Fix the logic of setting read_amp_bytes_per_bit from OPTIONS file (#7680)

Summary:
Instead of using `EncodeFixed32` which always serialize a integer to
little endian, we should use the local machine's endianness when
populating a native data structure during options parsing.
Without this fix, `read_amp_bytes_per_bit` may be populated incorrectly
on big-endian machines.

Pull Request resolved: https://github.com/facebook/rocksdb/pull/7680

Test Plan: make check

Reviewed By: pdillinger

Differential Revision: D24999166

Pulled By: riversand963

fbshipit-source-id: dc603cff6e17f8fa32479ce6df93b93082e6b0c4

.circleci/config.yml

@@ -2,283 +2,159 @@ version: 2.1
 
 orbs:
   win: circleci/windows@2.4.0
-  slack: circleci/slack@3.4.2
-
-aliases:
-  - &notify-on-master-failure
-    fail_only: true
-    only_for_branches: master
-
-commands:
-  install-pyenv-on-macos:
-    steps:
-      - run:
-          name: Install pyenv on macos
-          command: |
-            HOMEBREW_NO_AUTO_UPDATE=1 brew install pyenv
-
-  install-cmake-on-macos:
-    steps:
-      - run:
-          name: Install cmake on macos
-          command: |
-            HOMEBREW_NO_AUTO_UPDATE=1 brew install cmake
-
-  increase-max-open-files-on-macos:
-    steps:
-      - run:
-          name: Increase max open files
-          command: |
-            sudo sysctl -w kern.maxfiles=1048576
-            sudo sysctl -w kern.maxfilesperproc=1048576
-            sudo launchctl limit maxfiles 1048576
-
-  pre-steps:
-    parameters:
-      python-version:
-        default: "3.5.9"
-        type: string
-    steps:
-      - checkout
-      - run: pyenv install --skip-existing <<parameters.python-version>>
-      - run: pyenv global <<parameters.python-version>>
-      - run:
-          name: Setup Environment Variables
-          command: |
-            echo "export GTEST_THROW_ON_FAILURE=0" >> $BASH_ENV
-            echo "export GTEST_OUTPUT=\"xml:/tmp/test-results/\"" >> $BASH_ENV
-            echo "export SKIP_FORMAT_BUCK_CHECKS=1" >> $BASH_ENV
-            echo "export PRINT_PARALLEL_OUTPUTS=1" >> $BASH_ENV
-
-  pre-steps-macos:
-      steps:
-        - pre-steps:
-            python-version: "3.6.0"
-
-  post-steps:
-    steps:
-      - slack/status: *notify-on-master-failure
-      - store_test_results: # store test result if there's any
-          path: /tmp/test-results
-      - store_artifacts: # store LOG for debugging if there's any
-          path: LOG
-
-  install-clang-10:
-    steps:
-      - run:
-          name: Install Clang 10
-          command: |
-            echo "deb http://apt.llvm.org/xenial/ llvm-toolchain-xenial-10 main" | sudo tee -a /etc/apt/sources.list
-            echo "deb-src http://apt.llvm.org/xenial/ llvm-toolchain-xenial-10 main" | sudo tee -a /etc/apt/sources.list
-            echo "APT::Acquire::Retries \"10\";" | sudo tee -a /etc/apt/apt.conf.d/80-retries # llvm.org unreliable
-            sudo apt-get update -y && sudo apt-get install -y clang-10
-
-  install-gflags:
-    steps:
-      - run:
-          name: Install gflags
-          command: |
-            sudo apt-get update -y && sudo apt-get install -y libgflags-dev
-  
-  install-gflags-on-macos:
-    steps:
-      - run:
-          name: Install gflags on macos
-          command: |
-            HOMEBREW_NO_AUTO_UPDATE=1 brew install gflags
-
-  install-gtest-parallel:
-    steps:
-      - run:
-          name: Install gtest-parallel
-          command: |
-            git clone --single-branch --branch master --depth 1 https://github.com/google/gtest-parallel.git ~/gtest-parallel
-            echo "export PATH=$HOME/gtest-parallel:$PATH" >> $BASH_ENV
 
 executors:
   windows-2xlarge:
     machine:
-      image: 'windows-server-2019-vs2019:stable'
+      image: 'windows-server-2019-vs2019:201908-06'
       resource_class: windows.2xlarge
       shell: bash.exe
 
 jobs:
-  build-macos:
-    macos:
-      xcode: 9.4.1
-    steps:
-      - increase-max-open-files-on-macos
-      - install-pyenv-on-macos
-      - install-gflags-on-macos
-      - pre-steps-macos
-      - run: ulimit -S -n 1048576 && OPT=-DCIRCLECI make V=1 J=32 -j32 check | .circleci/cat_ignore_eagain
-      - post-steps
-
-  build-macos-cmake:
-    macos:
-      xcode: 9.4.1
-    steps:
-      - increase-max-open-files-on-macos
-      - install-pyenv-on-macos
-      - install-cmake-on-macos
-      - install-gflags-on-macos
-      - pre-steps-macos
-      - run: ulimit -S -n 1048576 && (mkdir build && cd build && cmake -DWITH_GFLAGS=0 .. && make V=1 -j32) | .circleci/cat_ignore_eagain
-      - post-steps
-
   build-linux:
     machine:
-      image: ubuntu-1604:202007-01
+      image: ubuntu-1604:201903-01
     resource_class: 2xlarge
     steps:
-      - pre-steps
-      - install-gflags
-      - run: make V=1 J=32 -j32 check | .circleci/cat_ignore_eagain
-      - post-steps
-
-  build-linux-mem-env:
-    machine:
-      image: ubuntu-1604:202007-01
-    resource_class: 2xlarge
-    steps:
-      - pre-steps
-      - install-gflags
-      - run: MEM_ENV=1 make V=1 J=32 -j32 check | .circleci/cat_ignore_eagain
-      - post-steps
-
-  build-linux-encrypted-env:
-    machine:
-      image: ubuntu-1604:202007-01
-    resource_class: 2xlarge
-    steps:
-      - pre-steps
-      - install-gflags
-      - run: ENCRYPTED_ENV=1 make V=1 J=32 -j32 check | .circleci/cat_ignore_eagain
-      - post-steps
+      - checkout # check out the code in the project directory
+      - run: pyenv global 3.5.2
+      - run: sudo apt-get update -y && sudo apt-get install -y libgflags-dev
+      - run: SKIP_FORMAT_BUCK_CHECKS=1 PRINT_PARALLEL_OUTPUTS=1 GTEST_THROW_ON_FAILURE=0 GTEST_OUTPUT="xml:/tmp/test-results/" make V=1 J=32 -j32 check | .circleci/cat_ignore_eagain
+      - store_test_results:
+          path: /tmp/test-results
 
   build-linux-shared_lib-alt_namespace-status_checked:
     machine:
-      image: ubuntu-1604:202007-01
+      image: ubuntu-1604:201903-01
     resource_class: 2xlarge
     steps:
-      - pre-steps
-      - install-gflags
-      - run: ASSERT_STATUS_CHECKED=1 TEST_UINT128_COMPAT=1 ROCKSDB_MODIFY_NPHASH=1 LIB_MODE=shared OPT="-DROCKSDB_NAMESPACE=alternative_rocksdb_ns" make V=1 -j32 all check_some | .circleci/cat_ignore_eagain
-      - post-steps
+      - checkout # check out the code in the project directory
+      - run: pyenv global 3.5.2
+      - run: sudo apt-get update -y && sudo apt-get install -y libgflags-dev
+      - run: SKIP_FORMAT_BUCK_CHECKS=1 PRINT_PARALLEL_OUTPUTS=1 ASSERT_STATUS_CHECKED=1 TEST_UINT128_COMPAT=1 LIB_MODE=shared OPT="-DROCKSDB_NAMESPACE=alternative_rocksdb_ns" GTEST_THROW_ON_FAILURE=0 GTEST_OUTPUT="xml:/tmp/test-results/" make V=1 -j32 all check_some | .circleci/cat_ignore_eagain
+      - store_test_results:
+          path: /tmp/test-results
 
   build-linux-release:
     machine:
-      image: ubuntu-1604:202007-01
+      image: ubuntu-1604:201903-01
     resource_class: 2xlarge
     steps:
       - checkout # check out the code in the project directory
       - run: make V=1 -j32 release | .circleci/cat_ignore_eagain
       - run: if ./db_stress --version; then false; else true; fi # ensure without gflags
-      - install-gflags
+      - run: sudo apt-get update -y && sudo apt-get install -y libgflags-dev
       - run: make V=1 -j32 release | .circleci/cat_ignore_eagain
       - run: ./db_stress --version # ensure with gflags
-      - post-steps
 
-  build-linux-release-rtti:
+  build-linux-lite:
+    machine:
+      image: ubuntu-1604:201903-01
+    resource_class: 2xlarge
+    steps:
+      - checkout # check out the code in the project directory
+      - run: pyenv global 3.5.2
+      - run: sudo apt-get update -y && sudo apt-get install -y libgflags-dev
+      - run: SKIP_FORMAT_BUCK_CHECKS=1 PRINT_PARALLEL_OUTPUTS=1 LITE=1 GTEST_THROW_ON_FAILURE=0 GTEST_OUTPUT="xml:/tmp/test-results/" make V=1 J=32 -j32 check | .circleci/cat_ignore_eagain
+      - store_test_results:
+          path: /tmp/test-results
+
+  build-linux-lite-release:
     machine:
       image: ubuntu-1604:201903-01
     resource_class: large
     steps:
       - checkout # check out the code in the project directory
-      - run: make clean
-      - run: USE_RTTI=1 DEBUG_LEVEL=0 make V=1 -j16 static_lib tools db_bench | .circleci/cat_ignore_eagain
+      - run: LITE=1 make V=1 -j32 release | .circleci/cat_ignore_eagain
       - run: if ./db_stress --version; then false; else true; fi # ensure without gflags
       - run: sudo apt-get update -y && sudo apt-get install -y libgflags-dev
-      - run: make clean
-      - run: USE_RTTI=1 DEBUG_LEVEL=0 make V=1 -j16 static_lib tools db_bench | .circleci/cat_ignore_eagain
-      - run: ./db_stress --version # ensure with gflags
-
-  build-linux-lite:
-    machine:
-      image: ubuntu-1604:202007-01
-    resource_class: 2xlarge
-    steps:
-      - pre-steps
-      - install-gflags
-      - run: LITE=1 make V=1 J=32 -j32 check | .circleci/cat_ignore_eagain
-      - post-steps
-
-  build-linux-lite-release:
-    machine:
-      image: ubuntu-1604:202007-01
-    resource_class: large
-    steps:
-      - checkout # check out the code in the project directory
-      - run: LITE=1 make V=1 -j32 release | .circleci/cat_ignore_eagain
-      - run: if ./db_stress --version; then false; else true; fi # ensure without gflags
-      - install-gflags
       - run: LITE=1 make V=1 -j32 release | .circleci/cat_ignore_eagain
       - run: ./db_stress --version # ensure with gflags
-      - post-steps
 
   build-linux-clang-no-test:
     machine:
-      image: ubuntu-1604:202007-01
+      image: ubuntu-1604:201903-01
     resource_class: 2xlarge
     steps:
       - checkout # check out the code in the project directory
       - run: sudo apt-get update -y && sudo apt-get install -y clang libgflags-dev
       - run: CC=clang CXX=clang++ USE_CLANG=1 PORTABLE=1 make V=1 -j32 all | .circleci/cat_ignore_eagain
-      - post-steps
+
+  build-linux-clang10-no-test:
+    machine:
+      image: ubuntu-1604:201903-01
+    resource_class: 2xlarge
+    steps:
+      - checkout # check out the code in the project directory
+      - run: echo "deb http://apt.llvm.org/xenial/ llvm-toolchain-xenial-10 main" | sudo tee -a /etc/apt/sources.list
+      - run: echo "deb-src http://apt.llvm.org/xenial/ llvm-toolchain-xenial-10 main" | sudo tee -a /etc/apt/sources.list
+      - run: echo "APT::Acquire::Retries \"10\";" | sudo tee -a /etc/apt/apt.conf.d/80-retries # llvm.org unreliable
+      - run: sudo apt-get update -y && sudo apt-get install -y clang-10 libgflags-dev
+      - run: CC=clang-10 CXX=clang++-10 ROCKSDB_DISABLE_ALIGNED_NEW=1 USE_CLANG=1 make V=1 -j32 all | .circleci/cat_ignore_eagain # aligned new doesn't work for reason we haven't figured out
 
   build-linux-clang10-asan:
     machine:
-      image: ubuntu-1604:202007-01
+      image: ubuntu-1604:201903-01
     resource_class: 2xlarge
     steps:
-      - pre-steps
-      - install-gflags
-      - install-clang-10
-      - run: COMPILE_WITH_ASAN=1 CC=clang-10 CXX=clang++-10 ROCKSDB_DISABLE_ALIGNED_NEW=1 USE_CLANG=1 make V=1 -j32 check | .circleci/cat_ignore_eagain # aligned new doesn't work for reason we haven't figured out
-      - post-steps
+      - checkout # check out the code in the project directory
+      - run: pyenv global 3.5.2
+      - run: echo "deb http://apt.llvm.org/xenial/ llvm-toolchain-xenial-10 main" | sudo tee -a /etc/apt/sources.list
+      - run: echo "deb-src http://apt.llvm.org/xenial/ llvm-toolchain-xenial-10 main" | sudo tee -a /etc/apt/sources.list
+      - run: echo "APT::Acquire::Retries \"10\";" | sudo tee -a /etc/apt/apt.conf.d/80-retries # llvm.org unreliable
+      - run: sudo apt-get update -y && sudo apt-get install -y clang-10 libgflags-dev
+      - run: SKIP_FORMAT_BUCK_CHECKS=1 COMPILE_WITH_ASAN=1 CC=clang-10 CXX=clang++-10 ROCKSDB_DISABLE_ALIGNED_NEW=1 USE_CLANG=1 PRINT_PARALLEL_OUTPUTS=1 GTEST_THROW_ON_FAILURE=0 GTEST_OUTPUT="xml:/tmp/test-results/" make V=1 -j32 check | .circleci/cat_ignore_eagain # aligned new doesn't work for reason we haven't figured out
+      - store_test_results:
+          path: /tmp/test-results
 
   build-linux-clang10-mini-tsan:
     machine:
-      image: ubuntu-1604:202007-01
+      image: ubuntu-1604:201903-01
     resource_class: 2xlarge
     steps:
-      - pre-steps
-      - install-gflags
-      - install-clang-10
-      - run: COMPILE_WITH_TSAN=1 CC=clang-10 CXX=clang++-10 ROCKSDB_DISABLE_ALIGNED_NEW=1 USE_CLANG=1 make V=1 -j32 check | .circleci/cat_ignore_eagain # aligned new doesn't work for reason we haven't figured out.
-      - post-steps
+      - checkout # check out the code in the project directory
+      - run: pyenv global 3.5.2
+      - run: echo "deb http://apt.llvm.org/xenial/ llvm-toolchain-xenial-10 main" | sudo tee -a /etc/apt/sources.list
+      - run: echo "deb-src http://apt.llvm.org/xenial/ llvm-toolchain-xenial-10 main" | sudo tee -a /etc/apt/sources.list
+      - run: echo "APT::Acquire::Retries \"10\";" | sudo tee -a /etc/apt/apt.conf.d/80-retries # llvm.org unreliable
+      - run: sudo apt-get update -y && sudo apt-get install -y clang-10 libgflags-dev
+      - run: SKIP_FORMAT_BUCK_CHECKS=1 COMPILE_WITH_TSAN=1 CC=clang-10 CXX=clang++-10 ROCKSDB_DISABLE_ALIGNED_NEW=1 USE_CLANG=1 PRINT_PARALLEL_OUTPUTS=1 EXCLUDE_TESTS_REGEX="TransactionStressTest|SnapshotConcurrentAccess|SeqAdvanceConcurrent|DeadlockStress|MultiThreadedDBTest.MultiThreaded|WriteUnpreparedStressTest.ReadYourOwnWriteStress|DBAsBaseDB/TransactionStressTest|FlushCloseWALFiles|BackgroundPurgeCFDropTest" GTEST_THROW_ON_FAILURE=0 GTEST_OUTPUT="xml:/tmp/test-results/" make V=1 -j32 check | .circleci/cat_ignore_eagain # aligned new doesn't work for reason we haven't figured out. Exclude FlushCloseWALFiles and BackgroundPurgeCFDropTest for occasional failures.
+      - store_test_results:
+          path: /tmp/test-results
 
   build-linux-clang10-ubsan:
     machine:
-      image: ubuntu-1604:202007-01
+      image: ubuntu-1604:201903-01
     resource_class: 2xlarge
     steps:
-      - pre-steps
-      - install-gflags
-      - install-clang-10
-      - run: COMPILE_WITH_UBSAN=1 OPT="-fsanitize-blacklist=.circleci/ubsan_suppression_list.txt" CC=clang-10 CXX=clang++-10 ROCKSDB_DISABLE_ALIGNED_NEW=1 USE_CLANG=1 make V=1 -j32 ubsan_check | .circleci/cat_ignore_eagain # aligned new doesn't work for reason we haven't figured out
-      - post-steps
+      - checkout # check out the code in the project directory
+      - run: pyenv global 3.5.2
+      - run: echo "deb http://apt.llvm.org/xenial/ llvm-toolchain-xenial-10 main" | sudo tee -a /etc/apt/sources.list
+      - run: echo "deb-src http://apt.llvm.org/xenial/ llvm-toolchain-xenial-10 main" | sudo tee -a /etc/apt/sources.list
+      - run: echo "APT::Acquire::Retries \"10\";" | sudo tee -a /etc/apt/apt.conf.d/80-retries # llvm.org unreliable
+      - run: sudo apt-get update -y && sudo apt-get install -y clang-10 libgflags-dev
+      - run: SKIP_FORMAT_BUCK_CHECKS=1 COMPILE_WITH_UBSAN=1 OPT="-fsanitize-blacklist=.circleci/ubsan_suppression_list.txt" CC=clang-10 CXX=clang++-10 ROCKSDB_DISABLE_ALIGNED_NEW=1 USE_CLANG=1 PRINT_PARALLEL_OUTPUTS=1 make V=1 -j32 ubsan_check | .circleci/cat_ignore_eagain # aligned new doesn't work for reason we haven't figured out
 
   build-linux-clang10-clang-analyze:
     machine:
-      image: ubuntu-1604:202007-01
+      image: ubuntu-1604:201903-01
     resource_class: 2xlarge
     steps:
-      - pre-steps
-      - install-gflags
-      - install-clang-10
-      - run: sudo apt-get update -y && sudo apt-get install -y clang-tools-10
-      - run: CC=clang-10 CXX=clang++-10 ROCKSDB_DISABLE_ALIGNED_NEW=1 CLANG_ANALYZER="/usr/bin/clang++-10" CLANG_SCAN_BUILD=scan-build-10 USE_CLANG=1 make V=1 -j32 analyze | .circleci/cat_ignore_eagain # aligned new doesn't work for reason we haven't figured out. For unknown, reason passing "clang++-10" as CLANG_ANALYZER doesn't work, and we need a full path.
-      - post-steps
+      - checkout # check out the code in the project directory
+      - run: pyenv global 3.5.2
+      - run: echo "deb http://apt.llvm.org/xenial/ llvm-toolchain-xenial-10 main" | sudo tee -a /etc/apt/sources.list
+      - run: echo "deb-src http://apt.llvm.org/xenial/ llvm-toolchain-xenial-10 main" | sudo tee -a /etc/apt/sources.list
+      - run: echo "APT::Acquire::Retries \"10\";" | sudo tee -a /etc/apt/apt.conf.d/80-retries # llvm.org unreliable
+      - run: sudo apt-get update -y && sudo apt-get install -y clang-10 libgflags-dev clang-tools-10
+      - run: SKIP_FORMAT_BUCK_CHECKS=1 CC=clang-10 CXX=clang++-10 ROCKSDB_DISABLE_ALIGNED_NEW=1 CLANG_ANALYZER="/usr/bin/clang++-10" CLANG_SCAN_BUILD=scan-build-10 USE_CLANG=1 PRINT_PARALLEL_OUTPUTS=1 make V=1 -j32 analyze | .circleci/cat_ignore_eagain # aligned new doesn't work for reason we haven't figured out. For unknown, reason passing "clang++-10" as CLANG_ANALYZER doesn't work, and we need a full path.
 
   build-linux-cmake:
     machine:
-      image: ubuntu-1604:202007-01
+      image: ubuntu-1604:201903-01
     resource_class: 2xlarge
     steps:
       - checkout # check out the code in the project directory
       - run: (mkdir build && cd build && cmake -DWITH_GFLAGS=0 .. && make V=1 -j32) | .circleci/cat_ignore_eagain
-      - post-steps
 
   build-linux-unity:
     docker: # executor type
@@ -288,17 +164,16 @@ jobs:
       - checkout # check out the code in the project directory
       - run: apt-get update -y && apt-get install -y libgflags-dev
       - run: TEST_TMPDIR=/dev/shm && make V=1 -j16 unity_test | .circleci/cat_ignore_eagain
-      - post-steps
 
   build-linux-gcc-4-8:
     machine:
-      image: ubuntu-1604:202007-01
+      image: ubuntu-1604:201903-01
     resource_class: large
     steps:
-      - pre-steps
+      - checkout
+      - run: pyenv global 3.5.2
       - run: sudo apt-get update -y && sudo apt-get install gcc-4.8 g++-4.8 libgflags-dev
       - run: CC=gcc-4.8 CXX=g++-4.8 V=1 SKIP_LINK=1 make -j4 all | .circleci/cat_ignore_eagain # Linking broken because libgflags compiled with newer ABI
-      - post-steps
 
   build-windows:
     executor: windows-2xlarge
@@ -359,119 +234,42 @@ jobs:
           name: "Test RocksDB"
           shell: powershell.exe
           command: |
-            build_tools\run_ci_db_test.ps1 -SuiteRun db_basic_test,db_test,db_test2,db_merge_operand_test,bloom_test,c_test,coding_test,crc32c_test,dynamic_bloom_test,env_basic_test,env_test,hash_test,random_test -Concurrency 16
+            build_tools\run_ci_db_test.ps1 -SuiteRun db_basic_test,db_test,db_test2,env_basic_test,env_test,db_merge_operand_test -Concurrency 16
 
   build-linux-java:
     machine:
-      image: ubuntu-1604:202007-01
-    resource_class: large
-    environment:
-      JAVA_HOME: /usr/lib/jvm/java-1.8.0-openjdk-amd64
+      image: ubuntu-1604:201903-01
+    resource_class: 2xlarge
     steps:
-      - pre-steps
-      - install-gflags
+      - checkout
+      - run: pyenv global 3.5.2
+      - run: sudo apt-get update -y && sudo apt-get install -y libgflags-dev
       - run:
-          name: "Set Java Environment"
+          name: "Build RocksDBJava"
           command: |
+            export JAVA_HOME=/usr/lib/jvm/jdk1.8.0
+            export PATH=$JAVA_HOME/bin:$PATH
             echo "JAVA_HOME=${JAVA_HOME}"
-            echo 'export PATH=$JAVA_HOME/bin:$PATH' >> $BASH_ENV
             which java && java -version
             which javac && javac -version
-      - run:
-          name: "Build RocksDBJava Shared Library"
-          command: make V=1 J=8 -j8 rocksdbjava | .circleci/cat_ignore_eagain
-      - run:
-          name: "Test RocksDBJava"
-          command: make V=1 J=8 -j8 jtest | .circleci/cat_ignore_eagain
-      - post-steps
-
-  build-linux-java-static:
-    machine:
-      image: ubuntu-1604:202007-01
-    resource_class: large
-    environment:
-      JAVA_HOME: /usr/lib/jvm/java-1.8.0-openjdk-amd64
-    steps:
-      - pre-steps
-      - install-gflags
-      - run:
-          name: "Set Java Environment"
-          command: |
-            echo "JAVA_HOME=${JAVA_HOME}"
-            echo 'export PATH=$JAVA_HOME/bin:$PATH' >> $BASH_ENV
-            which java && java -version
-            which javac && javac -version
-      - run:
-          name: "Build RocksDBJava Static Library"
-          command: make V=1 J=8 -j8 rocksdbjavastatic | .circleci/cat_ignore_eagain
-      - post-steps
-
-  build-macos-java:
-    macos:
-      xcode: 9.4.1
-    resource_class: medium
-    environment:
-      JAVA_HOME: /Library/Java/JavaVirtualMachines/jdk1.8.0_172.jdk/Contents/Home
-    steps:
-      - increase-max-open-files-on-macos
-      - install-pyenv-on-macos
-      - install-gflags-on-macos
-      - pre-steps-macos
-      - run:
-          name: "Set Java Environment"
-          command: |
-            echo "JAVA_HOME=${JAVA_HOME}"
-            echo 'export PATH=$JAVA_HOME/bin:$PATH' >> $BASH_ENV
-            which java && java -version
-            which javac && javac -version
-      - run:
-          name: "Build RocksDBJava Shared Library"
-          command: make V=1 J=8 -j8 rocksdbjava | .circleci/cat_ignore_eagain
-      - run:
-          name: "Test RocksDBJava"
-          command: make V=1 J=8 -j8 jtest | .circleci/cat_ignore_eagain
-      - post-steps
-
-  build-macos-java-static:
-    macos:
-      xcode: 9.4.1
-    resource_class: medium
-    environment:
-      JAVA_HOME: /Library/Java/JavaVirtualMachines/jdk1.8.0_172.jdk/Contents/Home
-    steps:
-      - increase-max-open-files-on-macos
-      - install-pyenv-on-macos
-      - install-gflags-on-macos
-      - install-cmake-on-macos
-      - pre-steps-macos
-      - run:
-          name: "Set Java Environment"
-          command: |
-            echo "JAVA_HOME=${JAVA_HOME}"
-            echo 'export PATH=$JAVA_HOME/bin:$PATH' >> $BASH_ENV
-            which java && java -version
-            which javac && javac -version
-      - run:
-          name: "Build RocksDBJava Static Library"
-          command: make V=1 J=8 -j8 rocksdbjavastatic | .circleci/cat_ignore_eagain
-      - post-steps
+            SKIP_FORMAT_BUCK_CHECKS=1 PRINT_PARALLEL_OUTPUTS=1 make V=1 J=32 -j32 rocksdbjava jtest | .circleci/cat_ignore_eagain
 
   build-examples:
     machine:
-      image: ubuntu-1604:202007-01
+      image: ubuntu-1604:201903-01
     resource_class: medium
     steps:
-      - pre-steps
-      - install-gflags
+      - checkout # check out the code in the project directory
+      - run: pyenv global 3.5.2
+      - run: sudo apt-get update -y && sudo apt-get install -y libgflags-dev
       - run:
           name: "Build examples"
           command: |
             OPT=-DTRAVIS V=1 make -j4 static_lib && cd examples && make -j4 | ../.circleci/cat_ignore_eagain
-      - post-steps
 
   build-linux-non-shm:
     machine:
-      image: ubuntu-1604:202007-01
+      image: ubuntu-1604:201903-01
     resource_class: 2xlarge
     parameters:
       start_test:
@@ -481,34 +279,18 @@ jobs:
         default: ""
         type: string
     steps:
-      - pre-steps
-      - install-gflags
-      - install-gtest-parallel
+      - checkout # checkout the code in the project directory
+      - run: pyenv global 3.5.2
+      - run: sudo apt-get update -y && sudo apt-get install -y libgflags-dev
       - run:
-          name: "Build unit tests"
+          name: "Build and unit tests on non-shm"
           command: |
-            echo "env: $(env)"
-            echo "** done env"
-            ROCKSDBTESTS_START=<<parameters.start_test>> ROCKSDBTESTS_END=<<parameters.end_test>> ROCKSDBTESTS_SUBSET_TESTS_TO_FILE=/tmp/test_list make V=1 -j32 --output-sync=target build_subset_tests
-      - run:
-          name: "Run unit tests in parallel"
-          command: |
-            sed -i 's/[[:space:]]*$//; s/ / \.\//g; s/.*/.\/&/' /tmp/test_list
-            cat /tmp/test_list
-            export TEST_TMPDIR=/tmp/rocksdb_test_tmp
-            /usr/bin/python ../gtest-parallel/gtest-parallel $(</tmp/test_list) --output_dir=/tmp | cat  # pipe to cat to continuously output status on circleci UI. Otherwise, no status will be printed while the job is running.
-      - post-steps
+            TMPD=/tmp/rocksdb_test_tmp ROCKSDBTESTS_START=<<parameters.start_test>> ROCKSDBTESTS_END=<<parameters.end_test>> make V=1 J=32 -j32 check_some | .circleci/cat_ignore_eagain
 
 workflows:
   build-linux:
     jobs:
       - build-linux
-  build-linux-mem-env:
-    jobs:
-      - build-linux-mem-env
-  build-linux-encrypted-env:
-    jobs:
-      - build-linux-encrypted-env
   build-linux-shared_lib-alt_namespace-status_checked:
     jobs:
       - build-linux-shared_lib-alt_namespace-status_checked
@@ -518,15 +300,15 @@ workflows:
   build-linux-release:
     jobs:
       - build-linux-release
-  build-linux-release-rtti:
-    jobs:
-      - build-linux-release-rtti
   build-linux-lite-release:
     jobs:
       - build-linux-lite-release
   build-linux-clang-no-test:
     jobs:
       - build-linux-clang-no-test
+  build-linux-clang10-no-test:
+    jobs:
+      - build-linux-clang10-no-test
   build-linux-clang10-asan:
     jobs:
       - build-linux-clang10-asan
@@ -565,29 +347,29 @@ workflows:
   build-java:
     jobs:
       - build-linux-java
-      - build-linux-java-static
-      - build-macos-java
-      - build-macos-java-static
   build-examples:
     jobs:
       - build-examples
-  build-linux-non-shm:
+  build-linux-non-shm-1:
     jobs:
       - build-linux-non-shm:
           start_test: ""
-          end_test: "db_options_test" # make sure unique in src.mk
+          end_test: "db_tailing_iter_test" # make sure unique in src.mk
+  build-linux-non-shm-2:
+    jobs:
       - build-linux-non-shm:
-          start_test: "db_options_test" # make sure unique in src.mk
-          end_test: "filename_test" # make sure unique in src.mk
+          start_test: "db_tailing_iter_test" # make sure unique in src.mk
+          end_test: "db_test2" # make sure unique in src.mk
+  build-linux-non-shm-3:
+    jobs:
       - build-linux-non-shm:
-          start_test: "filename_test" # make sure unique in src.mk
-          end_test: "statistics_test" # make sure unique in src.mk
+          start_test: "db_test2" # make sure unique in src.mk
+          end_test: "arena_test" # make sure unique in src.mk
+  build-linux-non-shm-4:
+    jobs:
       - build-linux-non-shm:
-          start_test: "statistics_test" # make sure unique in src.mk
+          start_test: "compact_on_deletion_collector_test" # make sure unique in src.mk
           end_test: ""
   build-linux-gcc-4-8:
     jobs:
       - build-linux-gcc-4-8
-  build-macos:
-    jobs:
-      - build-macos

.circleci/vs2015_install.ps1

@@ -10,7 +10,7 @@ $process = Start-Process "${PWD}\vs_installer.exe" -ArgumentList $VS_INSTALL_ARG
 Remove-Item -Path vs_installer.exe -Force
 $exitCode = $process.ExitCode
 if (($exitCode -ne 0) -and ($exitCode -ne 3010)) {
-    echo "VS 2015 installer exited with code $exitCode, which should be one of [0, 3010]."
+    echo "VS 2017 installer exited with code $exitCode, which should be one of [0, 3010]."
     curl.exe --retry 3 -kL $COLLECT_DOWNLOAD_LINK --output Collect.exe
     if ($LASTEXITCODE -ne 0) {
         echo "Download of the VS Collect tool failed."

.github/workflows/sanity_check.yml

@@ -32,7 +32,7 @@ jobs:
     - name: Download clang-format-diff.py
       uses: wei/wget@v1
       with:
-        args: https://raw.githubusercontent.com/llvm/llvm-project/master/clang/tools/clang-format/clang-format-diff.py
+        args: https://raw.githubusercontent.com/llvm-mirror/clang/master/tools/clang-format/clang-format-diff.py
 
     - name: Check format
       run: VERBOSE_CHECK=1 make check-format

.gitignore

@@ -8,7 +8,6 @@ rocksdb.pc
 *.gcda
 *.gcno
 *.o
-*.o.tmp
 *.so
 *.so.*
 *_test

.travis.yml

@@ -100,11 +100,11 @@ matrix:
     arch: amd64
     env: JOB_NAME=cmake-gcc9
   # Exclude most osx, arm64 and ppc64le tests for pull requests, but build in branches
-  # Temporarily disable ppc64le cmake test while snapd is broken
+  # Temporarily disable ppc64le unit tests in PRs until Travis gets its act together (#6653)
   - if: type = pull_request AND commit_message !~ /FULL_CI/
     os: linux
     arch: ppc64le
-    env: JOB_NAME=cmake
+    env: TEST_GROUP=platform_dependent
   # NB: the cmake build is a partial java test
   - if: type = pull_request AND commit_message !~ /FULL_CI/
     os: osx

CMakeLists.txt

@@ -391,12 +391,6 @@ if(NOT WITH_DYNAMIC_EXTENSION)
   add_definitions(-DROCKSDB_NO_DYNAMIC_EXTENSION)
 endif()
 
-option(ASSERT_STATUS_CHECKED "build with assert status checked" OFF)
-if (ASSERT_STATUS_CHECKED)
-  message(STATUS "Build with assert status checked")
-  add_definitions(-DROCKSDB_ASSERT_STATUS_CHECKED)
-endif()
-
 if(DEFINED USE_RTTI)
   if(USE_RTTI)
     message(STATUS "Enabling RTTI")
@@ -571,12 +565,10 @@ set(SOURCES
         db/arena_wrapped_db_iter.cc
         db/blob/blob_file_addition.cc
         db/blob/blob_file_builder.cc
-        db/blob/blob_file_cache.cc
         db/blob/blob_file_garbage.cc
         db/blob/blob_file_meta.cc
-        db/blob/blob_file_reader.cc
         db/blob/blob_log_format.cc
-        db/blob/blob_log_sequential_reader.cc
+        db/blob/blob_log_reader.cc
         db/blob/blob_log_writer.cc
         db/builder.cc
         db/c.cc
@@ -622,8 +614,6 @@ set(SOURCES
         db/memtable_list.cc
         db/merge_helper.cc
         db/merge_operator.cc
-        db/output_validator.cc
-        db/periodic_work_scheduler.cc
         db/range_del_aggregator.cc
         db/range_tombstone_fragmenter.cc
         db/repair.cc
@@ -681,13 +671,12 @@ set(SOURCES
         monitoring/perf_level.cc
         monitoring/persistent_stats_history.cc
         monitoring/statistics.cc
+        monitoring/stats_dump_scheduler.cc
         monitoring/thread_status_impl.cc
         monitoring/thread_status_updater.cc
         monitoring/thread_status_util.cc
         monitoring/thread_status_util_debug.cc
         options/cf_options.cc
-        options/configurable.cc
-        options/customizable.cc
         options/db_options.cc
         options/options.cc
         options/options_helper.cc
@@ -738,7 +727,6 @@ set(SOURCES
         table/sst_file_dumper.cc
         table/sst_file_reader.cc
         table/sst_file_writer.cc
-        table/table_factory.cc
         table/table_properties.cc
         table/two_level_iterator.cc
         test_util/sync_point.cc
@@ -747,7 +735,6 @@ set(SOURCES
         test_util/transaction_test_util.cc
         tools/block_cache_analyzer/block_cache_trace_analyzer.cc
         tools/dump/db_dump_tool.cc
-        tools/io_tracer_parser_tool.cc
         tools/ldb_cmd.cc
         tools/ldb_tool.cc
         tools/sst_dump_tool.cc
@@ -811,9 +798,8 @@ set(SOURCES
         utilities/simulator_cache/sim_cache.cc
         utilities/table_properties_collectors/compact_on_deletion_collector.cc
         utilities/trace/file_trace_reader_writer.cc
-        utilities/transactions/lock/lock_manager.cc
-        utilities/transactions/lock/point/point_lock_tracker.cc
-        utilities/transactions/lock/point/point_lock_manager.cc
+        utilities/transactions/lock/lock_tracker.cc
+        utilities/transactions/lock/point_lock_tracker.cc
         utilities/transactions/optimistic_transaction_db_impl.cc
         utilities/transactions/optimistic_transaction.cc
         utilities/transactions/pessimistic_transaction.cc
@@ -821,6 +807,7 @@ set(SOURCES
         utilities/transactions/snapshot_checker.cc
         utilities/transactions/transaction_base.cc
         utilities/transactions/transaction_db_mutex_impl.cc
+        utilities/transactions/transaction_lock_mgr.cc
         utilities/transactions/transaction_util.cc
         utilities/transactions/write_prepared_txn.cc
         utilities/transactions/write_prepared_txn_db.cc
@@ -1046,10 +1033,7 @@ if(WITH_TESTS)
         cache/lru_cache_test.cc
         db/blob/blob_file_addition_test.cc
         db/blob/blob_file_builder_test.cc
-        db/blob/blob_file_cache_test.cc
         db/blob/blob_file_garbage_test.cc
-        db/blob/blob_file_reader_test.cc
-        db/blob/db_blob_basic_test.cc
         db/blob/db_blob_index_test.cc
         db/column_family_test.cc
         db/compact_files_test.cc
@@ -1109,7 +1093,6 @@ if(WITH_TESTS)
         db/merge_test.cc
         db/options_file_test.cc
         db/perf_context_test.cc
-        db/periodic_work_scheduler_test.cc
         db/plain_table_db_test.cc
         db/prefix_test.cc
         db/range_del_aggregator_test.cc
@@ -1141,9 +1124,8 @@ if(WITH_TESTS)
         monitoring/histogram_test.cc
         monitoring/iostats_context_test.cc
         monitoring/statistics_test.cc
+        monitoring/stats_dump_scheduler_test.cc
         monitoring/stats_history_test.cc
-        options/configurable_test.cc
-        options/customizable_test.cc
         options/options_settable_test.cc
         options/options_test.cc
         table/block_based/block_based_filter_block_test.cc
@@ -1162,7 +1144,6 @@ if(WITH_TESTS)
         test_util/testutil_test.cc
         trace_replay/io_tracer_test.cc
         tools/block_cache_analyzer/block_cache_trace_analyzer_test.cc
-        tools/io_tracer_parser_test.cc
         tools/ldb_cmd_test.cc
         tools/reduce_levels_test.cc
         tools/sst_dump_test.cc
@@ -1180,7 +1161,6 @@ if(WITH_TESTS)
         util/random_test.cc
         util/rate_limiter_test.cc
         util/repeatable_thread_test.cc
-        util/ribbon_test.cc
         util/slice_test.cc
         util/slice_transform_test.cc
         util/timer_queue_test.cc
@@ -1207,7 +1187,7 @@ if(WITH_TESTS)
         utilities/table_properties_collectors/compact_on_deletion_collector_test.cc
         utilities/transactions/optimistic_transaction_test.cc
         utilities/transactions/transaction_test.cc
-        utilities/transactions/lock/point/point_lock_manager_test.cc
+        utilities/transactions/transaction_lock_mgr_test.cc
         utilities/transactions/write_prepared_transaction_test.cc
         utilities/transactions/write_unprepared_transaction_test.cc
         utilities/ttl/ttl_test.cc

HISTORY.md

@@ -1,81 +1,24 @@
 # Rocksdb Change Log
-## 6.15.5 (02/05/2021)
+## 6.13.4 (11/15/2020)
 ### Bug Fixes
-* Since 6.15.0, `TransactionDB` returns error `Status`es from calls to `DeleteRange()` and calls to `Write()` where the `WriteBatch` contains a range deletion. Previously such operations may have succeeded while not providing the expected transactional guarantees. There are certain cases where range deletion can still be used on such DBs; see the API doc on `TransactionDB::DeleteRange()` for details.
-* `OptimisticTransactionDB` now returns error `Status`es from calls to `DeleteRange()` and calls to `Write()` where the `WriteBatch` contains a range deletion. Previously such operations may have succeeded while not providing the expected transactional guarantees.
-
-## 6.15.4 (01/21/2021)
-### Bug Fixes
-* Fix a race condition between DB startups and shutdowns in managing the periodic background worker threads. One effect of this race condition could be the process being terminated.
-
-## 6.15.3 (01/07/2021)
-### Bug Fixes
-* For Java builds, fix errors due to missing compression library includes.
-
-## 6.15.2 (12/22/2020)
-### Bug Fixes
-* Fix failing RocksJava test compilation and add CI jobs
-* Fix jemalloc compilation issue on macOS
-* Fix build issues - compatibility with older gcc, older jemalloc libraries, docker warning when building i686 binaries
-
-## 6.15.1 (12/01/2020)
-### Bug Fixes
-* Truncated WALs ending in incomplete records can no longer produce gaps in the recovered data when `WALRecoveryMode::kPointInTimeRecovery` is used. Gaps are still possible when WALs are truncated exactly on record boundaries.
-* Fix a bug where compressed blocks read by MultiGet are not inserted into the compressed block cache when use_direct_reads = true.
-
-## 6.15.0 (11/13/2020)
-### Bug Fixes
-* Fixed a bug in the following combination of features: indexes with user keys (`format_version >= 3`), indexes are partitioned (`index_type == kTwoLevelIndexSearch`), and some index partitions are pinned in memory (`BlockBasedTableOptions::pin_l0_filter_and_index_blocks_in_cache`). The bug could cause keys to be truncated when read from the index leading to wrong read results or other unexpected behavior.
-* Fixed a bug when indexes are partitioned (`index_type == kTwoLevelIndexSearch`), some index partitions are pinned in memory (`BlockBasedTableOptions::pin_l0_filter_and_index_blocks_in_cache`), and partitions reads could be mixed between block cache and directly from the file (e.g., with `enable_index_compression == 1` and `mmap_read == 1`, partitions that were stored uncompressed due to poor compression ratio would be read directly from the file via mmap, while partitions that were stored compressed would be read from block cache). The bug could cause index partitions to be mistakenly considered empty during reads leading to wrong read results.
-* Since 6.12, memtable lookup should report unrecognized value_type as corruption (#7121).
-* Since 6.14, fix false positive flush/compaction `Status::Corruption` failure when `paranoid_file_checks == true` and range tombstones were written to the compaction output files.
-* Since 6.14, fix a bug that could cause a stalled write to crash with mixed of slowdown and no_slowdown writes (`WriteOptions.no_slowdown=true`).
-* Fixed a bug which causes hang in closing DB when refit level is set in opt build. It was because ContinueBackgroundWork() was called in assert statement which is a no op. It was introduced in 6.14.
-* Fixed a bug which causes Get() to return incorrect result when a key's merge operand is applied twice. This can occur if the thread performing Get() runs concurrently with a background flush thread and another thread writing to the MANIFEST file (PR6069).
-* Reverted a behavior change silently introduced in 6.14.2, in which the effects of the `ignore_unknown_options` flag (used in option parsing/loading functions) changed.
-* Reverted a behavior change silently introduced in 6.14, in which options parsing/loading functions began returning `NotFound` instead of `InvalidArgument` for option names not available in the present version.
-* Fixed MultiGet bugs it doesn't return valid data with user defined timestamp.
-* Fixed a potential bug caused by evaluating `TableBuilder::NeedCompact()` before `TableBuilder::Finish()` in compaction job. For example, the `NeedCompact()` method of `CompactOnDeletionCollector` returned by built-in `CompactOnDeletionCollectorFactory` requires `BlockBasedTable::Finish()` to return the correct result. The bug can cause a compaction-generated file not to be marked for future compaction based on deletion ratio.
-* Fixed a seek issue with prefix extractor and timestamp.
 * Fixed a bug of encoding and parsing BlockBasedTableOptions::read_amp_bytes_per_bit as a 64-bit integer.
 * Fixed the logic of populating native data structure for `read_amp_bytes_per_bit` during OPTIONS file parsing on big-endian architecture. Without this fix, original code introduced in PR7659, when running on big-endian machine, can mistakenly store read_amp_bytes_per_bit (an uint32) in little endian format. Future access to `read_amp_bytes_per_bit` will give wrong values. Little endian architecture is not affected.
 
+## 6.13.3 (10/14/2020)
+### Bug Fixes
+* Fix a bug that could cause a stalled write to crash with mixed of slowdown and no_slowdown writes (`WriteOptions.no_slowdown=true`).
 
-### Public API Change
-* Deprecate `BlockBasedTableOptions::pin_l0_filter_and_index_blocks_in_cache` and `BlockBasedTableOptions::pin_top_level_index_and_filter`. These options still take effect until users migrate to the replacement APIs in `BlockBasedTableOptions::metadata_cache_options`. Migration guidance can be found in the API comments on the deprecated options.
-* Add new API `DB::VerifyFileChecksums` to verify SST file checksum with corresponding entries in the MANIFEST if present. Current implementation requires scanning and recomputing file checksums.
+## 6.13.2 (10/13/2020)
+### Bug Fixes
+* Fix false positive flush/compaction `Status::Corruption` failure when `paranoid_file_checks == true` and range tombstones were written to the compaction output files.
 
-### Behavior Changes
-* The dictionary compression settings specified in `ColumnFamilyOptions::compression_opts` now additionally affect files generated by flush and compaction to non-bottommost level. Previously those settings at most affected files generated by compaction to bottommost level, depending on whether `ColumnFamilyOptions::bottommost_compression_opts` overrode them. Users who relied on dictionary compression settings in `ColumnFamilyOptions::compression_opts` affecting only the bottommost level can keep the behavior by moving their dictionary settings to `ColumnFamilyOptions::bottommost_compression_opts` and setting its `enabled` flag.
-* When the `enabled` flag is set in `ColumnFamilyOptions::bottommost_compression_opts`, those compression options now take effect regardless of the value in `ColumnFamilyOptions::bottommost_compression`. Previously, those compression options only took effect when `ColumnFamilyOptions::bottommost_compression != kDisableCompressionOption`. Now, they additionally take effect when `ColumnFamilyOptions::bottommost_compression == kDisableCompressionOption` (such a setting causes bottommost compression type to fall back to `ColumnFamilyOptions::compression_per_level` if configured, and otherwise fall back to `ColumnFamilyOptions::compression`).
+## 6.13.1 (10/12/2020)
+### Bug Fixes
+* Since 6.12, memtable lookup should report unrecognized value_type as corruption (#7121).
+* Fixed a bug in the following combination of features: indexes with user keys (`format_version >= 3`), indexes are partitioned (`index_type == kTwoLevelIndexSearch`), and some index partitions are pinned in memory (`BlockBasedTableOptions::pin_l0_filter_and_index_blocks_in_cache`). The bug could cause keys to be truncated when read from the index leading to wrong read results or other unexpected behavior.
+* Fixed a bug when indexes are partitioned (`index_type == kTwoLevelIndexSearch`), some index partitions are pinned in memory (`BlockBasedTableOptions::pin_l0_filter_and_index_blocks_in_cache`), and partitions reads could be mixed between block cache and directly from the file (e.g., with `enable_index_compression == 1` and `mmap_read == 1`, partitions that were stored uncompressed due to poor compression ratio would be read directly from the file via mmap, while partitions that were stored compressed would be read from block cache). The bug could cause index partitions to be mistakenly considered empty during reads leading to wrong read results.
 
-### New Features
-* An EXPERIMENTAL new Bloom alternative that saves about 30% space compared to Bloom filters, with about 3-4x construction time and similar query times is available using NewExperimentalRibbonFilterPolicy.
-
-## 6.14 (10/09/2020)
-### Bug fixes
-* Fixed a bug after a `CompactRange()` with `CompactRangeOptions::change_level` set fails due to a conflict in the level change step, which caused all subsequent calls to `CompactRange()` with `CompactRangeOptions::change_level` set to incorrectly fail with a `Status::NotSupported("another thread is refitting")` error.
-* Fixed a bug that the bottom most level compaction could still be a trivial move even if `BottommostLevelCompaction.kForce` or `kForceOptimized` is set.
-
-### Public API Change
-* The methods to create and manage EncrypedEnv have been changed.  The EncryptionProvider is now passed to NewEncryptedEnv as a shared pointer, rather than a raw pointer.  Comparably, the CTREncryptedProvider now takes a shared pointer, rather than a reference, to a BlockCipher.  CreateFromString methods have been added to BlockCipher and EncryptionProvider to provide a single API by which different ciphers and providers can be created, respectively.
-* The internal classes (CTREncryptionProvider, ROT13BlockCipher, CTRCipherStream) associated with the EncryptedEnv have been moved out of the public API.  To create a CTREncryptionProvider, one can either use EncryptionProvider::NewCTRProvider, or EncryptionProvider::CreateFromString("CTR").  To create a new ROT13BlockCipher, one can either use BlockCipher::NewROT13Cipher or BlockCipher::CreateFromString("ROT13").
-* The EncryptionProvider::AddCipher method has been added to allow keys to be added to an EncryptionProvider.  This API will allow future providers to support multiple cipher keys.
-* Add a new option "allow_data_in_errors". When this new option is set by users, it allows users to opt-in to get error messages containing corrupted keys/values. Corrupt keys, values will be logged in the messages, logs, status etc. that will help users with the useful information regarding affected data. By default value of this option is set false to prevent users data to be exposed in the messages so currently, data will be redacted from logs, messages, status by default.
-* AdvancedColumnFamilyOptions::force_consistency_checks is now true by default, for more proactive DB corruption detection at virtually no cost (estimated two extra CPU cycles per million on a major production workload). Corruptions reported by these checks now mention "force_consistency_checks" in case a false positive corruption report is suspected and the option needs to be disabled (unlikely). Since existing column families have a saved setting for force_consistency_checks, only new column families will pick up the new default.
-
-### General Improvements
-* The settings of the DBOptions and ColumnFamilyOptions are now managed by Configurable objects (see New Features).  The same convenience methods to configure these options still exist but the backend implementation has been unified under a common implementation.
-
-### New Features
-* Methods to configure serialize, and compare -- such as TableFactory -- are exposed directly through the Configurable base class (from which these objects inherit).  This change will allow for better and more thorough configuration management and retrieval in the future.  The options for a Configurable object can be set via the ConfigureFromMap, ConfigureFromString, or ConfigureOption method.  The serialized version of the options of an object can be retrieved via the GetOptionString, ToString, or GetOption methods.  The list of options supported by an object can be obtained via the GetOptionNames method.  The "raw" object (such as the BlockBasedTableOption) for an option may be retrieved via the GetOptions method.  Configurable options can be compared via the AreEquivalent method.  The settings within a Configurable object may be validated via the ValidateOptions method.  The object may be intialized (at which point only mutable options may be updated) via the PrepareOptions method.
-* Introduce options.check_flush_compaction_key_order with default value to be true. With this option, during flush and compaction, key order will be checked when writing to each SST file. If the order is violated, the flush or compaction will fail.
-* Added is_full_compaction to CompactionJobStats, so that the information is available through the EventListener interface.
-* Add more stats for MultiGet in Histogram to get number of data blocks, index blocks, filter blocks and sst files read from file system per level.
-* SST files have a new table property called db_host_id, which is set to the hostname by default. A new option in DBOptions, db_host_id, allows the property value to be overridden with a user specified string, or disable it completely by making the option string empty.
-* Methods to create customizable extensions -- such as TableFactory -- are exposed directly through the Customizable base class (from which these objects inherit).  This change will allow these Customizable classes to be loaded and configured in a standard way (via CreateFromString).  More information on how to write and use Customizable classes is in the customizable.h header file.
-
-## 6.13 (09/12/2020)
+## 6.13 (09/24/2020)
 ### Bug fixes
 * Fix a performance regression introduced in 6.4 that makes a upper bound check for every Next() even if keys are within a data block that is within the upper bound.
 * Fix a possible corruption to the LSM state (overlapping files within a level) when a `CompactRange()` for refitting levels (`CompactRangeOptions::change_level == true`) and another manual compaction are executed in parallel.
@@ -110,7 +53,7 @@
 
 ### Behavior Changes
 * File abstraction `FSRandomAccessFile.Prefetch()` default return status is changed from `OK` to `NotSupported`. If the user inherited file doesn't implement prefetch, RocksDB will create internal prefetch buffer to improve read performance.
-* When retryabel IO error happens during Flush (manifest write error is excluded) and WAL is disabled, originally it is mapped to kHardError. Now,it is mapped to soft error. So DB will not stall the writes unless the memtable is full. At the same time, when auto resume is triggered to recover the retryable IO error during Flush, SwitchMemtable is not called to avoid generating to many small immutable memtables. If WAL is enabled, no behavior changes.
+* When retryable IO error happens during Flush (manifest write error is excluded) and WAL is disabled, originally it is mapped to kHardError. Now,it is mapped to soft error. So DB will not stall the writes unless the memtable is full. At the same time, when auto resume is triggered to recover the retryable IO error during Flush, SwitchMemtable is not called to avoid generating to many small immutable memtables. If WAL is enabled, no behavior changes.
 * When considering whether a table file is already backed up in a shared part of backup directory, BackupEngine would already query the sizes of source (DB) and pre-existing destination (backup) files. BackupEngine now uses these file sizes to detect corruption, as at least one of (a) old backup, (b) backup in progress, or (c) current DB is corrupt if there's a size mismatch.
 
 ### Others
@@ -125,6 +68,7 @@
 * `DB::OpenForReadOnly()` now returns `Status::NotFound` when the specified DB directory does not exist. Previously the error returned depended on the underlying `Env`. This change is available in all 6.11 releases as well.
 * A parameter `verify_with_checksum` is added to `BackupEngine::VerifyBackup`, which is false by default. If it is ture, `BackupEngine::VerifyBackup` verifies checksums and file sizes of backup files. Pass `false` for `verify_with_checksum` to maintain the previous behavior and performance of `BackupEngine::VerifyBackup`, by only verifying sizes of backup files.
 
+
 ### Behavior Changes
 * Best-efforts recovery ignores CURRENT file completely. If CURRENT file is missing during recovery, best-efforts recovery still proceeds with MANIFEST file(s).
 * In best-efforts recovery, an error that is not Corruption or IOError::kNotFound or IOError::kPathNotFound will be overwritten silently. Fix this by checking all non-ok cases and return early.

Makefile

@@ -99,14 +99,14 @@ endif
 
 ifneq ($(findstring rocksdbjava, $(MAKECMDGOALS)),)
 	LIB_MODE=shared
-	ifneq ($(findstring rocksdbjavastatic, $(MAKECMDGOALS)),)
+        ifneq ($(findstring rocksdbjavastatic, $(MAKECMDGOALS)),)
 		OBJ_DIR=jls
-		ifneq ($(DEBUG_LEVEL),2)
-			DEBUG_LEVEL=0
-		endif
-		ifeq ($(MAKECMDGOALS),rocksdbjavastaticpublish)
-			DEBUG_LEVEL=0
-		endif
+	        ifneq ($(DEBUG_LEVEL),2)
+	            DEBUG_LEVEL=0
+                endif
+                ifeq ($(MAKECMDGOALS),rocksdbjavastaticpublish)
+	            DEBUG_LEVEL=0
+                endif
 	else
 		OBJ_DIR=jl
 	endif
@@ -414,10 +414,6 @@ ifdef TEST_UINT128_COMPAT
   PLATFORM_CCFLAGS += -DTEST_UINT128_COMPAT=1
   PLATFORM_CXXFLAGS += -DTEST_UINT128_COMPAT=1
 endif
-ifdef ROCKSDB_MODIFY_NPHASH
-  PLATFORM_CCFLAGS += -DROCKSDB_MODIFY_NPHASH=1
-  PLATFORM_CXXFLAGS += -DROCKSDB_MODIFY_NPHASH=1
-endif
 
 # This (the first rule) must depend on "all".
 default: all
@@ -557,14 +553,13 @@ PARALLEL_TEST = \
 	persistent_cache_test \
 	table_test \
 	transaction_test \
-	point_lock_manager_test \
+	transaction_lock_mgr_test \
 	write_prepared_transaction_test \
 	write_unprepared_transaction_test \
 
 ifeq ($(USE_FOLLY_DISTRIBUTED_MUTEX),1)
 	TESTS += folly_synchronization_distributed_mutex_test
 	PARALLEL_TEST += folly_synchronization_distributed_mutex_test
-	TESTS_PASSING_ASC = folly_synchronization_distributed_mutex_test
 endif
 
 # options_settable_test doesn't pass with UBSAN as we use hack in the test
@@ -581,9 +576,7 @@ ifdef ASSERT_STATUS_CHECKED
 		lru_cache_test \
 		blob_file_addition_test \
 		blob_file_builder_test \
-		blob_file_cache_test \
 		blob_file_garbage_test \
-		blob_file_reader_test \
 		bloom_test \
 		cassandra_format_test \
 		cassandra_row_merge_test \
@@ -592,15 +585,6 @@ ifdef ASSERT_STATUS_CHECKED
 		coding_test \
 		crc32c_test \
 		dbformat_test \
-		db_basic_test \
-		db_blob_basic_test \
-		db_flush_test \
-		db_with_timestamp_basic_test \
-		db_with_timestamp_compaction_test \
-		db_options_test \
-		db_properties_test \
-		db_secondary_test \
-		options_file_test \
 		defer_test \
 		filename_test \
 		dynamic_bloom_test \
@@ -608,10 +592,7 @@ ifdef ASSERT_STATUS_CHECKED
 		env_test \
 		env_logger_test \
 		event_logger_test \
-		error_handler_fs_test \
-		auto_roll_logger_test \
 		file_indexer_test \
-		flush_job_test \
 		hash_table_test \
 		hash_test \
 		heap_test \
@@ -619,64 +600,33 @@ ifdef ASSERT_STATUS_CHECKED
 		inlineskiplist_test \
 		io_posix_test \
 		iostats_context_test \
-		ldb_cmd_test \
 		memkind_kmem_allocator_test \
 		merger_test \
 		mock_env_test \
 		object_registry_test \
-		prefix_test \
-		plain_table_db_test \
-		repair_test \
-		configurable_test \
-		customizable_test \
 		options_settable_test \
 		options_test \
 		random_test \
 		range_del_aggregator_test \
-		sst_file_reader_test \
 		range_tombstone_fragmenter_test \
 		repeatable_thread_test \
-		ribbon_test \
 		skiplist_test \
 		slice_test \
 		sst_dump_test \
 		statistics_test \
-		stats_history_test \
 		thread_local_test \
-		trace_analyzer_test \
 		env_timed_test \
 		filelock_test \
 		timer_queue_test \
 		timer_test \
-		options_util_test \
-		persistent_cache_test \
 		util_merge_operators_test \
 		block_cache_trace_analyzer_test \
 		block_cache_tracer_test \
 		cache_simulator_test \
 		sim_cache_test \
-		version_builder_test \
 		version_edit_test \
 		work_queue_test \
 		write_controller_test \
-		compaction_iterator_test \
-		compaction_job_test \
-		compaction_job_stats_test \
-	        io_tracer_test \
-		merge_helper_test \
-		memtable_list_test \
-		flush_job_test \
-		block_based_filter_block_test \
-		block_fetcher_test \
-		full_filter_block_test \
-		partitioned_filter_block_test \
-		column_family_test \
-		file_reader_writer_test \
-		corruption_test \
-		db_universal_compaction_test \
-		import_column_family_test \
-		memory_test \
-		table_test \
 
 ifeq ($(USE_FOLLY_DISTRIBUTED_MUTEX),1)
 TESTS_PASSING_ASC += folly_synchronization_distributed_mutex_test
@@ -684,18 +634,17 @@ endif
 
 	# Enable building all unit tests, but use check_some to run only tests
 	# known to pass ASC (ASSERT_STATUS_CHECKED)
-	ROCKSDBTESTS_SUBSET ?= $(TESTS_PASSING_ASC)
+	SUBSET := $(TESTS_PASSING_ASC)
 	# Alternate: only build unit tests known to pass ASC, and run them
 	# with make check
 	#TESTS := $(filter $(TESTS_PASSING_ASC),$(TESTS))
 	#PARALLEL_TEST := $(filter $(TESTS_PASSING_ASC),$(PARALLEL_TEST))
 else
-	ROCKSDBTESTS_SUBSET ?= $(TESTS)
+	SUBSET := $(TESTS)
 endif
 # Not necessarily well thought out or up-to-date, but matches old list
 TESTS_PLATFORM_DEPENDENT := \
 	db_basic_test \
-	db_blob_basic_test \
 	db_with_timestamp_basic_test \
 	db_encryption_test \
 	db_test2 \
@@ -714,7 +663,6 @@ TESTS_PLATFORM_DEPENDENT := \
 	io_posix_test \
 	hash_test \
 	random_test \
-	ribbon_test \
 	thread_local_test \
 	work_queue_test \
 	rate_limiter_test \
@@ -722,22 +670,22 @@ TESTS_PLATFORM_DEPENDENT := \
 	iostats_context_test \
 	db_wal_test \
 
-# Sort ROCKSDBTESTS_SUBSET for filtering, except db_test is special (expensive)
-# so is placed first (out-of-order)
-ROCKSDBTESTS_SUBSET := $(filter db_test, $(ROCKSDBTESTS_SUBSET)) $(sort $(filter-out db_test, $(ROCKSDBTESTS_SUBSET)))
+# Sort SUBSET for filtering, except db_test is special (expensive) so
+# is placed first (out-of-order)
+SUBSET := $(filter db_test, $(SUBSET)) $(sort $(filter-out db_test, $(SUBSET)))
 
 ifdef ROCKSDBTESTS_START
-        ROCKSDBTESTS_SUBSET := $(shell echo $(ROCKSDBTESTS_SUBSET) | sed 's/^.*$(ROCKSDBTESTS_START)/$(ROCKSDBTESTS_START)/')
+        SUBSET := $(shell echo $(SUBSET) | sed 's/^.*$(ROCKSDBTESTS_START)/$(ROCKSDBTESTS_START)/')
 endif
 
 ifdef ROCKSDBTESTS_END
-        ROCKSDBTESTS_SUBSET := $(shell echo $(ROCKSDBTESTS_SUBSET) | sed 's/$(ROCKSDBTESTS_END).*//')
+        SUBSET := $(shell echo $(SUBSET) | sed 's/$(ROCKSDBTESTS_END).*//')
 endif
 
 ifeq ($(ROCKSDBTESTS_PLATFORM_DEPENDENT), only)
-        ROCKSDBTESTS_SUBSET := $(filter $(TESTS_PLATFORM_DEPENDENT), $(ROCKSDBTESTS_SUBSET))
+        SUBSET := $(filter $(TESTS_PLATFORM_DEPENDENT), $(SUBSET))
 else ifeq ($(ROCKSDBTESTS_PLATFORM_DEPENDENT), exclude)
-        ROCKSDBTESTS_SUBSET := $(filter-out $(TESTS_PLATFORM_DEPENDENT), $(ROCKSDBTESTS_SUBSET))
+        SUBSET := $(filter-out $(TESTS_PLATFORM_DEPENDENT), $(SUBSET))
 endif
 
 # bench_tool_analyer main is in bench_tool_analyzer_tool, or this would be simpler...
@@ -839,7 +787,7 @@ endif  # PLATFORM_SHARED_EXT
 
 all: $(LIBRARY) $(BENCHMARKS) tools tools_lib test_libs $(TESTS)
 
-all_but_some_tests: $(LIBRARY) $(BENCHMARKS) tools tools_lib test_libs $(ROCKSDBTESTS_SUBSET)
+all_but_some_tests: $(LIBRARY) $(BENCHMARKS) tools tools_lib test_libs $(SUBSET)
 
 static_lib: $(STATIC_LIBRARY)
 
@@ -1057,8 +1005,8 @@ ifndef SKIP_FORMAT_BUCK_CHECKS
 endif
 
 # TODO add ldb_tests
-check_some: $(ROCKSDBTESTS_SUBSET)
-	for t in $(ROCKSDBTESTS_SUBSET); do echo "===== Running $$t (`date`)"; ./$$t || exit 1; done
+check_some: $(SUBSET)
+	for t in $(SUBSET); do echo "===== Running $$t (`date`)"; ./$$t || exit 1; done
 
 .PHONY: ldb_tests
 ldb_tests: ldb
@@ -1162,9 +1110,6 @@ ubsan_crash_test_with_best_efforts_recovery: clean
 valgrind_test:
 	ROCKSDB_VALGRIND_RUN=1 DISABLE_JEMALLOC=1 $(MAKE) valgrind_check
 
-valgrind_test_some:
-	ROCKSDB_VALGRIND_RUN=1 DISABLE_JEMALLOC=1 $(MAKE) valgrind_check_some
-
 valgrind_check: $(TESTS)
 	$(MAKE) DRIVER="$(VALGRIND_VER) $(VALGRIND_OPTS)" gen_parallel_tests
 	$(AM_V_GEN)if test "$(J)" != 1                                  \
@@ -1183,14 +1128,6 @@ valgrind_check: $(TESTS)
 		done; \
 	fi
 
-valgrind_check_some: $(ROCKSDBTESTS_SUBSET)
-	for t in $(ROCKSDBTESTS_SUBSET); do \
-		$(VALGRIND_VER) $(VALGRIND_OPTS) ./$$t; \
-		ret_code=$$?; \
-		if [ $$ret_code -ne 0 ]; then \
-			exit $$ret_code; \
-		fi; \
-	done
 
 ifneq ($(PAR_TEST),)
 parloop:
@@ -1427,9 +1364,6 @@ hash_test: $(OBJ_DIR)/util/hash_test.o $(TEST_LIBRARY) $(LIBRARY)
 random_test: $(OBJ_DIR)/util/random_test.o  $(TEST_LIBRARY) $(LIBRARY)
 	$(AM_LINK)
 
-ribbon_test: $(OBJ_DIR)/util/ribbon_test.o $(TEST_LIBRARY) $(LIBRARY)
-	$(AM_LINK)
-
 option_change_migration_test: $(OBJ_DIR)/utilities/option_change_migration/option_change_migration_test.o $(TEST_LIBRARY) $(LIBRARY)
 	$(AM_LINK)
 
@@ -1475,9 +1409,6 @@ slice_transform_test: $(OBJ_DIR)/util/slice_transform_test.o $(TEST_LIBRARY) $(L
 db_basic_test: $(OBJ_DIR)/db/db_basic_test.o $(TEST_LIBRARY) $(LIBRARY)
 	$(AM_LINK)
 
-db_blob_basic_test: $(OBJ_DIR)/db/blob/db_blob_basic_test.o $(TEST_LIBRARY) $(LIBRARY)
-	$(AM_LINK)
-
 db_with_timestamp_basic_test: $(OBJ_DIR)/db/db_with_timestamp_basic_test.o $(TEST_LIBRARY) $(LIBRARY)
 	$(AM_LINK)
 
@@ -1798,12 +1729,6 @@ thread_list_test: $(OBJ_DIR)/util/thread_list_test.o $(TEST_LIBRARY) $(LIBRARY)
 compact_files_test: $(OBJ_DIR)/db/compact_files_test.o $(TEST_LIBRARY) $(LIBRARY)
 	$(AM_LINK)
 
-configurable_test: options/configurable_test.o $(TEST_LIBRARY) $(LIBRARY)
-	$(AM_LINK)
-
-customizable_test: options/customizable_test.o $(TEST_LIBRARY) $(LIBRARY)
-	$(AM_LINK)
-
 options_test: $(OBJ_DIR)/options/options_test.o $(TEST_LIBRARY) $(LIBRARY)
 	$(AM_LINK)
 
@@ -1855,7 +1780,7 @@ write_callback_test: $(OBJ_DIR)/db/write_callback_test.o $(TEST_LIBRARY) $(LIBRA
 heap_test: $(OBJ_DIR)/util/heap_test.o $(GTEST)
 	$(AM_LINK)
 
-point_lock_manager_test: utilities/transactions/lock/point/point_lock_manager_test.o $(TEST_LIBRARY) $(LIBRARY)
+transaction_lock_mgr_test: utilities/transactions/transaction_lock_mgr_test.o $(TEST_LIBRARY) $(LIBRARY)
 	$(AM_LINK)
 
 transaction_test: $(OBJ_DIR)/utilities/transactions/transaction_test.o $(TEST_LIBRARY) $(LIBRARY)
@@ -1933,19 +1858,13 @@ blob_file_addition_test: $(OBJ_DIR)/db/blob/blob_file_addition_test.o $(TEST_LIB
 blob_file_builder_test: $(OBJ_DIR)/db/blob/blob_file_builder_test.o $(TEST_LIBRARY) $(LIBRARY)
 	$(AM_LINK)
 
-blob_file_cache_test: $(OBJ_DIR)/db/blob/blob_file_cache_test.o $(TEST_LIBRARY) $(LIBRARY)
-	$(AM_LINK)
-
 blob_file_garbage_test: $(OBJ_DIR)/db/blob/blob_file_garbage_test.o $(TEST_LIBRARY) $(LIBRARY)
 	$(AM_LINK)
 
-blob_file_reader_test: $(OBJ_DIR)/db/blob/blob_file_reader_test.o $(TEST_LIBRARY) $(LIBRARY)
-	$(AM_LINK)
-
 timer_test: $(OBJ_DIR)/util/timer_test.o $(TEST_LIBRARY) $(LIBRARY)
 	$(AM_LINK)
 
-periodic_work_scheduler_test: $(OBJ_DIR)/db/periodic_work_scheduler_test.o $(TEST_LIBRARY) $(LIBRARY)
+stats_dump_scheduler_test: $(OBJ_DIR)/monitoring/stats_dump_scheduler_test.o $(TEST_LIBRARY) $(LIBRARY)
 	$(AM_LINK)
 
 testutil_test: $(OBJ_DIR)/test_util/testutil_test.o $(TEST_LIBRARY) $(LIBRARY)
@@ -1957,12 +1876,6 @@ io_tracer_test: $(OBJ_DIR)/trace_replay/io_tracer_test.o $(OBJ_DIR)/trace_replay
 prefetch_test: $(OBJ_DIR)/file/prefetch_test.o $(TEST_LIBRARY) $(LIBRARY)
 	$(AM_LINK)
 
-io_tracer_parser_test: $(OBJ_DIR)/tools/io_tracer_parser_test.o $(OBJ_DIR)/tools/io_tracer_parser_tool.o $(TEST_LIBRARY) $(LIBRARY)
-	$(AM_LINK)
-
-io_tracer_parser: $(OBJ_DIR)/tools/io_tracer_parser.o $(TOOLS_LIBRARY) $(LIBRARY)
-	$(AM_LINK)
-
 #-------------------------------------------------
 # make install related stuff
 PREFIX ?= /usr/local
@@ -2073,8 +1986,8 @@ SNAPPY_DOWNLOAD_BASE ?= https://github.com/google/snappy/archive
 LZ4_VER ?= 1.9.2
 LZ4_SHA256 ?= 658ba6191fa44c92280d4aa2c271b0f4fbc0e34d249578dd05e50e76d0e5efcc
 LZ4_DOWNLOAD_BASE ?= https://github.com/lz4/lz4/archive
-ZSTD_VER ?= 1.4.5
-ZSTD_SHA256 ?= 734d1f565c42f691f8420c8d06783ad818060fc390dee43ae0a89f86d0a4f8c2
+ZSTD_VER ?= 1.4.4
+ZSTD_SHA256 ?= a364f5162c7d1a455cc915e8e3cf5f4bd8b75d09bc0f53965b0c9ca1383c52c8
 ZSTD_DOWNLOAD_BASE ?= https://github.com/facebook/zstd/archive
 CURL_SSL_OPTS ?= --tlsv1
 
@@ -2106,78 +2019,78 @@ ifeq ($(PLATFORM), OS_AIX)
 	SNAPPY_MAKE_TARGET = libsnappy.la
 endif
 ifeq ($(PLATFORM), OS_OPENBSD)
-	JAVA_INCLUDE = -I$(JAVA_HOME)/include -I$(JAVA_HOME)/include/openbsd
+        JAVA_INCLUDE = -I$(JAVA_HOME)/include -I$(JAVA_HOME)/include/openbsd
 	ROCKSDBJNILIB = librocksdbjni-openbsd$(ARCH).so
-	ROCKSDB_JAR = rocksdbjni-$(ROCKSDB_JAVA_VERSION)-openbsd$(ARCH).jar
+        ROCKSDB_JAR = rocksdbjni-$(ROCKSDB_JAVA_VERSION)-openbsd$(ARCH).jar
 endif
 
-zlib-$(ZLIB_VER).tar.gz:
+libz.a:
+	-rm -rf zlib-$(ZLIB_VER)
+ifeq (,$(wildcard ./zlib-$(ZLIB_VER).tar.gz))
 	curl --fail --output zlib-$(ZLIB_VER).tar.gz --location ${ZLIB_DOWNLOAD_BASE}/zlib-$(ZLIB_VER).tar.gz
+endif
 	ZLIB_SHA256_ACTUAL=`$(SHA256_CMD) zlib-$(ZLIB_VER).tar.gz | cut -d ' ' -f 1`; \
 	if [ "$(ZLIB_SHA256)" != "$$ZLIB_SHA256_ACTUAL" ]; then \
 		echo zlib-$(ZLIB_VER).tar.gz checksum mismatch, expected=\"$(ZLIB_SHA256)\" actual=\"$$ZLIB_SHA256_ACTUAL\"; \
 		exit 1; \
 	fi
-
-libz.a: zlib-$(ZLIB_VER).tar.gz
-	-rm -rf zlib-$(ZLIB_VER)
 	tar xvzf zlib-$(ZLIB_VER).tar.gz
 	cd zlib-$(ZLIB_VER) && CFLAGS='-fPIC ${EXTRA_CFLAGS}' LDFLAGS='${EXTRA_LDFLAGS}' ./configure --static && $(MAKE)
 	cp zlib-$(ZLIB_VER)/libz.a .
 
-bzip2-$(BZIP2_VER).tar.gz:
+libbz2.a:
+	-rm -rf bzip2-$(BZIP2_VER)
+ifeq (,$(wildcard ./bzip2-$(BZIP2_VER).tar.gz))
 	curl --fail --output bzip2-$(BZIP2_VER).tar.gz --location ${CURL_SSL_OPTS} ${BZIP2_DOWNLOAD_BASE}/bzip2-$(BZIP2_VER).tar.gz
+endif
 	BZIP2_SHA256_ACTUAL=`$(SHA256_CMD) bzip2-$(BZIP2_VER).tar.gz | cut -d ' ' -f 1`; \
 	if [ "$(BZIP2_SHA256)" != "$$BZIP2_SHA256_ACTUAL" ]; then \
 		echo bzip2-$(BZIP2_VER).tar.gz checksum mismatch, expected=\"$(BZIP2_SHA256)\" actual=\"$$BZIP2_SHA256_ACTUAL\"; \
 		exit 1; \
 	fi
-
-libbz2.a: bzip2-$(BZIP2_VER).tar.gz
-	-rm -rf bzip2-$(BZIP2_VER)
 	tar xvzf bzip2-$(BZIP2_VER).tar.gz
 	cd bzip2-$(BZIP2_VER) && $(MAKE) CFLAGS='-fPIC -O2 -g -D_FILE_OFFSET_BITS=64 ${EXTRA_CFLAGS}' AR='ar ${EXTRA_ARFLAGS}'
 	cp bzip2-$(BZIP2_VER)/libbz2.a .
 
-snappy-$(SNAPPY_VER).tar.gz:
+libsnappy.a:
+	-rm -rf snappy-$(SNAPPY_VER)
+ifeq (,$(wildcard ./snappy-$(SNAPPY_VER).tar.gz))
 	curl --fail --output snappy-$(SNAPPY_VER).tar.gz --location ${CURL_SSL_OPTS} ${SNAPPY_DOWNLOAD_BASE}/$(SNAPPY_VER).tar.gz
+endif
 	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\"; \
 		exit 1; \
 	fi
-
-libsnappy.a: snappy-$(SNAPPY_VER).tar.gz
-	-rm -rf snappy-$(SNAPPY_VER)
 	tar xvzf snappy-$(SNAPPY_VER).tar.gz
 	mkdir snappy-$(SNAPPY_VER)/build
 	cd snappy-$(SNAPPY_VER)/build && CFLAGS='${EXTRA_CFLAGS}' CXXFLAGS='${EXTRA_CXXFLAGS}' LDFLAGS='${EXTRA_LDFLAGS}' cmake -DCMAKE_POSITION_INDEPENDENT_CODE=ON .. && $(MAKE) ${SNAPPY_MAKE_TARGET}
 	cp snappy-$(SNAPPY_VER)/build/libsnappy.a .
 
-lz4-$(LZ4_VER).tar.gz:
+liblz4.a:
+	-rm -rf lz4-$(LZ4_VER)
+ifeq (,$(wildcard ./lz4-$(LZ4_VER).tar.gz))
 	curl --fail --output lz4-$(LZ4_VER).tar.gz --location ${CURL_SSL_OPTS} ${LZ4_DOWNLOAD_BASE}/v$(LZ4_VER).tar.gz
+endif
 	LZ4_SHA256_ACTUAL=`$(SHA256_CMD) lz4-$(LZ4_VER).tar.gz | cut -d ' ' -f 1`; \
 	if [ "$(LZ4_SHA256)" != "$$LZ4_SHA256_ACTUAL" ]; then \
 		echo lz4-$(LZ4_VER).tar.gz checksum mismatch, expected=\"$(LZ4_SHA256)\" actual=\"$$LZ4_SHA256_ACTUAL\"; \
 		exit 1; \
 	fi
-
-liblz4.a: lz4-$(LZ4_VER).tar.gz
-	-rm -rf lz4-$(LZ4_VER)
 	tar xvzf lz4-$(LZ4_VER).tar.gz
 	cd lz4-$(LZ4_VER)/lib && $(MAKE) CFLAGS='-fPIC -O2 ${EXTRA_CFLAGS}' all
 	cp lz4-$(LZ4_VER)/lib/liblz4.a .
 
-zstd-$(ZSTD_VER).tar.gz:
+libzstd.a:
+	-rm -rf zstd-$(ZSTD_VER)
+ifeq (,$(wildcard ./zstd-$(ZSTD_VER).tar.gz))
 	curl --fail --output zstd-$(ZSTD_VER).tar.gz --location ${CURL_SSL_OPTS} ${ZSTD_DOWNLOAD_BASE}/v$(ZSTD_VER).tar.gz
+endif
 	ZSTD_SHA256_ACTUAL=`$(SHA256_CMD) zstd-$(ZSTD_VER).tar.gz | cut -d ' ' -f 1`; \
 	if [ "$(ZSTD_SHA256)" != "$$ZSTD_SHA256_ACTUAL" ]; then \
 		echo zstd-$(ZSTD_VER).tar.gz checksum mismatch, expected=\"$(ZSTD_SHA256)\" actual=\"$$ZSTD_SHA256_ACTUAL\"; \
 		exit 1; \
 	fi
-
-libzstd.a: zstd-$(ZSTD_VER).tar.gz
-	-rm -rf zstd-$(ZSTD_VER)
 	tar xvzf zstd-$(ZSTD_VER).tar.gz
 	cd zstd-$(ZSTD_VER)/lib && DESTDIR=. PREFIX= $(MAKE) CFLAGS='-fPIC -O2 ${EXTRA_CFLAGS}' install
 	cp zstd-$(ZSTD_VER)/lib/libzstd.a .
@@ -2188,23 +2101,14 @@ JAVA_COMPRESSIONS = libz.a libbz2.a libsnappy.a liblz4.a libzstd.a
 endif
 
 JAVA_STATIC_FLAGS = -DZLIB -DBZIP2 -DSNAPPY -DLZ4 -DZSTD
-JAVA_STATIC_INCLUDES = -I./zlib-$(ZLIB_VER) -I./bzip2-$(BZIP2_VER) -I./snappy-$(SNAPPY_VER) -I./snappy-$(SNAPPY_VER)/build -I./lz4-$(LZ4_VER)/lib -I./zstd-$(ZSTD_VER)/lib -I./zstd-$(ZSTD_VER)/lib/dictBuilder
-
-ifneq ($(findstring rocksdbjavastatic, $(filter-out rocksdbjavastatic_deps, $(MAKECMDGOALS))),)
+JAVA_STATIC_INCLUDES = -I./zlib-$(ZLIB_VER) -I./bzip2-$(BZIP2_VER) -I./snappy-$(SNAPPY_VER) -I./lz4-$(LZ4_VER)/lib -I./zstd-$(ZSTD_VER)/lib/include
+ifneq ($(findstring rocksdbjavastatic, $(MAKECMDGOALS)),)
 CXXFLAGS += $(JAVA_STATIC_FLAGS) $(JAVA_STATIC_INCLUDES)
-CFLAGS += $(JAVA_STATIC_FLAGS) $(JAVA_STATIC_INCLUDES)
+CFLAGS +=  $(JAVA_STATIC_FLAGS) $(JAVA_STATIC_INCLUDES)
 endif
-rocksdbjavastatic:
-ifeq ($(JAVA_HOME),)
-	$(error JAVA_HOME is not set)
-endif
-	$(MAKE) rocksdbjavastatic_deps
-	$(MAKE) rocksdbjavastatic_libobjects
-	$(MAKE) rocksdbjavastatic_javalib
-
-rocksdbjavastatic_javalib:
-	cd java;$(MAKE) javalib
-	rm -f java/target/$(ROCKSDBJNILIB)
+rocksdbjavastatic: $(LIB_OBJECTS) $(JAVA_COMPRESSIONS)
+	cd java;$(MAKE) javalib;
+	rm -f ./java/target/$(ROCKSDBJNILIB)
 	$(CXX) $(CXXFLAGS) -I./java/. $(JAVA_INCLUDE) -shared -fPIC \
 	  -o ./java/target/$(ROCKSDBJNILIB) $(JNI_NATIVE_SOURCES) \
 	  $(LIB_OBJECTS) $(COVERAGEFLAGS) \
@@ -2221,10 +2125,6 @@ rocksdbjavastatic_javalib:
 	openssl sha1 java/target/$(ROCKSDB_JAVADOCS_JAR) | sed 's/.*= \([0-9a-f]*\)/\1/' > java/target/$(ROCKSDB_JAVADOCS_JAR).sha1
 	openssl sha1 java/target/$(ROCKSDB_SOURCES_JAR) | sed 's/.*= \([0-9a-f]*\)/\1/' > java/target/$(ROCKSDB_SOURCES_JAR).sha1
 
-rocksdbjavastatic_deps: $(JAVA_COMPRESSIONS)
-
-rocksdbjavastatic_libobjects: $(LIB_OBJECTS)
-
 rocksdbjavastaticrelease: rocksdbjavastatic
 	cd java/crossbuild && (vagrant destroy -f || true) && vagrant up linux32 && vagrant halt linux32 && vagrant up linux64 && vagrant halt linux64 && vagrant up linux64-musl && vagrant halt linux64-musl
 	cd java;jar -cf target/$(ROCKSDB_JAR_ALL) HISTORY*.md
@@ -2240,7 +2140,7 @@ rocksdbjavastaticreleasedocker: rocksdbjavastatic rocksdbjavastaticdockerx86 roc
 
 rocksdbjavastaticdockerx86:
 	mkdir -p java/target
-	docker run --rm --name rocksdb_linux_x86-be --platform linux/386 --attach stdin --attach stdout --attach stderr --volume $(HOME)/.m2:/root/.m2:ro --volume `pwd`:/rocksdb-host:ro --volume /rocksdb-local-build --volume `pwd`/java/target:/rocksdb-java-target --env DEBUG_LEVEL=$(DEBUG_LEVEL) evolvedbinary/rocksjava:centos6_x86-be /rocksdb-host/java/crossbuild/docker-build-linux-centos.sh
+	docker run --rm --name rocksdb_linux_x86-be --attach stdin --attach stdout --attach stderr --volume $(HOME)/.m2:/root/.m2:ro --volume `pwd`:/rocksdb-host:ro --volume /rocksdb-local-build --volume `pwd`/java/target:/rocksdb-java-target --env DEBUG_LEVEL=$(DEBUG_LEVEL) evolvedbinary/rocksjava:centos6_x86-be /rocksdb-host/java/crossbuild/docker-build-linux-centos.sh
 
 rocksdbjavastaticdockerx86_64:
 	mkdir -p java/target
@@ -2256,7 +2156,7 @@ rocksdbjavastaticdockerarm64v8:
 
 rocksdbjavastaticdockerx86musl:
 	mkdir -p java/target
-	docker run --rm --name rocksdb_linux_x86-musl-be --platform linux/386 --attach stdin --attach stdout --attach stderr --volume $(HOME)/.m2:/root/.m2:ro --volume `pwd`:/rocksdb-host:ro --volume /rocksdb-local-build --volume `pwd`/java/target:/rocksdb-java-target --env DEBUG_LEVEL=$(DEBUG_LEVEL) evolvedbinary/rocksjava:alpine3_x86-be /rocksdb-host/java/crossbuild/docker-build-linux-centos.sh
+	docker run --rm --name rocksdb_linux_x86-musl-be --attach stdin --attach stdout --attach stderr --volume $(HOME)/.m2:/root/.m2:ro --volume `pwd`:/rocksdb-host:ro --volume /rocksdb-local-build --volume `pwd`/java/target:/rocksdb-java-target --env DEBUG_LEVEL=$(DEBUG_LEVEL) evolvedbinary/rocksjava:alpine3_x86-be /rocksdb-host/java/crossbuild/docker-build-linux-centos.sh
 
 rocksdbjavastaticdockerx86_64musl:
 	mkdir -p java/target
@@ -2294,9 +2194,6 @@ jl/%.o: %.cc
 	$(AM_V_CC)mkdir -p $(@D) && $(CXX) $(CXXFLAGS) -fPIC -c $< -o $@ $(COVERAGEFLAGS)
 
 rocksdbjava: $(LIB_OBJECTS)
-ifeq ($(JAVA_HOME),)
-	$(error JAVA_HOME is not set)
-endif
 	$(AM_V_GEN)cd java;$(MAKE) javalib;
 	$(AM_V_at)rm -f ./java/target/$(ROCKSDBJNILIB)
 	$(AM_V_at)$(CXX) $(CXXFLAGS) -I./java/. $(JAVA_INCLUDE) -shared -fPIC -o ./java/target/$(ROCKSDBJNILIB) $(JNI_NATIVE_SOURCES) $(LIB_OBJECTS) $(JAVA_LDFLAGS) $(COVERAGEFLAGS)
@@ -2416,9 +2313,6 @@ else
 depend: $(DEPFILES)
 endif
 
-build_subset_tests: $(ROCKSDBTESTS_SUBSET)
-	$(AM_V_GEN)if [ -n "$${ROCKSDBTESTS_SUBSET_TESTS_TO_FILE}" ]; then echo "$(ROCKSDBTESTS_SUBSET)" > "$${ROCKSDBTESTS_SUBSET_TESTS_TO_FILE}"; else echo "$(ROCKSDBTESTS_SUBSET)"; fi
-
 # if the make goal is either "clean" or "format", we shouldn't
 # try to import the *.d files.
 # TODO(kailiu) The unfamiliarity of Make's conditions leads to the ugly
@@ -2427,8 +2321,6 @@ ifneq ($(MAKECMDGOALS),clean)
 ifneq ($(MAKECMDGOALS),format)
 ifneq ($(MAKECMDGOALS),jclean)
 ifneq ($(MAKECMDGOALS),jtest)
-ifneq ($(MAKECMDGOALS),rocksdbjavastatic)
-ifneq ($(MAKECMDGOALS),rocksdbjavastatic_deps)
 ifneq ($(MAKECMDGOALS),package)
 ifneq ($(MAKECMDGOALS),analyze)
 -include $(DEPFILES)
@@ -2438,5 +2330,3 @@ endif
 endif
 endif
 endif
-endif
-endif

README.md

@@ -3,7 +3,7 @@
 [![CircleCI Status](https://circleci.com/gh/facebook/rocksdb.svg?style=svg)](https://circleci.com/gh/facebook/rocksdb)
 [![TravisCI Status](https://travis-ci.org/facebook/rocksdb.svg?branch=master)](https://travis-ci.org/facebook/rocksdb)
 [![Appveyor Build status](https://ci.appveyor.com/api/projects/status/fbgfu0so3afcno78/branch/master?svg=true)](https://ci.appveyor.com/project/Facebook/rocksdb/branch/master)
-[![PPC64le Build Status](http://140-211-168-68-openstack.osuosl.org:8080/buildStatus/icon?job=rocksdb&style=plastic)](http://140-211-168-68-openstack.osuosl.org:8080/job/rocksdb)
+[![PPC64le Build Status](http://140.211.168.68:8080/buildStatus/icon?job=Rocksdb)](http://140.211.168.68:8080/job/Rocksdb)
 
 RocksDB is developed and maintained by Facebook Database Engineering Team.
 It is built on earlier work on [LevelDB](https://github.com/google/leveldb) by Sanjay Ghemawat (sanjay@google.com)

TARGETS

@@ -25,16 +25,13 @@ ROCKSDB_EXTERNAL_DEPS = [
     ("gflags", None, "gflags"),
     ("lz4", None, "lz4"),
     ("zstd", None),
+    ("tbb", None),
 ]
 
 ROCKSDB_OS_DEPS = [
     (
         "linux",
-        ["third-party//numa:numa", "third-party//liburing:uring", "third-party//tbb:tbb"],
-    ),
-    (
-        "macos",
-        ["third-party//tbb:tbb"],
+        ["third-party//numa:numa", "third-party//liburing:uring"],
     ),
 ]
 
@@ -52,27 +49,17 @@ ROCKSDB_OS_PREPROCESSOR_FLAGS = [
             "-DHAVE_SSE42",
             "-DLIBURING",
             "-DNUMA",
-            "-DROCKSDB_PLATFORM_POSIX",
-            "-DROCKSDB_LIB_IO_POSIX",
-            "-DTBB",
         ],
     ),
     (
         "macos",
-        [
-            "-DOS_MACOSX",
-            "-DROCKSDB_PLATFORM_POSIX",
-            "-DROCKSDB_LIB_IO_POSIX",
-            "-DTBB",
-        ],
-    ),
-    (
-        "windows",
-        [ "-DOS_WIN", "-DWIN32", "-D_MBCS", "-DWIN64", "-DNOMINMAX" ]
+        ["-DOS_MACOSX"],
     ),
 ]
 
 ROCKSDB_PREPROCESSOR_FLAGS = [
+    "-DROCKSDB_PLATFORM_POSIX",
+    "-DROCKSDB_LIB_IO_POSIX",
     "-DROCKSDB_SUPPORT_THREAD_LOCAL",
 
     # Flags to enable libs we include
@@ -83,6 +70,7 @@ ROCKSDB_PREPROCESSOR_FLAGS = [
     "-DZSTD",
     "-DZSTD_STATIC_LINKING_ONLY",
     "-DGFLAGS=gflags",
+    "-DTBB",
 
     # Added missing flags from output of build_detect_platform
     "-DROCKSDB_BACKTRACE",
@@ -135,12 +123,10 @@ cpp_library(
         "db/arena_wrapped_db_iter.cc",
         "db/blob/blob_file_addition.cc",
         "db/blob/blob_file_builder.cc",
-        "db/blob/blob_file_cache.cc",
         "db/blob/blob_file_garbage.cc",
         "db/blob/blob_file_meta.cc",
-        "db/blob/blob_file_reader.cc",
         "db/blob/blob_log_format.cc",
-        "db/blob/blob_log_sequential_reader.cc",
+        "db/blob/blob_log_reader.cc",
         "db/blob/blob_log_writer.cc",
         "db/builder.cc",
         "db/c.cc",
@@ -186,8 +172,6 @@ cpp_library(
         "db/memtable_list.cc",
         "db/merge_helper.cc",
         "db/merge_operator.cc",
-        "db/output_validator.cc",
-        "db/periodic_work_scheduler.cc",
         "db/range_del_aggregator.cc",
         "db/range_tombstone_fragmenter.cc",
         "db/repair.cc",
@@ -248,26 +232,19 @@ cpp_library(
         "monitoring/perf_level.cc",
         "monitoring/persistent_stats_history.cc",
         "monitoring/statistics.cc",
+        "monitoring/stats_dump_scheduler.cc",
         "monitoring/thread_status_impl.cc",
         "monitoring/thread_status_updater.cc",
         "monitoring/thread_status_updater_debug.cc",
         "monitoring/thread_status_util.cc",
         "monitoring/thread_status_util_debug.cc",
         "options/cf_options.cc",
-        "options/configurable.cc",
-        "options/customizable.cc",
         "options/db_options.cc",
         "options/options.cc",
         "options/options_helper.cc",
         "options/options_parser.cc",
         "port/port_posix.cc",
         "port/stack_trace.cc",
-        "port/win/env_default.cc",
-        "port/win/env_win.cc",
-        "port/win/io_win.cc",
-        "port/win/port_win.cc",
-        "port/win/win_logger.cc",
-        "port/win/win_thread.cc",
         "table/adaptive/adaptive_table_factory.cc",
         "table/block_based/binary_search_index_reader.cc",
         "table/block_based/block.cc",
@@ -313,14 +290,12 @@ cpp_library(
         "table/sst_file_dumper.cc",
         "table/sst_file_reader.cc",
         "table/sst_file_writer.cc",
-        "table/table_factory.cc",
         "table/table_properties.cc",
         "table/two_level_iterator.cc",
         "test_util/sync_point.cc",
         "test_util/sync_point_impl.cc",
         "test_util/transaction_test_util.cc",
         "tools/dump/db_dump_tool.cc",
-        "tools/io_tracer_parser_tool.cc",
         "tools/ldb_cmd.cc",
         "tools/ldb_tool.cc",
         "tools/sst_dump_tool.cc",
@@ -385,9 +360,8 @@ cpp_library(
         "utilities/simulator_cache/sim_cache.cc",
         "utilities/table_properties_collectors/compact_on_deletion_collector.cc",
         "utilities/trace/file_trace_reader_writer.cc",
-        "utilities/transactions/lock/lock_manager.cc",
-        "utilities/transactions/lock/point/point_lock_manager.cc",
-        "utilities/transactions/lock/point/point_lock_tracker.cc",
+        "utilities/transactions/lock/lock_tracker.cc",
+        "utilities/transactions/lock/point_lock_tracker.cc",
         "utilities/transactions/optimistic_transaction.cc",
         "utilities/transactions/optimistic_transaction_db_impl.cc",
         "utilities/transactions/pessimistic_transaction.cc",
@@ -395,6 +369,7 @@ cpp_library(
         "utilities/transactions/snapshot_checker.cc",
         "utilities/transactions/transaction_base.cc",
         "utilities/transactions/transaction_db_mutex_impl.cc",
+        "utilities/transactions/transaction_lock_mgr.cc",
         "utilities/transactions/transaction_util.cc",
         "utilities/transactions/write_prepared_txn.cc",
         "utilities/transactions/write_prepared_txn_db.cc",
@@ -425,12 +400,10 @@ cpp_library(
         "db/arena_wrapped_db_iter.cc",
         "db/blob/blob_file_addition.cc",
         "db/blob/blob_file_builder.cc",
-        "db/blob/blob_file_cache.cc",
         "db/blob/blob_file_garbage.cc",
         "db/blob/blob_file_meta.cc",
-        "db/blob/blob_file_reader.cc",
         "db/blob/blob_log_format.cc",
-        "db/blob/blob_log_sequential_reader.cc",
+        "db/blob/blob_log_reader.cc",
         "db/blob/blob_log_writer.cc",
         "db/builder.cc",
         "db/c.cc",
@@ -476,8 +449,6 @@ cpp_library(
         "db/memtable_list.cc",
         "db/merge_helper.cc",
         "db/merge_operator.cc",
-        "db/output_validator.cc",
-        "db/periodic_work_scheduler.cc",
         "db/range_del_aggregator.cc",
         "db/range_tombstone_fragmenter.cc",
         "db/repair.cc",
@@ -538,26 +509,19 @@ cpp_library(
         "monitoring/perf_level.cc",
         "monitoring/persistent_stats_history.cc",
         "monitoring/statistics.cc",
+        "monitoring/stats_dump_scheduler.cc",
         "monitoring/thread_status_impl.cc",
         "monitoring/thread_status_updater.cc",
         "monitoring/thread_status_updater_debug.cc",
         "monitoring/thread_status_util.cc",
         "monitoring/thread_status_util_debug.cc",
         "options/cf_options.cc",
-        "options/configurable.cc",
-        "options/customizable.cc",
         "options/db_options.cc",
         "options/options.cc",
         "options/options_helper.cc",
         "options/options_parser.cc",
         "port/port_posix.cc",
         "port/stack_trace.cc",
-        "port/win/env_default.cc",
-        "port/win/env_win.cc",
-        "port/win/io_win.cc",
-        "port/win/port_win.cc",
-        "port/win/win_logger.cc",
-        "port/win/win_thread.cc",
         "table/adaptive/adaptive_table_factory.cc",
         "table/block_based/binary_search_index_reader.cc",
         "table/block_based/block.cc",
@@ -603,14 +567,12 @@ cpp_library(
         "table/sst_file_dumper.cc",
         "table/sst_file_reader.cc",
         "table/sst_file_writer.cc",
-        "table/table_factory.cc",
         "table/table_properties.cc",
         "table/two_level_iterator.cc",
         "test_util/sync_point.cc",
         "test_util/sync_point_impl.cc",
         "test_util/transaction_test_util.cc",
         "tools/dump/db_dump_tool.cc",
-        "tools/io_tracer_parser_tool.cc",
         "tools/ldb_cmd.cc",
         "tools/ldb_tool.cc",
         "tools/sst_dump_tool.cc",
@@ -675,9 +637,8 @@ cpp_library(
         "utilities/simulator_cache/sim_cache.cc",
         "utilities/table_properties_collectors/compact_on_deletion_collector.cc",
         "utilities/trace/file_trace_reader_writer.cc",
-        "utilities/transactions/lock/lock_manager.cc",
-        "utilities/transactions/lock/point/point_lock_manager.cc",
-        "utilities/transactions/lock/point/point_lock_tracker.cc",
+        "utilities/transactions/lock/lock_tracker.cc",
+        "utilities/transactions/lock/point_lock_tracker.cc",
         "utilities/transactions/optimistic_transaction.cc",
         "utilities/transactions/optimistic_transaction_db_impl.cc",
         "utilities/transactions/pessimistic_transaction.cc",
@@ -685,6 +646,7 @@ cpp_library(
         "utilities/transactions/snapshot_checker.cc",
         "utilities/transactions/transaction_base.cc",
         "utilities/transactions/transaction_db_mutex_impl.cc",
+        "utilities/transactions/transaction_lock_mgr.cc",
         "utilities/transactions/transaction_util.cc",
         "utilities/transactions/write_prepared_txn.cc",
         "utilities/transactions/write_prepared_txn_db.cc",
@@ -775,24 +737,26 @@ cpp_library(
     external_deps = ROCKSDB_EXTERNAL_DEPS,
 )
 
-cpp_binary(
-    name = "c_test_bin",
-    srcs = ["db/c_test.c"],
-    arch_preprocessor_flags = ROCKSDB_ARCH_PREPROCESSOR_FLAGS,
-    os_preprocessor_flags = ROCKSDB_OS_PREPROCESSOR_FLAGS,
-    compiler_flags = ROCKSDB_COMPILER_FLAGS,
-    preprocessor_flags = ROCKSDB_PREPROCESSOR_FLAGS,
-    deps = [":rocksdb_test_lib"],
-) if not is_opt_mode else None
+if not is_opt_mode:
+    cpp_binary(
+        name = "c_test_bin",
+        srcs = ["db/c_test.c"],
+        arch_preprocessor_flags = ROCKSDB_ARCH_PREPROCESSOR_FLAGS,
+        os_preprocessor_flags = ROCKSDB_OS_PREPROCESSOR_FLAGS,
+        compiler_flags = ROCKSDB_COMPILER_FLAGS,
+        preprocessor_flags = ROCKSDB_PREPROCESSOR_FLAGS,
+        deps = [":rocksdb_test_lib"],
+    )
 
-custom_unittest(
-    "c_test",
-    command = [
-        native.package_name() + "/buckifier/rocks_test_runner.sh",
-        "$(location :{})".format("c_test_bin"),
-    ],
-    type = "simple",
-) if not is_opt_mode else None
+if not is_opt_mode:
+    custom_unittest(
+        "c_test",
+        command = [
+            native.package_name() + "/buckifier/rocks_test_runner.sh",
+            "$(location :{})".format("c_test_bin"),
+        ],
+        type = "simple",
+    )
 
 cpp_library(
     name = "env_basic_test_lib",
@@ -859,13 +823,6 @@ ROCKS_TESTS = [
         [],
         [],
     ],
-    [
-        "blob_file_cache_test",
-        "db/blob/blob_file_cache_test.cc",
-        "serial",
-        [],
-        [],
-    ],
     [
         "blob_file_garbage_test",
         "db/blob/blob_file_garbage_test.cc",
@@ -873,13 +830,6 @@ ROCKS_TESTS = [
         [],
         [],
     ],
-    [
-        "blob_file_reader_test",
-        "db/blob/blob_file_reader_test.cc",
-        "serial",
-        [],
-        [],
-    ],
     [
         "block_based_filter_block_test",
         "table/block_based/block_based_filter_block_test.cc",
@@ -1048,13 +998,6 @@ ROCKS_TESTS = [
         [],
         [],
     ],
-    [
-        "configurable_test",
-        "options/configurable_test.cc",
-        "serial",
-        [],
-        [],
-    ],
     [
         "corruption_test",
         "db/corruption_test.cc",
@@ -1090,13 +1033,6 @@ ROCKS_TESTS = [
         [],
         [],
     ],
-    [
-        "customizable_test",
-        "options/customizable_test.cc",
-        "serial",
-        [],
-        [],
-    ],
     [
         "data_block_hash_index_test",
         "table/block_based/data_block_hash_index_test.cc",
@@ -1111,13 +1047,6 @@ ROCKS_TESTS = [
         [],
         [],
     ],
-    [
-        "db_blob_basic_test",
-        "db/blob/db_blob_basic_test.cc",
-        "serial",
-        [],
-        [],
-    ],
     [
         "db_blob_index_test",
         "db/blob/db_blob_index_test.cc",
@@ -1538,13 +1467,6 @@ ROCKS_TESTS = [
         [],
         [],
     ],
-    [
-        "io_tracer_parser_test",
-        "tools/io_tracer_parser_test.cc",
-        "serial",
-        [],
-        [],
-    ],
     [
         "io_tracer_test",
         "trace_replay/io_tracer_test.cc",
@@ -1713,13 +1635,6 @@ ROCKS_TESTS = [
         [],
         [],
     ],
-    [
-        "periodic_work_scheduler_test",
-        "db/periodic_work_scheduler_test.cc",
-        "serial",
-        [],
-        [],
-    ],
     [
         "persistent_cache_test",
         "utilities/persistent_cache/persistent_cache_test.cc",
@@ -1734,13 +1649,6 @@ ROCKS_TESTS = [
         [],
         [],
     ],
-    [
-        "point_lock_manager_test",
-        "utilities/transactions/lock/point/point_lock_manager_test.cc",
-        "parallel",
-        [],
-        [],
-    ],
     [
         "prefetch_test",
         "file/prefetch_test.cc",
@@ -1811,13 +1719,6 @@ ROCKS_TESTS = [
         [],
         [],
     ],
-    [
-        "ribbon_test",
-        "util/ribbon_test.cc",
-        "serial",
-        [],
-        [],
-    ],
     [
         "sim_cache_test",
         "utilities/simulator_cache/sim_cache_test.cc",
@@ -1867,6 +1768,13 @@ ROCKS_TESTS = [
         [],
         [],
     ],
+    [
+        "stats_dump_scheduler_test",
+        "monitoring/stats_dump_scheduler_test.cc",
+        "serial",
+        [],
+        [],
+    ],
     [
         "stats_history_test",
         "monitoring/stats_history_test.cc",
@@ -1937,6 +1845,13 @@ ROCKS_TESTS = [
         [],
         [],
     ],
+    [
+        "transaction_lock_mgr_test",
+        "utilities/transactions/transaction_lock_mgr_test.cc",
+        "parallel",
+        [],
+        [],
+    ],
     [
         "transaction_test",
         "utilities/transactions/transaction_test.cc",

buckifier/targets_builder.py

@@ -27,9 +27,9 @@ def pretty_list(lst, indent=8):
 class TARGETSBuilder(object):
     def __init__(self, path):
         self.path = path
-        self.targets_file = open(path, 'wb')
+        self.targets_file = open(path, 'w')
         header = targets_cfg.rocksdb_target_header_template
-        self.targets_file.write(header.encode("utf-8"))
+        self.targets_file.write(header)
         self.total_lib = 0
         self.total_bin = 0
         self.total_test = 0
@@ -53,7 +53,7 @@ class TARGETSBuilder(object):
             headers=headers,
             deps=pretty_list(deps),
             extra_external_deps=extra_external_deps,
-            link_whole=link_whole).encode("utf-8"))
+            link_whole=link_whole))
         self.total_lib = self.total_lib + 1
 
     def add_rocksdb_library(self, name, srcs, headers=None):
@@ -67,36 +67,38 @@ class TARGETSBuilder(object):
             name=name,
             srcs=pretty_list(srcs),
             headers_attr_prefix=headers_attr_prefix,
-            headers=headers).encode("utf-8"))
+            headers=headers))
         self.total_lib = self.total_lib + 1
 
     def add_binary(self, name, srcs, deps=None):
-        self.targets_file.write(targets_cfg.binary_template.format(
-            name=name,
-            srcs=pretty_list(srcs),
-            deps=pretty_list(deps)).encode("utf-8"))
+        self.targets_file.write(targets_cfg.binary_template % (
+            name,
+            pretty_list(srcs),
+            pretty_list(deps)))
         self.total_bin = self.total_bin + 1
 
     def add_c_test(self):
-        self.targets_file.write(b"""
-cpp_binary(
-    name = "c_test_bin",
-    srcs = ["db/c_test.c"],
-    arch_preprocessor_flags = ROCKSDB_ARCH_PREPROCESSOR_FLAGS,
-    os_preprocessor_flags = ROCKSDB_OS_PREPROCESSOR_FLAGS,
-    compiler_flags = ROCKSDB_COMPILER_FLAGS,
-    preprocessor_flags = ROCKSDB_PREPROCESSOR_FLAGS,
-    deps = [":rocksdb_test_lib"],
-) if not is_opt_mode else None
+        self.targets_file.write("""
+if not is_opt_mode:
+    cpp_binary(
+        name = "c_test_bin",
+        srcs = ["db/c_test.c"],
+        arch_preprocessor_flags = ROCKSDB_ARCH_PREPROCESSOR_FLAGS,
+        os_preprocessor_flags = ROCKSDB_OS_PREPROCESSOR_FLAGS,
+        compiler_flags = ROCKSDB_COMPILER_FLAGS,
+        preprocessor_flags = ROCKSDB_PREPROCESSOR_FLAGS,
+        deps = [":rocksdb_test_lib"],
+    )
 
-custom_unittest(
-    "c_test",
-    command = [
-        native.package_name() + "/buckifier/rocks_test_runner.sh",
-        "$(location :{})".format("c_test_bin"),
-    ],
-    type = "simple",
-) if not is_opt_mode else None
+if not is_opt_mode:
+    custom_unittest(
+        "c_test",
+        command = [
+            native.package_name() + "/buckifier/rocks_test_runner.sh",
+            "$(location :{})".format("c_test_bin"),
+        ],
+        type = "simple",
+    )
 """)
 
     def register_test(self,
@@ -118,5 +120,5 @@ custom_unittest(
         self.total_test = self.total_test + 1
 
     def flush_tests(self):
-        self.targets_file.write(targets_cfg.unittests_template.format(tests=self.tests_cfg).encode("utf-8"))
+        self.targets_file.write(targets_cfg.unittests_template % self.tests_cfg)
         self.tests_cfg = ""

buckifier/targets_cfg.py

@@ -32,16 +32,13 @@ ROCKSDB_EXTERNAL_DEPS = [
     ("gflags", None, "gflags"),
     ("lz4", None, "lz4"),
     ("zstd", None),
+    ("tbb", None),
 ]
 
 ROCKSDB_OS_DEPS = [
     (
         "linux",
-        ["third-party//numa:numa", "third-party//liburing:uring", "third-party//tbb:tbb"],
-    ),
-    (
-        "macos",
-        ["third-party//tbb:tbb"],
+        ["third-party//numa:numa", "third-party//liburing:uring"],
     ),
 ]
 
@@ -59,27 +56,17 @@ ROCKSDB_OS_PREPROCESSOR_FLAGS = [
             "-DHAVE_SSE42",
             "-DLIBURING",
             "-DNUMA",
-            "-DROCKSDB_PLATFORM_POSIX",
-            "-DROCKSDB_LIB_IO_POSIX",
-            "-DTBB",
         ],
     ),
     (
         "macos",
-        [
-            "-DOS_MACOSX",
-            "-DROCKSDB_PLATFORM_POSIX",
-            "-DROCKSDB_LIB_IO_POSIX",
-            "-DTBB",
-        ],
-    ),
-    (
-        "windows",
-        [ "-DOS_WIN", "-DWIN32", "-D_MBCS", "-DWIN64", "-DNOMINMAX" ]
+        ["-DOS_MACOSX"],
     ),
 ]
 
 ROCKSDB_PREPROCESSOR_FLAGS = [
+    "-DROCKSDB_PLATFORM_POSIX",
+    "-DROCKSDB_LIB_IO_POSIX",
     "-DROCKSDB_SUPPORT_THREAD_LOCAL",
 
     # Flags to enable libs we include
@@ -90,6 +77,7 @@ ROCKSDB_PREPROCESSOR_FLAGS = [
     "-DZSTD",
     "-DZSTD_STATIC_LINKING_ONLY",
     "-DGFLAGS=gflags",
+    "-DTBB",
 
     # Added missing flags from output of build_detect_platform
     "-DROCKSDB_BACKTRACE",
@@ -167,12 +155,12 @@ cpp_library(
 
 binary_template = """
 cpp_binary(
-    name = "{name}",
-    srcs = [{srcs}],
+    name = "%s",
+    srcs = [%s],
     arch_preprocessor_flags = ROCKSDB_ARCH_PREPROCESSOR_FLAGS,
     compiler_flags = ROCKSDB_COMPILER_FLAGS,
     preprocessor_flags = ROCKSDB_PREPROCESSOR_FLAGS,
-    deps = [{deps}],
+    deps = [%s],
     external_deps = ROCKSDB_EXTERNAL_DEPS,
 )
 """
@@ -189,7 +177,7 @@ test_cfg_template = """    [
 unittests_template = """
 # [test_name, test_src, test_type, extra_deps, extra_compiler_flags]
 ROCKS_TESTS = [
-{tests}]
+%s]
 
 # Generate a test rule for each entry in ROCKS_TESTS
 # Do not build the tests in opt mode, since SyncPoint and other test code

build_tools/format-diff.sh

@@ -52,15 +52,15 @@ else
     else
       echo "You didn't have clang-format-diff.py and/or clang-format available in your computer!"
       echo "You can download clang-format-diff.py by running: "
-      echo "    curl --location https://tinyurl.com/y2kvokof -o ${REPO_ROOT}/clang-format-diff.py"
+      echo "    curl --location http://goo.gl/iUW1u2 -o ${CLANG_FORMAT_DIFF}"
       echo "You can download clang-format by running:"
       echo "    brew install clang-format"
       echo "  Or"
       echo "    apt install clang-format"
       echo "  This might work too:"
       echo "    yum install git-clang-format"
-      echo "Then make sure clang-format is available and executable from \$PATH:"
-      echo "    clang-format --version"
+      echo "Then, move both files (i.e. ${CLANG_FORMAT_DIFF} and clang-format) to some directory within PATH=${PATH}"
+      echo "and make sure ${CLANG_FORMAT_DIFF} is executable."
       exit 128
     fi
     # Check argparse pre-req on interpreter, or it will fail
@@ -75,15 +75,17 @@ else
       exit 129
     fi
     # Unfortunately, some machines have a Python2 clang-format-diff.py
-    # installed but only a Python3 interpreter installed. Unfortunately,
-    # automatic 2to3 migration is insufficient, so suggest downloading latest.
+    # installed but only a Python3 interpreter installed. Rather than trying
+    # different Python versions that might be installed, we can try migrating
+    # the code to Python3 if it looks like Python2
     if grep -q "print '" "$CFD_PATH" && \
        ${PYTHON:-python3} --version | grep -q 'ython 3'; then
-      echo "You have clang-format-diff.py for Python 2 but are using a Python 3"
-      echo "interpreter (${PYTHON:-python3})."
-      echo "You can download clang-format-diff.py for Python 3 by running: "
-      echo "    curl --location https://tinyurl.com/y2kvokof -o ${REPO_ROOT}/clang-format-diff.py"
-      exit 130
+      if [ ! -f "$REPO_ROOT/.py3/clang-format-diff.py" ]; then
+        echo "Migrating $CFD_PATH to Python3 in a hidden file"
+        mkdir -p "$REPO_ROOT/.py3"
+        ${PYTHON:-python3} -m lib2to3 -w -n -o "$REPO_ROOT/.py3" "$CFD_PATH" > /dev/null || exit 128
+      fi
+      CFD_PATH="$REPO_ROOT/.py3/clang-format-diff.py"
     fi
     CLANG_FORMAT_DIFF="${PYTHON:-python3} $CFD_PATH"
     # This had better work after all those checks

cache/cache.cc

@@ -10,7 +10,7 @@
 #include "rocksdb/cache.h"
 
 #include "cache/lru_cache.h"
-#include "rocksdb/utilities/options_type.h"
+#include "options/options_helper.h"
 #include "util/string_util.h"
 
 namespace ROCKSDB_NAMESPACE {
@@ -19,19 +19,22 @@ static std::unordered_map<std::string, OptionTypeInfo>
     lru_cache_options_type_info = {
         {"capacity",
          {offsetof(struct LRUCacheOptions, capacity), OptionType::kSizeT,
-          OptionVerificationType::kNormal, OptionTypeFlags::kMutable}},
+          OptionVerificationType::kNormal, OptionTypeFlags::kMutable,
+          offsetof(struct LRUCacheOptions, capacity)}},
         {"num_shard_bits",
          {offsetof(struct LRUCacheOptions, num_shard_bits), OptionType::kInt,
-          OptionVerificationType::kNormal, OptionTypeFlags::kMutable}},
+          OptionVerificationType::kNormal, OptionTypeFlags::kMutable,
+          offsetof(struct LRUCacheOptions, num_shard_bits)}},
         {"strict_capacity_limit",
          {offsetof(struct LRUCacheOptions, strict_capacity_limit),
           OptionType::kBoolean, OptionVerificationType::kNormal,
-          OptionTypeFlags::kMutable}},
+          OptionTypeFlags::kMutable,
+          offsetof(struct LRUCacheOptions, strict_capacity_limit)}},
         {"high_pri_pool_ratio",
          {offsetof(struct LRUCacheOptions, high_pri_pool_ratio),
           OptionType::kDouble, OptionVerificationType::kNormal,
-          OptionTypeFlags::kMutable}},
-};
+          OptionTypeFlags::kMutable,
+          offsetof(struct LRUCacheOptions, high_pri_pool_ratio)}}};
 #endif  // ROCKSDB_LITE
 
 Status Cache::CreateFromString(const ConfigOptions& config_options,

cache/cache_bench.cc

@@ -136,7 +136,7 @@ struct KeyGen {
     for (uint32_t i = 0; i < FLAGS_skew; ++i) {
       raw = std::min(raw, rnd.Next());
     }
-    uint64_t key = FastRange64(raw, max_key);
+    uint64_t key = fastrange64(raw, max_key);
     // Variable size and alignment
     size_t off = key % 8;
     key_data[0] = char{42};

cache/cache_helpers.h

@@ -1,114 +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).
-
-#pragma once
-
-#include <cassert>
-
-#include "rocksdb/cache.h"
-#include "rocksdb/rocksdb_namespace.h"
-
-namespace ROCKSDB_NAMESPACE {
-
-// Returns the cached value given a cache handle.
-template <typename T>
-T* GetFromCacheHandle(Cache* cache, Cache::Handle* handle) {
-  assert(cache);
-  assert(handle);
-
-  return static_cast<T*>(cache->Value(handle));
-}
-
-// Simple generic deleter for Cache (to be used with Cache::Insert).
-template <typename T>
-void DeleteCacheEntry(const Slice& /* key */, void* value) {
-  delete static_cast<T*>(value);
-}
-
-// Turns a T* into a Slice so it can be used as a key with Cache.
-template <typename T>
-Slice GetSlice(const T* t) {
-  return Slice(reinterpret_cast<const char*>(t), sizeof(T));
-}
-
-// Generic resource management object for cache handles that releases the handle
-// when destroyed. Has unique ownership of the handle, so copying it is not
-// allowed, while moving it transfers ownership.
-template <typename T>
-class CacheHandleGuard {
- public:
-  CacheHandleGuard() = default;
-
-  CacheHandleGuard(Cache* cache, Cache::Handle* handle)
-      : cache_(cache),
-        handle_(handle),
-        value_(GetFromCacheHandle<T>(cache, handle)) {
-    assert(cache_ && handle_ && value_);
-  }
-
-  CacheHandleGuard(const CacheHandleGuard&) = delete;
-  CacheHandleGuard& operator=(const CacheHandleGuard&) = delete;
-
-  CacheHandleGuard(CacheHandleGuard&& rhs) noexcept
-      : cache_(rhs.cache_), handle_(rhs.handle_), value_(rhs.value_) {
-    assert((!cache_ && !handle_ && !value_) || (cache_ && handle_ && value_));
-
-    rhs.ResetFields();
-  }
-
-  CacheHandleGuard& operator=(CacheHandleGuard&& rhs) noexcept {
-    if (this == &rhs) {
-      return *this;
-    }
-
-    ReleaseHandle();
-
-    cache_ = rhs.cache_;
-    handle_ = rhs.handle_;
-    value_ = rhs.value_;
-
-    assert((!cache_ && !handle_ && !value_) || (cache_ && handle_ && value_));
-
-    rhs.ResetFields();
-
-    return *this;
-  }
-
-  ~CacheHandleGuard() { ReleaseHandle(); }
-
-  bool IsEmpty() const { return !handle_; }
-
-  Cache* GetCache() const { return cache_; }
-  Cache::Handle* GetCacheHandle() const { return handle_; }
-  T* GetValue() const { return value_; }
-
-  void Reset() {
-    ReleaseHandle();
-    ResetFields();
-  }
-
- private:
-  void ReleaseHandle() {
-    if (IsEmpty()) {
-      return;
-    }
-
-    assert(cache_);
-    cache_->Release(handle_);
-  }
-
-  void ResetFields() {
-    cache_ = nullptr;
-    handle_ = nullptr;
-    value_ = nullptr;
-  }
-
- private:
-  Cache* cache_ = nullptr;
-  Cache::Handle* handle_ = nullptr;
-  T* value_ = nullptr;
-};
-
-}  // namespace ROCKSDB_NAMESPACE

cache/lru_cache.cc

@@ -11,6 +11,7 @@
 
 #include <assert.h>
 #include <stdio.h>
+#include <stdlib.h>
 #include <string>
 
 #include "util/mutexlock.h"

db/blob/blob_file_builder.cc

@@ -31,13 +31,12 @@ BlobFileBuilder::BlobFileBuilder(
     int job_id, uint32_t column_family_id,
     const std::string& column_family_name, Env::IOPriority io_priority,
     Env::WriteLifeTimeHint write_hint,
-    std::vector<std::string>* blob_file_paths,
     std::vector<BlobFileAddition>* blob_file_additions)
     : BlobFileBuilder([versions]() { return versions->NewFileNumber(); }, env,
                       fs, immutable_cf_options, mutable_cf_options,
                       file_options, job_id, column_family_id,
                       column_family_name, io_priority, write_hint,
-                      blob_file_paths, blob_file_additions) {}
+                      blob_file_additions) {}
 
 BlobFileBuilder::BlobFileBuilder(
     std::function<uint64_t()> file_number_generator, Env* env, FileSystem* fs,
@@ -46,7 +45,6 @@ BlobFileBuilder::BlobFileBuilder(
     int job_id, uint32_t column_family_id,
     const std::string& column_family_name, Env::IOPriority io_priority,
     Env::WriteLifeTimeHint write_hint,
-    std::vector<std::string>* blob_file_paths,
     std::vector<BlobFileAddition>* blob_file_additions)
     : file_number_generator_(std::move(file_number_generator)),
       env_(env),
@@ -61,7 +59,6 @@ BlobFileBuilder::BlobFileBuilder(
       column_family_name_(column_family_name),
       io_priority_(io_priority),
       write_hint_(write_hint),
-      blob_file_paths_(blob_file_paths),
       blob_file_additions_(blob_file_additions),
       blob_count_(0),
       blob_bytes_(0) {
@@ -70,10 +67,7 @@ BlobFileBuilder::BlobFileBuilder(
   assert(fs_);
   assert(immutable_cf_options_);
   assert(file_options_);
-  assert(blob_file_paths_);
-  assert(blob_file_paths_->empty());
   assert(blob_file_additions_);
-  assert(blob_file_additions_->empty());
 }
 
 BlobFileBuilder::~BlobFileBuilder() = default;
@@ -151,7 +145,7 @@ Status BlobFileBuilder::OpenBlobFileIfNeeded() {
 
   assert(immutable_cf_options_);
   assert(!immutable_cf_options_->cf_paths.empty());
-  std::string blob_file_path = BlobFileName(
+  const std::string blob_file_path = BlobFileName(
       immutable_cf_options_->cf_paths.front().path, blob_file_number);
 
   std::unique_ptr<FSWritableFile> file;
@@ -167,12 +161,6 @@ Status BlobFileBuilder::OpenBlobFileIfNeeded() {
     }
   }
 
-  // Note: files get added to blob_file_paths_ right after the open, so they
-  // can be cleaned up upon failure. Contrast this with blob_file_additions_,
-  // which only contains successfully written files.
-  assert(blob_file_paths_);
-  blob_file_paths_->emplace_back(std::move(blob_file_path));
-
   assert(file);
   file->SetIOPriority(io_priority_);
   file->SetWriteLifeTimeHint(write_hint_);
@@ -180,7 +168,7 @@ Status BlobFileBuilder::OpenBlobFileIfNeeded() {
   Statistics* const statistics = immutable_cf_options_->statistics;
 
   std::unique_ptr<WritableFileWriter> file_writer(new WritableFileWriter(
-      std::move(file), blob_file_paths_->back(), *file_options_, env_,
+      std::move(file), blob_file_path, *file_options_, env_,
       nullptr /*IOTracer*/, statistics, immutable_cf_options_->listeners,
       immutable_cf_options_->file_checksum_gen_factory));
 

db/blob/blob_file_builder.h

@@ -36,7 +36,6 @@ class BlobFileBuilder {
                   const std::string& column_family_name,
                   Env::IOPriority io_priority,
                   Env::WriteLifeTimeHint write_hint,
-                  std::vector<std::string>* blob_file_paths,
                   std::vector<BlobFileAddition>* blob_file_additions);
 
   BlobFileBuilder(std::function<uint64_t()> file_number_generator, Env* env,
@@ -48,7 +47,6 @@ class BlobFileBuilder {
                   const std::string& column_family_name,
                   Env::IOPriority io_priority,
                   Env::WriteLifeTimeHint write_hint,
-                  std::vector<std::string>* blob_file_paths,
                   std::vector<BlobFileAddition>* blob_file_additions);
 
   BlobFileBuilder(const BlobFileBuilder&) = delete;
@@ -81,7 +79,6 @@ class BlobFileBuilder {
   std::string column_family_name_;
   Env::IOPriority io_priority_;
   Env::WriteLifeTimeHint write_hint_;
-  std::vector<std::string>* blob_file_paths_;
   std::vector<BlobFileAddition>* blob_file_additions_;
   std::unique_ptr<BlobLogWriter> writer_;
   uint64_t blob_count_;

db/blob/blob_file_builder_test.cc

@@ -14,7 +14,7 @@
 #include "db/blob/blob_file_addition.h"
 #include "db/blob/blob_index.h"
 #include "db/blob/blob_log_format.h"
-#include "db/blob/blob_log_sequential_reader.h"
+#include "db/blob/blob_log_reader.h"
 #include "env/composite_env_wrapper.h"
 #include "env/mock_env.h"
 #include "file/filename.h"
@@ -42,15 +42,17 @@ class BlobFileBuilderTest : public testing::Test {
  protected:
   BlobFileBuilderTest() : mock_env_(Env::Default()), fs_(&mock_env_) {}
 
-  void VerifyBlobFile(uint64_t blob_file_number,
-                      const std::string& blob_file_path,
-                      uint32_t column_family_id,
+  void VerifyBlobFile(const ImmutableCFOptions& immutable_cf_options,
+                      uint64_t blob_file_number, uint32_t column_family_id,
                       CompressionType blob_compression_type,
                       const std::vector<std::pair<std::string, std::string>>&
                           expected_key_value_pairs,
                       const std::vector<std::string>& blob_indexes) {
     assert(expected_key_value_pairs.size() == blob_indexes.size());
 
+    const std::string blob_file_path = BlobFileName(
+        immutable_cf_options.cf_paths.front().path, blob_file_number);
+
     std::unique_ptr<FSRandomAccessFile> file;
     constexpr IODebugContext* dbg = nullptr;
     ASSERT_OK(
@@ -61,8 +63,8 @@ class BlobFileBuilderTest : public testing::Test {
                                    &mock_env_));
 
     constexpr Statistics* statistics = nullptr;
-    BlobLogSequentialReader blob_log_reader(std::move(file_reader), &mock_env_,
-                                            statistics);
+    BlobLogReader blob_log_reader(std::move(file_reader), &mock_env_,
+                                  statistics);
 
     BlobLogHeader header;
     ASSERT_OK(blob_log_reader.ReadHeader(&header));
@@ -77,7 +79,7 @@ class BlobFileBuilderTest : public testing::Test {
       uint64_t blob_offset = 0;
 
       ASSERT_OK(blob_log_reader.ReadRecord(
-          &record, BlobLogSequentialReader::kReadHeaderKeyBlob, &blob_offset));
+          &record, BlobLogReader::kReadHeaderKeyBlob, &blob_offset));
 
       // Check the contents of the blob file
       const auto& expected_key_value = expected_key_value_pairs[i];
@@ -135,14 +137,12 @@ TEST_F(BlobFileBuilderTest, BuildAndCheckOneFile) {
   constexpr Env::IOPriority io_priority = Env::IO_HIGH;
   constexpr Env::WriteLifeTimeHint write_hint = Env::WLTH_MEDIUM;
 
-  std::vector<std::string> blob_file_paths;
   std::vector<BlobFileAddition> blob_file_additions;
 
-  BlobFileBuilder builder(TestFileNumberGenerator(), &mock_env_, &fs_,
-                          &immutable_cf_options, &mutable_cf_options,
-                          &file_options_, job_id, column_family_id,
-                          column_family_name, io_priority, write_hint,
-                          &blob_file_paths, &blob_file_additions);
+  BlobFileBuilder builder(
+      TestFileNumberGenerator(), &mock_env_, &fs_, &immutable_cf_options,
+      &mutable_cf_options, &file_options_, job_id, column_family_id,
+      column_family_name, io_priority, write_hint, &blob_file_additions);
 
   std::vector<std::pair<std::string, std::string>> expected_key_value_pairs(
       number_of_blobs);
@@ -168,20 +168,12 @@ TEST_F(BlobFileBuilderTest, BuildAndCheckOneFile) {
   ASSERT_OK(builder.Finish());
 
   // Check the metadata generated
-  constexpr uint64_t blob_file_number = 2;
-
-  ASSERT_EQ(blob_file_paths.size(), 1);
-
-  const std::string& blob_file_path = blob_file_paths[0];
-
-  ASSERT_EQ(blob_file_path,
-            BlobFileName(immutable_cf_options.cf_paths.front().path,
-                         blob_file_number));
-
   ASSERT_EQ(blob_file_additions.size(), 1);
 
   const auto& blob_file_addition = blob_file_additions[0];
 
+  constexpr uint64_t blob_file_number = 2;
+
   ASSERT_EQ(blob_file_addition.GetBlobFileNumber(), blob_file_number);
   ASSERT_EQ(blob_file_addition.GetTotalBlobCount(), number_of_blobs);
   ASSERT_EQ(
@@ -189,7 +181,7 @@ TEST_F(BlobFileBuilderTest, BuildAndCheckOneFile) {
       number_of_blobs * (BlobLogRecord::kHeaderSize + key_size + value_size));
 
   // Verify the contents of the new blob file as well as the blob references
-  VerifyBlobFile(blob_file_number, blob_file_path, column_family_id,
+  VerifyBlobFile(immutable_cf_options, blob_file_number, column_family_id,
                  kNoCompression, expected_key_value_pairs, blob_indexes);
 }
 
@@ -218,14 +210,12 @@ TEST_F(BlobFileBuilderTest, BuildAndCheckMultipleFiles) {
   constexpr Env::IOPriority io_priority = Env::IO_HIGH;
   constexpr Env::WriteLifeTimeHint write_hint = Env::WLTH_MEDIUM;
 
-  std::vector<std::string> blob_file_paths;
   std::vector<BlobFileAddition> blob_file_additions;
 
-  BlobFileBuilder builder(TestFileNumberGenerator(), &mock_env_, &fs_,
-                          &immutable_cf_options, &mutable_cf_options,
-                          &file_options_, job_id, column_family_id,
-                          column_family_name, io_priority, write_hint,
-                          &blob_file_paths, &blob_file_additions);
+  BlobFileBuilder builder(
+      TestFileNumberGenerator(), &mock_env_, &fs_, &immutable_cf_options,
+      &mutable_cf_options, &file_options_, job_id, column_family_id,
+      column_family_name, io_priority, write_hint, &blob_file_additions);
 
   std::vector<std::pair<std::string, std::string>> expected_key_value_pairs(
       number_of_blobs);
@@ -251,19 +241,12 @@ TEST_F(BlobFileBuilderTest, BuildAndCheckMultipleFiles) {
   ASSERT_OK(builder.Finish());
 
   // Check the metadata generated
-  ASSERT_EQ(blob_file_paths.size(), number_of_blobs);
   ASSERT_EQ(blob_file_additions.size(), number_of_blobs);
 
   for (size_t i = 0; i < number_of_blobs; ++i) {
-    const uint64_t blob_file_number = i + 2;
-
-    ASSERT_EQ(blob_file_paths[i],
-              BlobFileName(immutable_cf_options.cf_paths.front().path,
-                           blob_file_number));
-
     const auto& blob_file_addition = blob_file_additions[i];
 
-    ASSERT_EQ(blob_file_addition.GetBlobFileNumber(), blob_file_number);
+    ASSERT_EQ(blob_file_addition.GetBlobFileNumber(), i + 2);
     ASSERT_EQ(blob_file_addition.GetTotalBlobCount(), 1);
     ASSERT_EQ(blob_file_addition.GetTotalBlobBytes(),
               BlobLogRecord::kHeaderSize + key_size + value_size);
@@ -275,8 +258,8 @@ TEST_F(BlobFileBuilderTest, BuildAndCheckMultipleFiles) {
         expected_key_value_pairs[i]};
     std::vector<std::string> blob_index{blob_indexes[i]};
 
-    VerifyBlobFile(i + 2, blob_file_paths[i], column_family_id, kNoCompression,
-                   expected_key_value_pair, blob_index);
+    VerifyBlobFile(immutable_cf_options, i + 2, column_family_id,
+                   kNoCompression, expected_key_value_pair, blob_index);
   }
 }
 
@@ -303,14 +286,12 @@ TEST_F(BlobFileBuilderTest, InlinedValues) {
   constexpr Env::IOPriority io_priority = Env::IO_HIGH;
   constexpr Env::WriteLifeTimeHint write_hint = Env::WLTH_MEDIUM;
 
-  std::vector<std::string> blob_file_paths;
   std::vector<BlobFileAddition> blob_file_additions;
 
-  BlobFileBuilder builder(TestFileNumberGenerator(), &mock_env_, &fs_,
-                          &immutable_cf_options, &mutable_cf_options,
-                          &file_options_, job_id, column_family_id,
-                          column_family_name, io_priority, write_hint,
-                          &blob_file_paths, &blob_file_additions);
+  BlobFileBuilder builder(
+      TestFileNumberGenerator(), &mock_env_, &fs_, &immutable_cf_options,
+      &mutable_cf_options, &file_options_, job_id, column_family_id,
+      column_family_name, io_priority, write_hint, &blob_file_additions);
 
   for (size_t i = 0; i < number_of_blobs; ++i) {
     const std::string key = std::to_string(i);
@@ -327,7 +308,6 @@ TEST_F(BlobFileBuilderTest, InlinedValues) {
   ASSERT_OK(builder.Finish());
 
   // Check the metadata generated
-  ASSERT_TRUE(blob_file_paths.empty());
   ASSERT_TRUE(blob_file_additions.empty());
 }
 
@@ -355,14 +335,12 @@ TEST_F(BlobFileBuilderTest, Compression) {
   constexpr Env::IOPriority io_priority = Env::IO_HIGH;
   constexpr Env::WriteLifeTimeHint write_hint = Env::WLTH_MEDIUM;
 
-  std::vector<std::string> blob_file_paths;
   std::vector<BlobFileAddition> blob_file_additions;
 
-  BlobFileBuilder builder(TestFileNumberGenerator(), &mock_env_, &fs_,
-                          &immutable_cf_options, &mutable_cf_options,
-                          &file_options_, job_id, column_family_id,
-                          column_family_name, io_priority, write_hint,
-                          &blob_file_paths, &blob_file_additions);
+  BlobFileBuilder builder(
+      TestFileNumberGenerator(), &mock_env_, &fs_, &immutable_cf_options,
+      &mutable_cf_options, &file_options_, job_id, column_family_id,
+      column_family_name, io_priority, write_hint, &blob_file_additions);
 
   const std::string key("1");
   const std::string uncompressed_value(value_size, 'x');
@@ -375,20 +353,12 @@ TEST_F(BlobFileBuilderTest, Compression) {
   ASSERT_OK(builder.Finish());
 
   // Check the metadata generated
-  constexpr uint64_t blob_file_number = 2;
-
-  ASSERT_EQ(blob_file_paths.size(), 1);
-
-  const std::string& blob_file_path = blob_file_paths[0];
-
-  ASSERT_EQ(blob_file_path,
-            BlobFileName(immutable_cf_options.cf_paths.front().path,
-                         blob_file_number));
-
   ASSERT_EQ(blob_file_additions.size(), 1);
 
   const auto& blob_file_addition = blob_file_additions[0];
 
+  constexpr uint64_t blob_file_number = 2;
+
   ASSERT_EQ(blob_file_addition.GetBlobFileNumber(), blob_file_number);
   ASSERT_EQ(blob_file_addition.GetTotalBlobCount(), 1);
 
@@ -411,7 +381,7 @@ TEST_F(BlobFileBuilderTest, Compression) {
       {key, compressed_value}};
   std::vector<std::string> blob_indexes{blob_index};
 
-  VerifyBlobFile(blob_file_number, blob_file_path, column_family_id,
+  VerifyBlobFile(immutable_cf_options, blob_file_number, column_family_id,
                  kSnappyCompression, expected_key_value_pairs, blob_indexes);
 }
 
@@ -437,14 +407,12 @@ TEST_F(BlobFileBuilderTest, CompressionError) {
   constexpr Env::IOPriority io_priority = Env::IO_HIGH;
   constexpr Env::WriteLifeTimeHint write_hint = Env::WLTH_MEDIUM;
 
-  std::vector<std::string> blob_file_paths;
   std::vector<BlobFileAddition> blob_file_additions;
 
-  BlobFileBuilder builder(TestFileNumberGenerator(), &mock_env_, &fs_,
-                          &immutable_cf_options, &mutable_cf_options,
-                          &file_options_, job_id, column_family_id,
-                          column_family_name, io_priority, write_hint,
-                          &blob_file_paths, &blob_file_additions);
+  BlobFileBuilder builder(
+      TestFileNumberGenerator(), &mock_env_, &fs_, &immutable_cf_options,
+      &mutable_cf_options, &file_options_, job_id, column_family_id,
+      column_family_name, io_priority, write_hint, &blob_file_additions);
 
   SyncPoint::GetInstance()->SetCallBack("CompressData:TamperWithReturnValue",
                                         [](void* arg) {
@@ -462,15 +430,6 @@ TEST_F(BlobFileBuilderTest, CompressionError) {
 
   SyncPoint::GetInstance()->DisableProcessing();
   SyncPoint::GetInstance()->ClearAllCallBacks();
-
-  constexpr uint64_t blob_file_number = 2;
-
-  ASSERT_EQ(blob_file_paths.size(), 1);
-  ASSERT_EQ(blob_file_paths[0],
-            BlobFileName(immutable_cf_options.cf_paths.front().path,
-                         blob_file_number));
-
-  ASSERT_TRUE(blob_file_additions.empty());
 }
 
 TEST_F(BlobFileBuilderTest, Checksum) {
@@ -514,14 +473,12 @@ TEST_F(BlobFileBuilderTest, Checksum) {
   constexpr Env::IOPriority io_priority = Env::IO_HIGH;
   constexpr Env::WriteLifeTimeHint write_hint = Env::WLTH_MEDIUM;
 
-  std::vector<std::string> blob_file_paths;
   std::vector<BlobFileAddition> blob_file_additions;
 
-  BlobFileBuilder builder(TestFileNumberGenerator(), &mock_env_, &fs_,
-                          &immutable_cf_options, &mutable_cf_options,
-                          &file_options_, job_id, column_family_id,
-                          column_family_name, io_priority, write_hint,
-                          &blob_file_paths, &blob_file_additions);
+  BlobFileBuilder builder(
+      TestFileNumberGenerator(), &mock_env_, &fs_, &immutable_cf_options,
+      &mutable_cf_options, &file_options_, job_id, column_family_id,
+      column_family_name, io_priority, write_hint, &blob_file_additions);
 
   const std::string key("1");
   const std::string value("deadbeef");
@@ -534,20 +491,12 @@ TEST_F(BlobFileBuilderTest, Checksum) {
   ASSERT_OK(builder.Finish());
 
   // Check the metadata generated
-  constexpr uint64_t blob_file_number = 2;
-
-  ASSERT_EQ(blob_file_paths.size(), 1);
-
-  const std::string& blob_file_path = blob_file_paths[0];
-
-  ASSERT_EQ(blob_file_path,
-            BlobFileName(immutable_cf_options.cf_paths.front().path,
-                         blob_file_number));
-
   ASSERT_EQ(blob_file_additions.size(), 1);
 
   const auto& blob_file_addition = blob_file_additions[0];
 
+  constexpr uint64_t blob_file_number = 2;
+
   ASSERT_EQ(blob_file_addition.GetBlobFileNumber(), blob_file_number);
   ASSERT_EQ(blob_file_addition.GetTotalBlobCount(), 1);
   ASSERT_EQ(blob_file_addition.GetTotalBlobBytes(),
@@ -560,7 +509,7 @@ TEST_F(BlobFileBuilderTest, Checksum) {
       {key, value}};
   std::vector<std::string> blob_indexes{blob_index};
 
-  VerifyBlobFile(blob_file_number, blob_file_path, column_family_id,
+  VerifyBlobFile(immutable_cf_options, blob_file_number, column_family_id,
                  kNoCompression, expected_key_value_pairs, blob_indexes);
 }
 
@@ -612,14 +561,13 @@ TEST_P(BlobFileBuilderIOErrorTest, IOError) {
   constexpr Env::IOPriority io_priority = Env::IO_HIGH;
   constexpr Env::WriteLifeTimeHint write_hint = Env::WLTH_MEDIUM;
 
-  std::vector<std::string> blob_file_paths;
   std::vector<BlobFileAddition> blob_file_additions;
 
   BlobFileBuilder builder(TestFileNumberGenerator(), &fault_injection_env_,
                           &fs_, &immutable_cf_options, &mutable_cf_options,
                           &file_options_, job_id, column_family_id,
                           column_family_name, io_priority, write_hint,
-                          &blob_file_paths, &blob_file_additions);
+                          &blob_file_additions);
 
   SyncPoint::GetInstance()->SetCallBack(sync_point_, [this](void* /* arg */) {
     fault_injection_env_.SetFilesystemActive(false,
@@ -636,19 +584,6 @@ TEST_P(BlobFileBuilderIOErrorTest, IOError) {
 
   SyncPoint::GetInstance()->DisableProcessing();
   SyncPoint::GetInstance()->ClearAllCallBacks();
-
-  if (sync_point_ == "BlobFileBuilder::OpenBlobFileIfNeeded:NewWritableFile") {
-    ASSERT_TRUE(blob_file_paths.empty());
-  } else {
-    constexpr uint64_t blob_file_number = 2;
-
-    ASSERT_EQ(blob_file_paths.size(), 1);
-    ASSERT_EQ(blob_file_paths[0],
-              BlobFileName(immutable_cf_options.cf_paths.front().path,
-                           blob_file_number));
-  }
-
-  ASSERT_TRUE(blob_file_additions.empty());
 }
 
 }  // namespace ROCKSDB_NAMESPACE

db/blob/blob_file_cache.cc

@@ -1,99 +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 "db/blob/blob_file_cache.h"
-
-#include <cassert>
-#include <memory>
-
-#include "db/blob/blob_file_reader.h"
-#include "options/cf_options.h"
-#include "rocksdb/cache.h"
-#include "rocksdb/slice.h"
-#include "test_util/sync_point.h"
-#include "util/hash.h"
-
-namespace ROCKSDB_NAMESPACE {
-
-BlobFileCache::BlobFileCache(Cache* cache,
-                             const ImmutableCFOptions* immutable_cf_options,
-                             const FileOptions* file_options,
-                             uint32_t column_family_id,
-                             HistogramImpl* blob_file_read_hist)
-    : cache_(cache),
-      mutex_(kNumberOfMutexStripes, GetSliceNPHash64),
-      immutable_cf_options_(immutable_cf_options),
-      file_options_(file_options),
-      column_family_id_(column_family_id),
-      blob_file_read_hist_(blob_file_read_hist) {
-  assert(cache_);
-  assert(immutable_cf_options_);
-  assert(file_options_);
-}
-
-Status BlobFileCache::GetBlobFileReader(
-    uint64_t blob_file_number,
-    CacheHandleGuard<BlobFileReader>* blob_file_reader) {
-  assert(blob_file_reader);
-  assert(blob_file_reader->IsEmpty());
-
-  const Slice key = GetSlice(&blob_file_number);
-
-  assert(cache_);
-
-  Cache::Handle* handle = cache_->Lookup(key);
-  if (handle) {
-    *blob_file_reader = CacheHandleGuard<BlobFileReader>(cache_, handle);
-    return Status::OK();
-  }
-
-  TEST_SYNC_POINT("BlobFileCache::GetBlobFileReader:DoubleCheck");
-
-  // Check again while holding mutex
-  MutexLock lock(mutex_.get(key));
-
-  handle = cache_->Lookup(key);
-  if (handle) {
-    *blob_file_reader = CacheHandleGuard<BlobFileReader>(cache_, handle);
-    return Status::OK();
-  }
-
-  assert(immutable_cf_options_);
-  Statistics* const statistics = immutable_cf_options_->statistics;
-
-  RecordTick(statistics, NO_FILE_OPENS);
-
-  std::unique_ptr<BlobFileReader> reader;
-
-  {
-    assert(file_options_);
-    const Status s = BlobFileReader::Create(
-        *immutable_cf_options_, *file_options_, column_family_id_,
-        blob_file_read_hist_, blob_file_number, &reader);
-    if (!s.ok()) {
-      RecordTick(statistics, NO_FILE_ERRORS);
-      return s;
-    }
-  }
-
-  {
-    constexpr size_t charge = 1;
-
-    const Status s = cache_->Insert(key, reader.get(), charge,
-                                    &DeleteCacheEntry<BlobFileReader>, &handle);
-    if (!s.ok()) {
-      RecordTick(statistics, NO_FILE_ERRORS);
-      return s;
-    }
-  }
-
-  reader.release();
-
-  *blob_file_reader = CacheHandleGuard<BlobFileReader>(cache_, handle);
-
-  return Status::OK();
-}
-
-}  // namespace ROCKSDB_NAMESPACE

db/blob/blob_file_cache.h

@@ -1,49 +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).
-
-#pragma once
-
-#include <cinttypes>
-
-#include "cache/cache_helpers.h"
-#include "rocksdb/rocksdb_namespace.h"
-#include "util/mutexlock.h"
-
-namespace ROCKSDB_NAMESPACE {
-
-class Cache;
-struct ImmutableCFOptions;
-struct FileOptions;
-class HistogramImpl;
-class Status;
-class BlobFileReader;
-class Slice;
-
-class BlobFileCache {
- public:
-  BlobFileCache(Cache* cache, const ImmutableCFOptions* immutable_cf_options,
-                const FileOptions* file_options, uint32_t column_family_id,
-                HistogramImpl* blob_file_read_hist);
-
-  BlobFileCache(const BlobFileCache&) = delete;
-  BlobFileCache& operator=(const BlobFileCache&) = delete;
-
-  Status GetBlobFileReader(uint64_t blob_file_number,
-                           CacheHandleGuard<BlobFileReader>* blob_file_reader);
-
- private:
-  Cache* cache_;
-  // Note: mutex_ below is used to guard against multiple threads racing to open
-  // the same file.
-  Striped<port::Mutex, Slice> mutex_;
-  const ImmutableCFOptions* immutable_cf_options_;
-  const FileOptions* file_options_;
-  uint32_t column_family_id_;
-  HistogramImpl* blob_file_read_hist_;
-
-  static constexpr size_t kNumberOfMutexStripes = 1 << 7;
-};
-
-}  // namespace ROCKSDB_NAMESPACE

db/blob/blob_file_cache_test.cc

@@ -1,268 +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 "db/blob/blob_file_cache.h"
-
-#include <cassert>
-#include <string>
-
-#include "db/blob/blob_log_format.h"
-#include "db/blob/blob_log_writer.h"
-#include "env/mock_env.h"
-#include "file/filename.h"
-#include "file/read_write_util.h"
-#include "file/writable_file_writer.h"
-#include "options/cf_options.h"
-#include "rocksdb/cache.h"
-#include "rocksdb/env.h"
-#include "rocksdb/file_system.h"
-#include "rocksdb/options.h"
-#include "rocksdb/statistics.h"
-#include "test_util/sync_point.h"
-#include "test_util/testharness.h"
-
-namespace ROCKSDB_NAMESPACE {
-
-namespace {
-
-// Creates a test blob file with a single blob in it.
-void WriteBlobFile(uint32_t column_family_id,
-                   const ImmutableCFOptions& immutable_cf_options,
-                   uint64_t blob_file_number) {
-  assert(!immutable_cf_options.cf_paths.empty());
-
-  const std::string blob_file_path = BlobFileName(
-      immutable_cf_options.cf_paths.front().path, blob_file_number);
-
-  std::unique_ptr<FSWritableFile> file;
-  ASSERT_OK(NewWritableFile(immutable_cf_options.fs, blob_file_path, &file,
-                            FileOptions()));
-
-  std::unique_ptr<WritableFileWriter> file_writer(
-      new WritableFileWriter(std::move(file), blob_file_path, FileOptions(),
-                             immutable_cf_options.env));
-
-  constexpr Statistics* statistics = nullptr;
-  constexpr bool use_fsync = false;
-
-  BlobLogWriter blob_log_writer(std::move(file_writer),
-                                immutable_cf_options.env, statistics,
-                                blob_file_number, use_fsync);
-
-  constexpr bool has_ttl = false;
-  constexpr ExpirationRange expiration_range;
-
-  BlobLogHeader header(column_family_id, kNoCompression, has_ttl,
-                       expiration_range);
-
-  ASSERT_OK(blob_log_writer.WriteHeader(header));
-
-  constexpr char key[] = "key";
-  constexpr char blob[] = "blob";
-
-  std::string compressed_blob;
-  Slice blob_to_write;
-
-  uint64_t key_offset = 0;
-  uint64_t blob_offset = 0;
-
-  ASSERT_OK(blob_log_writer.AddRecord(key, blob, &key_offset, &blob_offset));
-
-  BlobLogFooter footer;
-  footer.blob_count = 1;
-  footer.expiration_range = expiration_range;
-
-  std::string checksum_method;
-  std::string checksum_value;
-
-  ASSERT_OK(
-      blob_log_writer.AppendFooter(footer, &checksum_method, &checksum_value));
-}
-
-}  // anonymous namespace
-
-class BlobFileCacheTest : public testing::Test {
- protected:
-  BlobFileCacheTest() : mock_env_(Env::Default()) {}
-
-  MockEnv mock_env_;
-};
-
-TEST_F(BlobFileCacheTest, GetBlobFileReader) {
-  Options options;
-  options.env = &mock_env_;
-  options.statistics = CreateDBStatistics();
-  options.cf_paths.emplace_back(
-      test::PerThreadDBPath(&mock_env_, "BlobFileCacheTest_GetBlobFileReader"),
-      0);
-  options.enable_blob_files = true;
-
-  constexpr uint32_t column_family_id = 1;
-  ImmutableCFOptions immutable_cf_options(options);
-  constexpr uint64_t blob_file_number = 123;
-
-  WriteBlobFile(column_family_id, immutable_cf_options, blob_file_number);
-
-  constexpr size_t capacity = 10;
-  std::shared_ptr<Cache> backing_cache = NewLRUCache(capacity);
-
-  FileOptions file_options;
-  constexpr HistogramImpl* blob_file_read_hist = nullptr;
-
-  BlobFileCache blob_file_cache(backing_cache.get(), &immutable_cf_options,
-                                &file_options, column_family_id,
-                                blob_file_read_hist);
-
-  // First try: reader should be opened and put in cache
-  CacheHandleGuard<BlobFileReader> first;
-
-  ASSERT_OK(blob_file_cache.GetBlobFileReader(blob_file_number, &first));
-  ASSERT_NE(first.GetValue(), nullptr);
-  ASSERT_EQ(options.statistics->getTickerCount(NO_FILE_OPENS), 1);
-  ASSERT_EQ(options.statistics->getTickerCount(NO_FILE_ERRORS), 0);
-
-  // Second try: reader should be served from cache
-  CacheHandleGuard<BlobFileReader> second;
-
-  ASSERT_OK(blob_file_cache.GetBlobFileReader(blob_file_number, &second));
-  ASSERT_NE(second.GetValue(), nullptr);
-  ASSERT_EQ(options.statistics->getTickerCount(NO_FILE_OPENS), 1);
-  ASSERT_EQ(options.statistics->getTickerCount(NO_FILE_ERRORS), 0);
-
-  ASSERT_EQ(first.GetValue(), second.GetValue());
-}
-
-TEST_F(BlobFileCacheTest, GetBlobFileReader_Race) {
-  Options options;
-  options.env = &mock_env_;
-  options.statistics = CreateDBStatistics();
-  options.cf_paths.emplace_back(
-      test::PerThreadDBPath(&mock_env_,
-                            "BlobFileCacheTest_GetBlobFileReader_Race"),
-      0);
-  options.enable_blob_files = true;
-
-  constexpr uint32_t column_family_id = 1;
-  ImmutableCFOptions immutable_cf_options(options);
-  constexpr uint64_t blob_file_number = 123;
-
-  WriteBlobFile(column_family_id, immutable_cf_options, blob_file_number);
-
-  constexpr size_t capacity = 10;
-  std::shared_ptr<Cache> backing_cache = NewLRUCache(capacity);
-
-  FileOptions file_options;
-  constexpr HistogramImpl* blob_file_read_hist = nullptr;
-
-  BlobFileCache blob_file_cache(backing_cache.get(), &immutable_cf_options,
-                                &file_options, column_family_id,
-                                blob_file_read_hist);
-
-  CacheHandleGuard<BlobFileReader> first;
-  CacheHandleGuard<BlobFileReader> second;
-
-  SyncPoint::GetInstance()->SetCallBack(
-      "BlobFileCache::GetBlobFileReader:DoubleCheck", [&](void* /* arg */) {
-        // Disabling sync points to prevent infinite recursion
-        SyncPoint::GetInstance()->DisableProcessing();
-
-        ASSERT_OK(blob_file_cache.GetBlobFileReader(blob_file_number, &second));
-        ASSERT_NE(second.GetValue(), nullptr);
-        ASSERT_EQ(options.statistics->getTickerCount(NO_FILE_OPENS), 1);
-        ASSERT_EQ(options.statistics->getTickerCount(NO_FILE_ERRORS), 0);
-      });
-  SyncPoint::GetInstance()->EnableProcessing();
-
-  ASSERT_OK(blob_file_cache.GetBlobFileReader(blob_file_number, &first));
-  ASSERT_NE(first.GetValue(), nullptr);
-  ASSERT_EQ(options.statistics->getTickerCount(NO_FILE_OPENS), 1);
-  ASSERT_EQ(options.statistics->getTickerCount(NO_FILE_ERRORS), 0);
-
-  ASSERT_EQ(first.GetValue(), second.GetValue());
-
-  SyncPoint::GetInstance()->DisableProcessing();
-  SyncPoint::GetInstance()->ClearAllCallBacks();
-}
-
-TEST_F(BlobFileCacheTest, GetBlobFileReader_IOError) {
-  Options options;
-  options.env = &mock_env_;
-  options.statistics = CreateDBStatistics();
-  options.cf_paths.emplace_back(
-      test::PerThreadDBPath(&mock_env_,
-                            "BlobFileCacheTest_GetBlobFileReader_IOError"),
-      0);
-  options.enable_blob_files = true;
-
-  constexpr size_t capacity = 10;
-  std::shared_ptr<Cache> backing_cache = NewLRUCache(capacity);
-
-  ImmutableCFOptions immutable_cf_options(options);
-  FileOptions file_options;
-  constexpr uint32_t column_family_id = 1;
-  constexpr HistogramImpl* blob_file_read_hist = nullptr;
-
-  BlobFileCache blob_file_cache(backing_cache.get(), &immutable_cf_options,
-                                &file_options, column_family_id,
-                                blob_file_read_hist);
-
-  // Note: there is no blob file with the below number
-  constexpr uint64_t blob_file_number = 123;
-
-  CacheHandleGuard<BlobFileReader> reader;
-
-  ASSERT_TRUE(
-      blob_file_cache.GetBlobFileReader(blob_file_number, &reader).IsIOError());
-  ASSERT_EQ(reader.GetValue(), nullptr);
-  ASSERT_EQ(options.statistics->getTickerCount(NO_FILE_OPENS), 1);
-  ASSERT_EQ(options.statistics->getTickerCount(NO_FILE_ERRORS), 1);
-}
-
-TEST_F(BlobFileCacheTest, GetBlobFileReader_CacheFull) {
-  Options options;
-  options.env = &mock_env_;
-  options.statistics = CreateDBStatistics();
-  options.cf_paths.emplace_back(
-      test::PerThreadDBPath(&mock_env_,
-                            "BlobFileCacheTest_GetBlobFileReader_CacheFull"),
-      0);
-  options.enable_blob_files = true;
-
-  constexpr uint32_t column_family_id = 1;
-  ImmutableCFOptions immutable_cf_options(options);
-  constexpr uint64_t blob_file_number = 123;
-
-  WriteBlobFile(column_family_id, immutable_cf_options, blob_file_number);
-
-  constexpr size_t capacity = 0;
-  constexpr int num_shard_bits = -1;  // determined automatically
-  constexpr bool strict_capacity_limit = true;
-  std::shared_ptr<Cache> backing_cache =
-      NewLRUCache(capacity, num_shard_bits, strict_capacity_limit);
-
-  FileOptions file_options;
-  constexpr HistogramImpl* blob_file_read_hist = nullptr;
-
-  BlobFileCache blob_file_cache(backing_cache.get(), &immutable_cf_options,
-                                &file_options, column_family_id,
-                                blob_file_read_hist);
-
-  // Insert into cache should fail since it has zero capacity and
-  // strict_capacity_limit is set
-  CacheHandleGuard<BlobFileReader> reader;
-
-  ASSERT_TRUE(blob_file_cache.GetBlobFileReader(blob_file_number, &reader)
-                  .IsIncomplete());
-  ASSERT_EQ(reader.GetValue(), nullptr);
-  ASSERT_EQ(options.statistics->getTickerCount(NO_FILE_OPENS), 1);
-  ASSERT_EQ(options.statistics->getTickerCount(NO_FILE_ERRORS), 1);
-}
-
-}  // namespace ROCKSDB_NAMESPACE
-
-int main(int argc, char** argv) {
-  ::testing::InitGoogleTest(&argc, argv);
-  return RUN_ALL_TESTS();
-}

db/blob/blob_file_reader.cc

@@ -1,423 +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 "db/blob/blob_file_reader.h"
-
-#include <cassert>
-#include <string>
-
-#include "db/blob/blob_log_format.h"
-#include "file/filename.h"
-#include "options/cf_options.h"
-#include "rocksdb/file_system.h"
-#include "rocksdb/slice.h"
-#include "rocksdb/status.h"
-#include "test_util/sync_point.h"
-#include "util/compression.h"
-#include "util/crc32c.h"
-
-namespace ROCKSDB_NAMESPACE {
-
-Status BlobFileReader::Create(
-    const ImmutableCFOptions& immutable_cf_options,
-    const FileOptions& file_options, uint32_t column_family_id,
-    HistogramImpl* blob_file_read_hist, uint64_t blob_file_number,
-    std::unique_ptr<BlobFileReader>* blob_file_reader) {
-  assert(blob_file_reader);
-  assert(!*blob_file_reader);
-
-  uint64_t file_size = 0;
-  std::unique_ptr<RandomAccessFileReader> file_reader;
-
-  {
-    const Status s =
-        OpenFile(immutable_cf_options, file_options, blob_file_read_hist,
-                 blob_file_number, &file_size, &file_reader);
-    if (!s.ok()) {
-      return s;
-    }
-  }
-
-  assert(file_reader);
-
-  CompressionType compression_type = kNoCompression;
-
-  {
-    const Status s =
-        ReadHeader(file_reader.get(), column_family_id, &compression_type);
-    if (!s.ok()) {
-      return s;
-    }
-  }
-
-  {
-    const Status s = ReadFooter(file_size, file_reader.get());
-    if (!s.ok()) {
-      return s;
-    }
-  }
-
-  blob_file_reader->reset(
-      new BlobFileReader(std::move(file_reader), file_size, compression_type));
-
-  return Status::OK();
-}
-
-Status BlobFileReader::OpenFile(
-    const ImmutableCFOptions& immutable_cf_options,
-    const FileOptions& file_opts, HistogramImpl* blob_file_read_hist,
-    uint64_t blob_file_number, uint64_t* file_size,
-    std::unique_ptr<RandomAccessFileReader>* file_reader) {
-  assert(file_size);
-  assert(file_reader);
-
-  const auto& cf_paths = immutable_cf_options.cf_paths;
-  assert(!cf_paths.empty());
-
-  const std::string blob_file_path =
-      BlobFileName(cf_paths.front().path, blob_file_number);
-
-  FileSystem* const fs = immutable_cf_options.fs;
-  assert(fs);
-
-  constexpr IODebugContext* dbg = nullptr;
-
-  {
-    TEST_SYNC_POINT("BlobFileReader::OpenFile:GetFileSize");
-
-    const Status s =
-        fs->GetFileSize(blob_file_path, IOOptions(), file_size, dbg);
-    if (!s.ok()) {
-      return s;
-    }
-  }
-
-  if (*file_size < BlobLogHeader::kSize + BlobLogFooter::kSize) {
-    return Status::Corruption("Malformed blob file");
-  }
-
-  std::unique_ptr<FSRandomAccessFile> file;
-
-  {
-    TEST_SYNC_POINT("BlobFileReader::OpenFile:NewRandomAccessFile");
-
-    const Status s =
-        fs->NewRandomAccessFile(blob_file_path, file_opts, &file, dbg);
-    if (!s.ok()) {
-      return s;
-    }
-  }
-
-  assert(file);
-
-  if (immutable_cf_options.advise_random_on_open) {
-    file->Hint(FSRandomAccessFile::kRandom);
-  }
-
-  file_reader->reset(new RandomAccessFileReader(
-      std::move(file), blob_file_path, immutable_cf_options.env,
-      std::shared_ptr<IOTracer>(), immutable_cf_options.statistics,
-      BLOB_DB_BLOB_FILE_READ_MICROS, blob_file_read_hist,
-      immutable_cf_options.rate_limiter, immutable_cf_options.listeners));
-
-  return Status::OK();
-}
-
-Status BlobFileReader::ReadHeader(const RandomAccessFileReader* file_reader,
-                                  uint32_t column_family_id,
-                                  CompressionType* compression_type) {
-  assert(file_reader);
-  assert(compression_type);
-
-  Slice header_slice;
-  Buffer buf;
-  AlignedBuf aligned_buf;
-
-  {
-    TEST_SYNC_POINT("BlobFileReader::ReadHeader:ReadFromFile");
-
-    constexpr uint64_t read_offset = 0;
-    constexpr size_t read_size = BlobLogHeader::kSize;
-
-    const Status s = ReadFromFile(file_reader, read_offset, read_size,
-                                  &header_slice, &buf, &aligned_buf);
-    if (!s.ok()) {
-      return s;
-    }
-
-    TEST_SYNC_POINT_CALLBACK("BlobFileReader::ReadHeader:TamperWithResult",
-                             &header_slice);
-  }
-
-  BlobLogHeader header;
-
-  {
-    const Status s = header.DecodeFrom(header_slice);
-    if (!s.ok()) {
-      return s;
-    }
-  }
-
-  constexpr ExpirationRange no_expiration_range;
-
-  if (header.has_ttl || header.expiration_range != no_expiration_range) {
-    return Status::Corruption("Unexpected TTL blob file");
-  }
-
-  if (header.column_family_id != column_family_id) {
-    return Status::Corruption("Column family ID mismatch");
-  }
-
-  *compression_type = header.compression;
-
-  return Status::OK();
-}
-
-Status BlobFileReader::ReadFooter(uint64_t file_size,
-                                  const RandomAccessFileReader* file_reader) {
-  assert(file_size >= BlobLogHeader::kSize + BlobLogFooter::kSize);
-  assert(file_reader);
-
-  Slice footer_slice;
-  Buffer buf;
-  AlignedBuf aligned_buf;
-
-  {
-    TEST_SYNC_POINT("BlobFileReader::ReadFooter:ReadFromFile");
-
-    const uint64_t read_offset = file_size - BlobLogFooter::kSize;
-    constexpr size_t read_size = BlobLogFooter::kSize;
-
-    const Status s = ReadFromFile(file_reader, read_offset, read_size,
-                                  &footer_slice, &buf, &aligned_buf);
-    if (!s.ok()) {
-      return s;
-    }
-
-    TEST_SYNC_POINT_CALLBACK("BlobFileReader::ReadFooter:TamperWithResult",
-                             &footer_slice);
-  }
-
-  BlobLogFooter footer;
-
-  {
-    const Status s = footer.DecodeFrom(footer_slice);
-    if (!s.ok()) {
-      return s;
-    }
-  }
-
-  constexpr ExpirationRange no_expiration_range;
-
-  if (footer.expiration_range != no_expiration_range) {
-    return Status::Corruption("Unexpected TTL blob file");
-  }
-
-  return Status::OK();
-}
-
-Status BlobFileReader::ReadFromFile(const RandomAccessFileReader* file_reader,
-                                    uint64_t read_offset, size_t read_size,
-                                    Slice* slice, Buffer* buf,
-                                    AlignedBuf* aligned_buf) {
-  assert(slice);
-  assert(buf);
-  assert(aligned_buf);
-
-  assert(file_reader);
-
-  Status s;
-
-  if (file_reader->use_direct_io()) {
-    constexpr char* scratch = nullptr;
-
-    s = file_reader->Read(IOOptions(), read_offset, read_size, slice, scratch,
-                          aligned_buf);
-  } else {
-    buf->reset(new char[read_size]);
-    constexpr AlignedBuf* aligned_scratch = nullptr;
-
-    s = file_reader->Read(IOOptions(), read_offset, read_size, slice,
-                          buf->get(), aligned_scratch);
-  }
-
-  if (!s.ok()) {
-    return s;
-  }
-
-  if (slice->size() != read_size) {
-    return Status::Corruption("Failed to read data from blob file");
-  }
-
-  return Status::OK();
-}
-
-BlobFileReader::BlobFileReader(
-    std::unique_ptr<RandomAccessFileReader>&& file_reader, uint64_t file_size,
-    CompressionType compression_type)
-    : file_reader_(std::move(file_reader)),
-      file_size_(file_size),
-      compression_type_(compression_type) {
-  assert(file_reader_);
-}
-
-BlobFileReader::~BlobFileReader() = default;
-
-Status BlobFileReader::GetBlob(const ReadOptions& read_options,
-                               const Slice& user_key, uint64_t offset,
-                               uint64_t value_size,
-                               CompressionType compression_type,
-                               PinnableSlice* value) const {
-  assert(value);
-
-  const uint64_t key_size = user_key.size();
-
-  if (!IsValidBlobOffset(offset, key_size, value_size, file_size_)) {
-    return Status::Corruption("Invalid blob offset");
-  }
-
-  if (compression_type != compression_type_) {
-    return Status::Corruption("Compression type mismatch when reading blob");
-  }
-
-  // Note: if verify_checksum is set, we read the entire blob record to be able
-  // to perform the verification; otherwise, we just read the blob itself. Since
-  // the offset in BlobIndex actually points to the blob value, we need to make
-  // an adjustment in the former case.
-  const uint64_t adjustment =
-      read_options.verify_checksums
-          ? BlobLogRecord::CalculateAdjustmentForRecordHeader(key_size)
-          : 0;
-  assert(offset >= adjustment);
-
-  Slice record_slice;
-  Buffer buf;
-  AlignedBuf aligned_buf;
-
-  {
-    TEST_SYNC_POINT("BlobFileReader::GetBlob:ReadFromFile");
-
-    const uint64_t record_offset = offset - adjustment;
-    const uint64_t record_size = value_size + adjustment;
-
-    const Status s = ReadFromFile(file_reader_.get(), record_offset,
-                                  static_cast<size_t>(record_size),
-                                  &record_slice, &buf, &aligned_buf);
-    if (!s.ok()) {
-      return s;
-    }
-
-    TEST_SYNC_POINT_CALLBACK("BlobFileReader::GetBlob:TamperWithResult",
-                             &record_slice);
-  }
-
-  if (read_options.verify_checksums) {
-    const Status s = VerifyBlob(record_slice, user_key, value_size);
-    if (!s.ok()) {
-      return s;
-    }
-  }
-
-  const Slice value_slice(record_slice.data() + adjustment, value_size);
-
-  {
-    const Status s =
-        UncompressBlobIfNeeded(value_slice, compression_type, value);
-    if (!s.ok()) {
-      return s;
-    }
-  }
-
-  return Status::OK();
-}
-
-Status BlobFileReader::VerifyBlob(const Slice& record_slice,
-                                  const Slice& user_key, uint64_t value_size) {
-  BlobLogRecord record;
-
-  const Slice header_slice(record_slice.data(), BlobLogRecord::kHeaderSize);
-
-  {
-    const Status s = record.DecodeHeaderFrom(header_slice);
-    if (!s.ok()) {
-      return s;
-    }
-  }
-
-  if (record.key_size != user_key.size()) {
-    return Status::Corruption("Key size mismatch when reading blob");
-  }
-
-  if (record.value_size != value_size) {
-    return Status::Corruption("Value size mismatch when reading blob");
-  }
-
-  record.key =
-      Slice(record_slice.data() + BlobLogRecord::kHeaderSize, record.key_size);
-  if (record.key != user_key) {
-    return Status::Corruption("Key mismatch when reading blob");
-  }
-
-  record.value = Slice(record.key.data() + record.key_size, value_size);
-
-  {
-    TEST_SYNC_POINT_CALLBACK("BlobFileReader::VerifyBlob:CheckBlobCRC",
-                             &record);
-
-    const Status s = record.CheckBlobCRC();
-    if (!s.ok()) {
-      return s;
-    }
-  }
-
-  return Status::OK();
-}
-
-Status BlobFileReader::UncompressBlobIfNeeded(const Slice& value_slice,
-                                              CompressionType compression_type,
-                                              PinnableSlice* value) {
-  assert(value);
-
-  if (compression_type == kNoCompression) {
-    SaveValue(value_slice, value);
-
-    return Status::OK();
-  }
-
-  UncompressionContext context(compression_type);
-  UncompressionInfo info(context, UncompressionDict::GetEmptyDict(),
-                         compression_type);
-
-  size_t uncompressed_size = 0;
-  constexpr uint32_t compression_format_version = 2;
-  constexpr MemoryAllocator* allocator = nullptr;
-
-  CacheAllocationPtr output =
-      UncompressData(info, value_slice.data(), value_slice.size(),
-                     &uncompressed_size, compression_format_version, allocator);
-
-  TEST_SYNC_POINT_CALLBACK(
-      "BlobFileReader::UncompressBlobIfNeeded:TamperWithResult", &output);
-
-  if (!output) {
-    return Status::Corruption("Unable to uncompress blob");
-  }
-
-  SaveValue(Slice(output.get(), uncompressed_size), value);
-
-  return Status::OK();
-}
-
-void BlobFileReader::SaveValue(const Slice& src, PinnableSlice* dst) {
-  assert(dst);
-
-  if (dst->IsPinned()) {
-    dst->Reset();
-  }
-
-  dst->PinSelf(src);
-}
-
-}  // namespace ROCKSDB_NAMESPACE

db/blob/blob_file_reader.h

@@ -1,81 +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).
-
-#pragma once
-
-#include <cinttypes>
-#include <memory>
-
-#include "file/random_access_file_reader.h"
-#include "rocksdb/compression_type.h"
-#include "rocksdb/rocksdb_namespace.h"
-
-namespace ROCKSDB_NAMESPACE {
-
-class Status;
-struct ImmutableCFOptions;
-struct FileOptions;
-class HistogramImpl;
-struct ReadOptions;
-class Slice;
-class PinnableSlice;
-
-class BlobFileReader {
- public:
-  static Status Create(const ImmutableCFOptions& immutable_cf_options,
-                       const FileOptions& file_options,
-                       uint32_t column_family_id,
-                       HistogramImpl* blob_file_read_hist,
-                       uint64_t blob_file_number,
-                       std::unique_ptr<BlobFileReader>* reader);
-
-  BlobFileReader(const BlobFileReader&) = delete;
-  BlobFileReader& operator=(const BlobFileReader&) = delete;
-
-  ~BlobFileReader();
-
-  Status GetBlob(const ReadOptions& read_options, const Slice& user_key,
-                 uint64_t offset, uint64_t value_size,
-                 CompressionType compression_type, PinnableSlice* value) const;
-
- private:
-  BlobFileReader(std::unique_ptr<RandomAccessFileReader>&& file_reader,
-                 uint64_t file_size, CompressionType compression_type);
-
-  static Status OpenFile(const ImmutableCFOptions& immutable_cf_options,
-                         const FileOptions& file_opts,
-                         HistogramImpl* blob_file_read_hist,
-                         uint64_t blob_file_number, uint64_t* file_size,
-                         std::unique_ptr<RandomAccessFileReader>* file_reader);
-
-  static Status ReadHeader(const RandomAccessFileReader* file_reader,
-                           uint32_t column_family_id,
-                           CompressionType* compression_type);
-
-  static Status ReadFooter(uint64_t file_size,
-                           const RandomAccessFileReader* file_reader);
-
-  using Buffer = std::unique_ptr<char[]>;
-
-  static Status ReadFromFile(const RandomAccessFileReader* file_reader,
-                             uint64_t read_offset, size_t read_size,
-                             Slice* slice, Buffer* buf,
-                             AlignedBuf* aligned_buf);
-
-  static Status VerifyBlob(const Slice& record_slice, const Slice& user_key,
-                           uint64_t value_size);
-
-  static Status UncompressBlobIfNeeded(const Slice& value_slice,
-                                       CompressionType compression_type,
-                                       PinnableSlice* value);
-
-  static void SaveValue(const Slice& src, PinnableSlice* dst);
-
-  std::unique_ptr<RandomAccessFileReader> file_reader_;
-  uint64_t file_size_;
-  CompressionType compression_type_;
-};
-
-}  // namespace ROCKSDB_NAMESPACE

db/blob/blob_file_reader_test.cc

@@ -1,771 +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 "db/blob/blob_file_reader.h"
-
-#include <cassert>
-#include <string>
-
-#include "db/blob/blob_log_format.h"
-#include "db/blob/blob_log_writer.h"
-#include "env/mock_env.h"
-#include "file/filename.h"
-#include "file/read_write_util.h"
-#include "file/writable_file_writer.h"
-#include "options/cf_options.h"
-#include "rocksdb/env.h"
-#include "rocksdb/file_system.h"
-#include "rocksdb/options.h"
-#include "test_util/sync_point.h"
-#include "test_util/testharness.h"
-#include "util/compression.h"
-#include "utilities/fault_injection_env.h"
-
-namespace ROCKSDB_NAMESPACE {
-
-namespace {
-
-// Creates a test blob file with a single blob in it. Note: this method
-// makes it possible to test various corner cases by allowing the caller
-// to specify the contents of various blob file header/footer fields.
-void WriteBlobFile(const ImmutableCFOptions& immutable_cf_options,
-                   uint32_t column_family_id, bool has_ttl,
-                   const ExpirationRange& expiration_range_header,
-                   const ExpirationRange& expiration_range_footer,
-                   uint64_t blob_file_number, const Slice& key,
-                   const Slice& blob, CompressionType compression_type,
-                   uint64_t* blob_offset, uint64_t* blob_size) {
-  assert(!immutable_cf_options.cf_paths.empty());
-  assert(blob_offset);
-  assert(blob_size);
-
-  const std::string blob_file_path = BlobFileName(
-      immutable_cf_options.cf_paths.front().path, blob_file_number);
-
-  std::unique_ptr<FSWritableFile> file;
-  ASSERT_OK(NewWritableFile(immutable_cf_options.fs, blob_file_path, &file,
-                            FileOptions()));
-
-  std::unique_ptr<WritableFileWriter> file_writer(
-      new WritableFileWriter(std::move(file), blob_file_path, FileOptions(),
-                             immutable_cf_options.env));
-
-  constexpr Statistics* statistics = nullptr;
-  constexpr bool use_fsync = false;
-
-  BlobLogWriter blob_log_writer(std::move(file_writer),
-                                immutable_cf_options.env, statistics,
-                                blob_file_number, use_fsync);
-
-  BlobLogHeader header(column_family_id, compression_type, has_ttl,
-                       expiration_range_header);
-
-  ASSERT_OK(blob_log_writer.WriteHeader(header));
-
-  std::string compressed_blob;
-  Slice blob_to_write;
-
-  if (compression_type == kNoCompression) {
-    blob_to_write = blob;
-    *blob_size = blob.size();
-  } else {
-    CompressionOptions opts;
-    CompressionContext context(compression_type);
-    constexpr uint64_t sample_for_compression = 0;
-
-    CompressionInfo info(opts, context, CompressionDict::GetEmptyDict(),
-                         compression_type, sample_for_compression);
-
-    constexpr uint32_t compression_format_version = 2;
-
-    ASSERT_TRUE(
-        CompressData(blob, info, compression_format_version, &compressed_blob));
-
-    blob_to_write = compressed_blob;
-    *blob_size = compressed_blob.size();
-  }
-
-  uint64_t key_offset = 0;
-
-  ASSERT_OK(
-      blob_log_writer.AddRecord(key, blob_to_write, &key_offset, blob_offset));
-
-  BlobLogFooter footer;
-  footer.blob_count = 1;
-  footer.expiration_range = expiration_range_footer;
-
-  std::string checksum_method;
-  std::string checksum_value;
-
-  ASSERT_OK(
-      blob_log_writer.AppendFooter(footer, &checksum_method, &checksum_value));
-}
-
-}  // anonymous namespace
-
-class BlobFileReaderTest : public testing::Test {
- protected:
-  BlobFileReaderTest() : mock_env_(Env::Default()) {}
-
-  MockEnv mock_env_;
-};
-
-TEST_F(BlobFileReaderTest, CreateReaderAndGetBlob) {
-  Options options;
-  options.env = &mock_env_;
-  options.cf_paths.emplace_back(
-      test::PerThreadDBPath(&mock_env_,
-                            "BlobFileReaderTest_CreateReaderAndGetBlob"),
-      0);
-  options.enable_blob_files = true;
-
-  ImmutableCFOptions immutable_cf_options(options);
-
-  constexpr uint32_t column_family_id = 1;
-  constexpr bool has_ttl = false;
-  constexpr ExpirationRange expiration_range;
-  constexpr uint64_t blob_file_number = 1;
-  constexpr char key[] = "key";
-  constexpr char blob[] = "blob";
-
-  uint64_t blob_offset = 0;
-  uint64_t blob_size = 0;
-
-  WriteBlobFile(immutable_cf_options, column_family_id, has_ttl,
-                expiration_range, expiration_range, blob_file_number, key, blob,
-                kNoCompression, &blob_offset, &blob_size);
-
-  constexpr HistogramImpl* blob_file_read_hist = nullptr;
-
-  std::unique_ptr<BlobFileReader> reader;
-
-  ASSERT_OK(BlobFileReader::Create(immutable_cf_options, FileOptions(),
-                                   column_family_id, blob_file_read_hist,
-                                   blob_file_number, &reader));
-
-  // Make sure the blob can be retrieved with and without checksum verification
-  ReadOptions read_options;
-  read_options.verify_checksums = false;
-
-  {
-    PinnableSlice value;
-
-    ASSERT_OK(reader->GetBlob(read_options, key, blob_offset, blob_size,
-                              kNoCompression, &value));
-    ASSERT_EQ(value, blob);
-  }
-
-  read_options.verify_checksums = true;
-
-  {
-    PinnableSlice value;
-
-    ASSERT_OK(reader->GetBlob(read_options, key, blob_offset, blob_size,
-                              kNoCompression, &value));
-    ASSERT_EQ(value, blob);
-  }
-
-  // Invalid offset (too close to start of file)
-  {
-    PinnableSlice value;
-
-    ASSERT_TRUE(reader
-                    ->GetBlob(read_options, key, blob_offset - 1, blob_size,
-                              kNoCompression, &value)
-                    .IsCorruption());
-  }
-
-  // Invalid offset (too close to end of file)
-  {
-    PinnableSlice value;
-
-    ASSERT_TRUE(reader
-                    ->GetBlob(read_options, key, blob_offset + 1, blob_size,
-                              kNoCompression, &value)
-                    .IsCorruption());
-  }
-
-  // Incorrect compression type
-  {
-    PinnableSlice value;
-
-    ASSERT_TRUE(
-        reader
-            ->GetBlob(read_options, key, blob_offset, blob_size, kZSTD, &value)
-            .IsCorruption());
-  }
-
-  // Incorrect key size
-  {
-    constexpr char shorter_key[] = "k";
-    PinnableSlice value;
-
-    ASSERT_TRUE(reader
-                    ->GetBlob(read_options, shorter_key,
-                              blob_offset - (sizeof(key) - sizeof(shorter_key)),
-                              blob_size, kNoCompression, &value)
-                    .IsCorruption());
-  }
-
-  // Incorrect key
-  {
-    constexpr char incorrect_key[] = "foo";
-    PinnableSlice value;
-
-    ASSERT_TRUE(reader
-                    ->GetBlob(read_options, incorrect_key, blob_offset,
-                              blob_size, kNoCompression, &value)
-                    .IsCorruption());
-  }
-
-  // Incorrect value size
-  {
-    PinnableSlice value;
-
-    ASSERT_TRUE(reader
-                    ->GetBlob(read_options, key, blob_offset, blob_size + 1,
-                              kNoCompression, &value)
-                    .IsCorruption());
-  }
-}
-
-TEST_F(BlobFileReaderTest, Malformed) {
-  // Write a blob file consisting of nothing but a header, and make sure we
-  // detect the error when we open it for reading
-
-  Options options;
-  options.env = &mock_env_;
-  options.cf_paths.emplace_back(
-      test::PerThreadDBPath(&mock_env_, "BlobFileReaderTest_Malformed"), 0);
-  options.enable_blob_files = true;
-
-  ImmutableCFOptions immutable_cf_options(options);
-
-  constexpr uint32_t column_family_id = 1;
-  constexpr uint64_t blob_file_number = 1;
-
-  {
-    constexpr bool has_ttl = false;
-    constexpr ExpirationRange expiration_range;
-
-    const std::string blob_file_path = BlobFileName(
-        immutable_cf_options.cf_paths.front().path, blob_file_number);
-
-    std::unique_ptr<FSWritableFile> file;
-    ASSERT_OK(NewWritableFile(immutable_cf_options.fs, blob_file_path, &file,
-                              FileOptions()));
-
-    std::unique_ptr<WritableFileWriter> file_writer(
-        new WritableFileWriter(std::move(file), blob_file_path, FileOptions(),
-                               immutable_cf_options.env));
-
-    constexpr Statistics* statistics = nullptr;
-    constexpr bool use_fsync = false;
-
-    BlobLogWriter blob_log_writer(std::move(file_writer),
-                                  immutable_cf_options.env, statistics,
-                                  blob_file_number, use_fsync);
-
-    BlobLogHeader header(column_family_id, kNoCompression, has_ttl,
-                         expiration_range);
-
-    ASSERT_OK(blob_log_writer.WriteHeader(header));
-  }
-
-  constexpr HistogramImpl* blob_file_read_hist = nullptr;
-
-  std::unique_ptr<BlobFileReader> reader;
-
-  ASSERT_TRUE(BlobFileReader::Create(immutable_cf_options, FileOptions(),
-                                     column_family_id, blob_file_read_hist,
-                                     blob_file_number, &reader)
-                  .IsCorruption());
-}
-
-TEST_F(BlobFileReaderTest, TTL) {
-  Options options;
-  options.env = &mock_env_;
-  options.cf_paths.emplace_back(
-      test::PerThreadDBPath(&mock_env_, "BlobFileReaderTest_TTL"), 0);
-  options.enable_blob_files = true;
-
-  ImmutableCFOptions immutable_cf_options(options);
-
-  constexpr uint32_t column_family_id = 1;
-  constexpr bool has_ttl = true;
-  constexpr ExpirationRange expiration_range;
-  constexpr uint64_t blob_file_number = 1;
-  constexpr char key[] = "key";
-  constexpr char blob[] = "blob";
-
-  uint64_t blob_offset = 0;
-  uint64_t blob_size = 0;
-
-  WriteBlobFile(immutable_cf_options, column_family_id, has_ttl,
-                expiration_range, expiration_range, blob_file_number, key, blob,
-                kNoCompression, &blob_offset, &blob_size);
-
-  constexpr HistogramImpl* blob_file_read_hist = nullptr;
-
-  std::unique_ptr<BlobFileReader> reader;
-
-  ASSERT_TRUE(BlobFileReader::Create(immutable_cf_options, FileOptions(),
-                                     column_family_id, blob_file_read_hist,
-                                     blob_file_number, &reader)
-                  .IsCorruption());
-}
-
-TEST_F(BlobFileReaderTest, ExpirationRangeInHeader) {
-  Options options;
-  options.env = &mock_env_;
-  options.cf_paths.emplace_back(
-      test::PerThreadDBPath(&mock_env_,
-                            "BlobFileReaderTest_ExpirationRangeInHeader"),
-      0);
-  options.enable_blob_files = true;
-
-  ImmutableCFOptions immutable_cf_options(options);
-
-  constexpr uint32_t column_family_id = 1;
-  constexpr bool has_ttl = false;
-  const ExpirationRange expiration_range_header(
-      1, 2);  // can be made constexpr when we adopt C++14
-  constexpr ExpirationRange expiration_range_footer;
-  constexpr uint64_t blob_file_number = 1;
-  constexpr char key[] = "key";
-  constexpr char blob[] = "blob";
-
-  uint64_t blob_offset = 0;
-  uint64_t blob_size = 0;
-
-  WriteBlobFile(immutable_cf_options, column_family_id, has_ttl,
-                expiration_range_header, expiration_range_footer,
-                blob_file_number, key, blob, kNoCompression, &blob_offset,
-                &blob_size);
-
-  constexpr HistogramImpl* blob_file_read_hist = nullptr;
-
-  std::unique_ptr<BlobFileReader> reader;
-
-  ASSERT_TRUE(BlobFileReader::Create(immutable_cf_options, FileOptions(),
-                                     column_family_id, blob_file_read_hist,
-                                     blob_file_number, &reader)
-                  .IsCorruption());
-}
-
-TEST_F(BlobFileReaderTest, ExpirationRangeInFooter) {
-  Options options;
-  options.env = &mock_env_;
-  options.cf_paths.emplace_back(
-      test::PerThreadDBPath(&mock_env_,
-                            "BlobFileReaderTest_ExpirationRangeInFooter"),
-      0);
-  options.enable_blob_files = true;
-
-  ImmutableCFOptions immutable_cf_options(options);
-
-  constexpr uint32_t column_family_id = 1;
-  constexpr bool has_ttl = false;
-  constexpr ExpirationRange expiration_range_header;
-  const ExpirationRange expiration_range_footer(
-      1, 2);  // can be made constexpr when we adopt C++14
-  constexpr uint64_t blob_file_number = 1;
-  constexpr char key[] = "key";
-  constexpr char blob[] = "blob";
-
-  uint64_t blob_offset = 0;
-  uint64_t blob_size = 0;
-
-  WriteBlobFile(immutable_cf_options, column_family_id, has_ttl,
-                expiration_range_header, expiration_range_footer,
-                blob_file_number, key, blob, kNoCompression, &blob_offset,
-                &blob_size);
-
-  constexpr HistogramImpl* blob_file_read_hist = nullptr;
-
-  std::unique_ptr<BlobFileReader> reader;
-
-  ASSERT_TRUE(BlobFileReader::Create(immutable_cf_options, FileOptions(),
-                                     column_family_id, blob_file_read_hist,
-                                     blob_file_number, &reader)
-                  .IsCorruption());
-}
-
-TEST_F(BlobFileReaderTest, IncorrectColumnFamily) {
-  Options options;
-  options.env = &mock_env_;
-  options.cf_paths.emplace_back(
-      test::PerThreadDBPath(&mock_env_,
-                            "BlobFileReaderTest_IncorrectColumnFamily"),
-      0);
-  options.enable_blob_files = true;
-
-  ImmutableCFOptions immutable_cf_options(options);
-
-  constexpr uint32_t column_family_id = 1;
-  constexpr bool has_ttl = false;
-  constexpr ExpirationRange expiration_range;
-  constexpr uint64_t blob_file_number = 1;
-  constexpr char key[] = "key";
-  constexpr char blob[] = "blob";
-
-  uint64_t blob_offset = 0;
-  uint64_t blob_size = 0;
-
-  WriteBlobFile(immutable_cf_options, column_family_id, has_ttl,
-                expiration_range, expiration_range, blob_file_number, key, blob,
-                kNoCompression, &blob_offset, &blob_size);
-
-  constexpr HistogramImpl* blob_file_read_hist = nullptr;
-
-  std::unique_ptr<BlobFileReader> reader;
-
-  constexpr uint32_t incorrect_column_family_id = 2;
-
-  ASSERT_TRUE(BlobFileReader::Create(immutable_cf_options, FileOptions(),
-                                     incorrect_column_family_id,
-                                     blob_file_read_hist, blob_file_number,
-                                     &reader)
-                  .IsCorruption());
-}
-
-TEST_F(BlobFileReaderTest, BlobCRCError) {
-  Options options;
-  options.env = &mock_env_;
-  options.cf_paths.emplace_back(
-      test::PerThreadDBPath(&mock_env_, "BlobFileReaderTest_BlobCRCError"), 0);
-  options.enable_blob_files = true;
-
-  ImmutableCFOptions immutable_cf_options(options);
-
-  constexpr uint32_t column_family_id = 1;
-  constexpr bool has_ttl = false;
-  constexpr ExpirationRange expiration_range;
-  constexpr uint64_t blob_file_number = 1;
-  constexpr char key[] = "key";
-  constexpr char blob[] = "blob";
-
-  uint64_t blob_offset = 0;
-  uint64_t blob_size = 0;
-
-  WriteBlobFile(immutable_cf_options, column_family_id, has_ttl,
-                expiration_range, expiration_range, blob_file_number, key, blob,
-                kNoCompression, &blob_offset, &blob_size);
-
-  constexpr HistogramImpl* blob_file_read_hist = nullptr;
-
-  std::unique_ptr<BlobFileReader> reader;
-
-  ASSERT_OK(BlobFileReader::Create(immutable_cf_options, FileOptions(),
-                                   column_family_id, blob_file_read_hist,
-                                   blob_file_number, &reader));
-
-  SyncPoint::GetInstance()->SetCallBack(
-      "BlobFileReader::VerifyBlob:CheckBlobCRC", [](void* arg) {
-        BlobLogRecord* const record = static_cast<BlobLogRecord*>(arg);
-        assert(record);
-
-        record->blob_crc = 0xfaceb00c;
-      });
-
-  SyncPoint::GetInstance()->EnableProcessing();
-
-  PinnableSlice value;
-
-  ASSERT_TRUE(reader
-                  ->GetBlob(ReadOptions(), key, blob_offset, blob_size,
-                            kNoCompression, &value)
-                  .IsCorruption());
-
-  SyncPoint::GetInstance()->DisableProcessing();
-  SyncPoint::GetInstance()->ClearAllCallBacks();
-}
-
-TEST_F(BlobFileReaderTest, Compression) {
-  if (!Snappy_Supported()) {
-    return;
-  }
-
-  Options options;
-  options.env = &mock_env_;
-  options.cf_paths.emplace_back(
-      test::PerThreadDBPath(&mock_env_, "BlobFileReaderTest_Compression"), 0);
-  options.enable_blob_files = true;
-
-  ImmutableCFOptions immutable_cf_options(options);
-
-  constexpr uint32_t column_family_id = 1;
-  constexpr bool has_ttl = false;
-  constexpr ExpirationRange expiration_range;
-  constexpr uint64_t blob_file_number = 1;
-  constexpr char key[] = "key";
-  constexpr char blob[] = "blob";
-
-  uint64_t blob_offset = 0;
-  uint64_t blob_size = 0;
-
-  WriteBlobFile(immutable_cf_options, column_family_id, has_ttl,
-                expiration_range, expiration_range, blob_file_number, key, blob,
-                kSnappyCompression, &blob_offset, &blob_size);
-
-  constexpr HistogramImpl* blob_file_read_hist = nullptr;
-
-  std::unique_ptr<BlobFileReader> reader;
-
-  ASSERT_OK(BlobFileReader::Create(immutable_cf_options, FileOptions(),
-                                   column_family_id, blob_file_read_hist,
-                                   blob_file_number, &reader));
-
-  // Make sure the blob can be retrieved with and without checksum verification
-  ReadOptions read_options;
-  read_options.verify_checksums = false;
-
-  {
-    PinnableSlice value;
-
-    ASSERT_OK(reader->GetBlob(read_options, key, blob_offset, blob_size,
-                              kSnappyCompression, &value));
-    ASSERT_EQ(value, blob);
-  }
-
-  read_options.verify_checksums = true;
-
-  {
-    PinnableSlice value;
-
-    ASSERT_OK(reader->GetBlob(read_options, key, blob_offset, blob_size,
-                              kSnappyCompression, &value));
-    ASSERT_EQ(value, blob);
-  }
-}
-
-TEST_F(BlobFileReaderTest, UncompressionError) {
-  if (!Snappy_Supported()) {
-    return;
-  }
-
-  Options options;
-  options.env = &mock_env_;
-  options.cf_paths.emplace_back(
-      test::PerThreadDBPath(&mock_env_,
-                            "BlobFileReaderTest_UncompressionError"),
-      0);
-  options.enable_blob_files = true;
-
-  ImmutableCFOptions immutable_cf_options(options);
-
-  constexpr uint32_t column_family_id = 1;
-  constexpr bool has_ttl = false;
-  constexpr ExpirationRange expiration_range;
-  constexpr uint64_t blob_file_number = 1;
-  constexpr char key[] = "key";
-  constexpr char blob[] = "blob";
-
-  uint64_t blob_offset = 0;
-  uint64_t blob_size = 0;
-
-  WriteBlobFile(immutable_cf_options, column_family_id, has_ttl,
-                expiration_range, expiration_range, blob_file_number, key, blob,
-                kSnappyCompression, &blob_offset, &blob_size);
-
-  constexpr HistogramImpl* blob_file_read_hist = nullptr;
-
-  std::unique_ptr<BlobFileReader> reader;
-
-  ASSERT_OK(BlobFileReader::Create(immutable_cf_options, FileOptions(),
-                                   column_family_id, blob_file_read_hist,
-                                   blob_file_number, &reader));
-
-  SyncPoint::GetInstance()->SetCallBack(
-      "BlobFileReader::UncompressBlobIfNeeded:TamperWithResult", [](void* arg) {
-        CacheAllocationPtr* const output =
-            static_cast<CacheAllocationPtr*>(arg);
-        assert(output);
-
-        output->reset();
-      });
-
-  SyncPoint::GetInstance()->EnableProcessing();
-
-  PinnableSlice value;
-
-  ASSERT_TRUE(reader
-                  ->GetBlob(ReadOptions(), key, blob_offset, blob_size,
-                            kSnappyCompression, &value)
-                  .IsCorruption());
-
-  SyncPoint::GetInstance()->DisableProcessing();
-  SyncPoint::GetInstance()->ClearAllCallBacks();
-}
-
-class BlobFileReaderIOErrorTest
-    : public testing::Test,
-      public testing::WithParamInterface<std::string> {
- protected:
-  BlobFileReaderIOErrorTest()
-      : mock_env_(Env::Default()),
-        fault_injection_env_(&mock_env_),
-        sync_point_(GetParam()) {}
-
-  MockEnv mock_env_;
-  FaultInjectionTestEnv fault_injection_env_;
-  std::string sync_point_;
-};
-
-INSTANTIATE_TEST_CASE_P(BlobFileReaderTest, BlobFileReaderIOErrorTest,
-                        ::testing::ValuesIn(std::vector<std::string>{
-                            "BlobFileReader::OpenFile:GetFileSize",
-                            "BlobFileReader::OpenFile:NewRandomAccessFile",
-                            "BlobFileReader::ReadHeader:ReadFromFile",
-                            "BlobFileReader::ReadFooter:ReadFromFile",
-                            "BlobFileReader::GetBlob:ReadFromFile"}));
-
-TEST_P(BlobFileReaderIOErrorTest, IOError) {
-  // Simulates an I/O error during the specified step
-
-  Options options;
-  options.env = &fault_injection_env_;
-  options.cf_paths.emplace_back(
-      test::PerThreadDBPath(&fault_injection_env_,
-                            "BlobFileReaderIOErrorTest_IOError"),
-      0);
-  options.enable_blob_files = true;
-
-  ImmutableCFOptions immutable_cf_options(options);
-
-  constexpr uint32_t column_family_id = 1;
-  constexpr bool has_ttl = false;
-  constexpr ExpirationRange expiration_range;
-  constexpr uint64_t blob_file_number = 1;
-  constexpr char key[] = "key";
-  constexpr char blob[] = "blob";
-
-  uint64_t blob_offset = 0;
-  uint64_t blob_size = 0;
-
-  WriteBlobFile(immutable_cf_options, column_family_id, has_ttl,
-                expiration_range, expiration_range, blob_file_number, key, blob,
-                kNoCompression, &blob_offset, &blob_size);
-
-  SyncPoint::GetInstance()->SetCallBack(sync_point_, [this](void* /* arg */) {
-    fault_injection_env_.SetFilesystemActive(false,
-                                             Status::IOError(sync_point_));
-  });
-  SyncPoint::GetInstance()->EnableProcessing();
-
-  constexpr HistogramImpl* blob_file_read_hist = nullptr;
-
-  std::unique_ptr<BlobFileReader> reader;
-
-  const Status s = BlobFileReader::Create(immutable_cf_options, FileOptions(),
-                                          column_family_id, blob_file_read_hist,
-                                          blob_file_number, &reader);
-
-  const bool fail_during_create =
-      (sync_point_ != "BlobFileReader::GetBlob:ReadFromFile");
-
-  if (fail_during_create) {
-    ASSERT_TRUE(s.IsIOError());
-  } else {
-    ASSERT_OK(s);
-
-    PinnableSlice value;
-
-    ASSERT_TRUE(reader
-                    ->GetBlob(ReadOptions(), key, blob_offset, blob_size,
-                              kNoCompression, &value)
-                    .IsIOError());
-  }
-
-  SyncPoint::GetInstance()->DisableProcessing();
-  SyncPoint::GetInstance()->ClearAllCallBacks();
-}
-
-class BlobFileReaderDecodingErrorTest
-    : public testing::Test,
-      public testing::WithParamInterface<std::string> {
- protected:
-  BlobFileReaderDecodingErrorTest()
-      : mock_env_(Env::Default()), sync_point_(GetParam()) {}
-
-  MockEnv mock_env_;
-  std::string sync_point_;
-};
-
-INSTANTIATE_TEST_CASE_P(BlobFileReaderTest, BlobFileReaderDecodingErrorTest,
-                        ::testing::ValuesIn(std::vector<std::string>{
-                            "BlobFileReader::ReadHeader:TamperWithResult",
-                            "BlobFileReader::ReadFooter:TamperWithResult",
-                            "BlobFileReader::GetBlob:TamperWithResult"}));
-
-TEST_P(BlobFileReaderDecodingErrorTest, DecodingError) {
-  Options options;
-  options.env = &mock_env_;
-  options.cf_paths.emplace_back(
-      test::PerThreadDBPath(&mock_env_,
-                            "BlobFileReaderDecodingErrorTest_DecodingError"),
-      0);
-  options.enable_blob_files = true;
-
-  ImmutableCFOptions immutable_cf_options(options);
-
-  constexpr uint32_t column_family_id = 1;
-  constexpr bool has_ttl = false;
-  constexpr ExpirationRange expiration_range;
-  constexpr uint64_t blob_file_number = 1;
-  constexpr char key[] = "key";
-  constexpr char blob[] = "blob";
-
-  uint64_t blob_offset = 0;
-  uint64_t blob_size = 0;
-
-  WriteBlobFile(immutable_cf_options, column_family_id, has_ttl,
-                expiration_range, expiration_range, blob_file_number, key, blob,
-                kNoCompression, &blob_offset, &blob_size);
-
-  SyncPoint::GetInstance()->SetCallBack(sync_point_, [](void* arg) {
-    Slice* const slice = static_cast<Slice*>(arg);
-    assert(slice);
-    assert(!slice->empty());
-
-    slice->remove_prefix(1);
-  });
-
-  SyncPoint::GetInstance()->EnableProcessing();
-
-  constexpr HistogramImpl* blob_file_read_hist = nullptr;
-
-  std::unique_ptr<BlobFileReader> reader;
-
-  const Status s = BlobFileReader::Create(immutable_cf_options, FileOptions(),
-                                          column_family_id, blob_file_read_hist,
-                                          blob_file_number, &reader);
-
-  const bool fail_during_create =
-      sync_point_ != "BlobFileReader::GetBlob:TamperWithResult";
-
-  if (fail_during_create) {
-    ASSERT_TRUE(s.IsCorruption());
-  } else {
-    ASSERT_OK(s);
-
-    PinnableSlice value;
-
-    ASSERT_TRUE(reader
-                    ->GetBlob(ReadOptions(), key, blob_offset, blob_size,
-                              kNoCompression, &value)
-                    .IsCorruption());
-  }
-
-  SyncPoint::GetInstance()->DisableProcessing();
-  SyncPoint::GetInstance()->ClearAllCallBacks();
-}
-
-}  // namespace ROCKSDB_NAMESPACE
-
-int main(int argc, char** argv) {
-  ::testing::InitGoogleTest(&argc, argv);
-  return RUN_ALL_TESTS();
-}

db/blob/blob_index.h

@@ -7,9 +7,8 @@
 #include <sstream>
 #include <string>
 
-#include "rocksdb/compression_type.h"
+#include "rocksdb/options.h"
 #include "util/coding.h"
-#include "util/compression.h"
 #include "util/string_util.h"
 
 namespace ROCKSDB_NAMESPACE {
@@ -83,11 +82,6 @@ class BlobIndex {
     return size_;
   }
 
-  CompressionType compression() const {
-    assert(!IsInlined());
-    return compression_;
-  }
-
   Status DecodeFrom(Slice slice) {
     static const std::string kErrorMessage = "Error while decoding blob index";
     assert(slice.size() > 0);
@@ -123,8 +117,7 @@ class BlobIndex {
       oss << "[inlined blob] value:" << value_.ToString(output_hex);
     } else {
       oss << "[blob ref] file:" << file_number_ << " offset:" << offset_
-          << " size:" << size_
-          << " compression: " << CompressionTypeToString(compression_);
+          << " size:" << size_;
     }
 
     if (HasTTL()) {

db/blob/blob_log_format.h

@@ -104,13 +104,6 @@ struct BlobLogRecord {
   // header include fields up to blob CRC
   static constexpr size_t kHeaderSize = 32;
 
-  // Note that the offset field of BlobIndex actually points to the blob value
-  // as opposed to the start of the blob record. The following method can
-  // be used to calculate the adjustment needed to read the blob record header.
-  static uint64_t CalculateAdjustmentForRecordHeader(uint64_t key_size) {
-    return key_size + kHeaderSize;
-  }
-
   uint64_t key_size = 0;
   uint64_t value_size = 0;
   uint64_t expiration = 0;
@@ -130,19 +123,4 @@ struct BlobLogRecord {
   Status CheckBlobCRC() const;
 };
 
-// Checks whether a blob offset is potentially valid or not.
-inline bool IsValidBlobOffset(uint64_t value_offset, uint64_t key_size,
-                              uint64_t value_size, uint64_t file_size) {
-  if (value_offset <
-      BlobLogHeader::kSize + BlobLogRecord::kHeaderSize + key_size) {
-    return false;
-  }
-
-  if (value_offset + value_size + BlobLogFooter::kSize > file_size) {
-    return false;
-  }
-
-  return true;
-}
-
 }  // namespace ROCKSDB_NAMESPACE

db/blob/blob_log_reader.cc

@@ -4,7 +4,9 @@
 //  (found in the LICENSE.Apache file in the root directory).
 //
 
-#include "db/blob/blob_log_sequential_reader.h"
+#include "db/blob/blob_log_reader.h"
+
+#include <algorithm>
 
 #include "file/random_access_file_reader.h"
 #include "monitoring/statistics.h"
@@ -12,19 +14,16 @@
 
 namespace ROCKSDB_NAMESPACE {
 
-BlobLogSequentialReader::BlobLogSequentialReader(
+BlobLogReader::BlobLogReader(
     std::unique_ptr<RandomAccessFileReader>&& file_reader, Env* env,
     Statistics* statistics)
     : file_(std::move(file_reader)),
       env_(env),
       statistics_(statistics),
+      buffer_(),
       next_byte_(0) {}
 
-BlobLogSequentialReader::~BlobLogSequentialReader() = default;
-
-Status BlobLogSequentialReader::ReadSlice(uint64_t size, Slice* slice,
-                                          char* buf) {
-  assert(slice);
+Status BlobLogReader::ReadSlice(uint64_t size, Slice* slice, char* buf) {
   assert(file_);
 
   StopWatch read_sw(env_, statistics_, BLOB_DB_BLOB_FILE_READ_MICROS);
@@ -41,8 +40,7 @@ Status BlobLogSequentialReader::ReadSlice(uint64_t size, Slice* slice,
   return s;
 }
 
-Status BlobLogSequentialReader::ReadHeader(BlobLogHeader* header) {
-  assert(header);
+Status BlobLogReader::ReadHeader(BlobLogHeader* header) {
   assert(next_byte_ == 0);
 
   static_assert(BlobLogHeader::kSize <= sizeof(header_buf_),
@@ -60,10 +58,8 @@ Status BlobLogSequentialReader::ReadHeader(BlobLogHeader* header) {
   return header->DecodeFrom(buffer_);
 }
 
-Status BlobLogSequentialReader::ReadRecord(BlobLogRecord* record,
-                                           ReadLevel level,
-                                           uint64_t* blob_offset) {
-  assert(record);
+Status BlobLogReader::ReadRecord(BlobLogRecord* record, ReadLevel level,
+                                 uint64_t* blob_offset) {
   static_assert(BlobLogRecord::kHeaderSize <= sizeof(header_buf_),
                 "Buffer is smaller than BlobLogRecord::kHeaderSize");
 
@@ -112,8 +108,7 @@ Status BlobLogSequentialReader::ReadRecord(BlobLogRecord* record,
   return s;
 }
 
-Status BlobLogSequentialReader::ReadFooter(BlobLogFooter* footer) {
-  assert(footer);
+Status BlobLogReader::ReadFooter(BlobLogFooter* footer) {
   static_assert(BlobLogFooter::kSize <= sizeof(header_buf_),
                 "Buffer is smaller than BlobLogFooter::kSize");
 

db/blob/blob_log_reader.h

@@ -6,26 +6,28 @@
 #pragma once
 
 #include <memory>
+#include <string>
 
 #include "db/blob/blob_log_format.h"
+#include "file/random_access_file_reader.h"
+#include "rocksdb/env.h"
 #include "rocksdb/slice.h"
+#include "rocksdb/statistics.h"
+#include "rocksdb/status.h"
 
 namespace ROCKSDB_NAMESPACE {
 
-class RandomAccessFileReader;
-class Env;
-class Statistics;
-class Status;
+class SequentialFileReader;
+class Logger;
 
 /**
- * BlobLogSequentialReader is a general purpose log stream reader
- * implementation. The actual job of reading from the device is implemented by
- * the RandomAccessFileReader interface.
+ * BlobLogReader is a general purpose log stream reader implementation. The
+ * actual job of reading from the device is implemented by the SequentialFile
+ * interface.
  *
- * Please see BlobLogWriter for details on the file and record layout.
+ * Please see Writer for details on the file and record layout.
  */
-
-class BlobLogSequentialReader {
+class BlobLogReader {
  public:
   enum ReadLevel {
     kReadHeader,
@@ -33,22 +35,23 @@ class BlobLogSequentialReader {
     kReadHeaderKeyBlob,
   };
 
-  // Create a reader that will return log records from "*file_reader".
-  BlobLogSequentialReader(std::unique_ptr<RandomAccessFileReader>&& file_reader,
-                          Env* env, Statistics* statistics);
-
+  // Create a reader that will return log records from "*file".
+  // "*file" must remain live while this BlobLogReader is in use.
+  BlobLogReader(std::unique_ptr<RandomAccessFileReader>&& file_reader, Env* env,
+                Statistics* statistics);
   // No copying allowed
-  BlobLogSequentialReader(const BlobLogSequentialReader&) = delete;
-  BlobLogSequentialReader& operator=(const BlobLogSequentialReader&) = delete;
+  BlobLogReader(const BlobLogReader&) = delete;
+  BlobLogReader& operator=(const BlobLogReader&) = delete;
 
-  ~BlobLogSequentialReader();
+  ~BlobLogReader() = default;
 
   Status ReadHeader(BlobLogHeader* header);
 
   // Read the next record into *record.  Returns true if read
-  // successfully, false if we hit end of the input. The contents filled in
-  // *record will only be valid until the next mutating operation on this
-  // reader.
+  // successfully, false if we hit end of the input.  May use
+  // "*scratch" as temporary storage.  The contents filled in *record
+  // will only be valid until the next mutating operation on this
+  // reader or the next mutation to *scratch.
   // If blob_offset is non-null, return offset of the blob through it.
   Status ReadRecord(BlobLogRecord* record, ReadLevel level = kReadHeader,
                     uint64_t* blob_offset = nullptr);
@@ -69,7 +72,7 @@ class BlobLogSequentialReader {
   Slice buffer_;
   char header_buf_[BlobLogRecord::kHeaderSize];
 
-  // which byte to read next
+  // which byte to read next. For asserting proper usage
   uint64_t next_byte_;
 };
 

db/blob/db_blob_basic_test.cc

@@ -1,184 +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 "db/blob/blob_index.h"
-#include "db/db_test_util.h"
-#include "port/stack_trace.h"
-#include "test_util/sync_point.h"
-#include "utilities/fault_injection_env.h"
-
-namespace ROCKSDB_NAMESPACE {
-
-class DBBlobBasicTest : public DBTestBase {
- protected:
-  DBBlobBasicTest()
-      : DBTestBase("/db_blob_basic_test", /* env_do_fsync */ false) {}
-};
-
-TEST_F(DBBlobBasicTest, GetBlob) {
-  Options options = GetDefaultOptions();
-  options.enable_blob_files = true;
-  options.min_blob_size = 0;
-
-  Reopen(options);
-
-  constexpr char key[] = "key";
-  constexpr char blob_value[] = "blob_value";
-
-  ASSERT_OK(Put(key, blob_value));
-
-  ASSERT_OK(Flush());
-
-  ASSERT_EQ(Get(key), blob_value);
-
-  // Try again with no I/O allowed. The table and the necessary blocks should
-  // already be in their respective caches; however, the blob itself can only be
-  // read from the blob file, so the read should return Incomplete.
-  ReadOptions read_options;
-  read_options.read_tier = kBlockCacheTier;
-
-  PinnableSlice result;
-  ASSERT_TRUE(db_->Get(read_options, db_->DefaultColumnFamily(), key, &result)
-                  .IsIncomplete());
-}
-
-TEST_F(DBBlobBasicTest, GetBlob_CorruptIndex) {
-  Options options = GetDefaultOptions();
-  options.enable_blob_files = true;
-  options.min_blob_size = 0;
-
-  Reopen(options);
-
-  constexpr char key[] = "key";
-
-  // Fake a corrupt blob index.
-  const std::string blob_index("foobar");
-
-  WriteBatch batch;
-  ASSERT_OK(WriteBatchInternal::PutBlobIndex(&batch, 0, key, blob_index));
-  ASSERT_OK(db_->Write(WriteOptions(), &batch));
-
-  ASSERT_OK(Flush());
-
-  PinnableSlice result;
-  ASSERT_TRUE(db_->Get(ReadOptions(), db_->DefaultColumnFamily(), key, &result)
-                  .IsCorruption());
-}
-
-TEST_F(DBBlobBasicTest, GetBlob_InlinedTTLIndex) {
-  constexpr uint64_t min_blob_size = 10;
-
-  Options options = GetDefaultOptions();
-  options.enable_blob_files = true;
-  options.min_blob_size = min_blob_size;
-
-  Reopen(options);
-
-  constexpr char key[] = "key";
-  constexpr char blob[] = "short";
-  static_assert(sizeof(short) - 1 < min_blob_size,
-                "Blob too long to be inlined");
-
-  // Fake an inlined TTL blob index.
-  std::string blob_index;
-
-  constexpr uint64_t expiration = 1234567890;
-
-  BlobIndex::EncodeInlinedTTL(&blob_index, expiration, blob);
-
-  WriteBatch batch;
-  ASSERT_OK(WriteBatchInternal::PutBlobIndex(&batch, 0, key, blob_index));
-  ASSERT_OK(db_->Write(WriteOptions(), &batch));
-
-  ASSERT_OK(Flush());
-
-  PinnableSlice result;
-  ASSERT_TRUE(db_->Get(ReadOptions(), db_->DefaultColumnFamily(), key, &result)
-                  .IsCorruption());
-}
-
-TEST_F(DBBlobBasicTest, GetBlob_IndexWithInvalidFileNumber) {
-  Options options = GetDefaultOptions();
-  options.enable_blob_files = true;
-  options.min_blob_size = 0;
-
-  Reopen(options);
-
-  constexpr char key[] = "key";
-
-  // Fake a blob index referencing a non-existent blob file.
-  std::string blob_index;
-
-  constexpr uint64_t blob_file_number = 1000;
-  constexpr uint64_t offset = 1234;
-  constexpr uint64_t size = 5678;
-
-  BlobIndex::EncodeBlob(&blob_index, blob_file_number, offset, size,
-                        kNoCompression);
-
-  WriteBatch batch;
-  ASSERT_OK(WriteBatchInternal::PutBlobIndex(&batch, 0, key, blob_index));
-  ASSERT_OK(db_->Write(WriteOptions(), &batch));
-
-  ASSERT_OK(Flush());
-
-  PinnableSlice result;
-  ASSERT_TRUE(db_->Get(ReadOptions(), db_->DefaultColumnFamily(), key, &result)
-                  .IsCorruption());
-}
-
-class DBBlobBasicIOErrorTest : public DBBlobBasicTest,
-                               public testing::WithParamInterface<std::string> {
- protected:
-  DBBlobBasicIOErrorTest() : sync_point_(GetParam()) {
-    fault_injection_env_.reset(new FaultInjectionTestEnv(env_));
-  }
-  ~DBBlobBasicIOErrorTest() { Close(); }
-
-  std::unique_ptr<FaultInjectionTestEnv> fault_injection_env_;
-  std::string sync_point_;
-};
-
-INSTANTIATE_TEST_CASE_P(DBBlobBasicTest, DBBlobBasicIOErrorTest,
-                        ::testing::ValuesIn(std::vector<std::string>{
-                            "BlobFileReader::OpenFile:NewRandomAccessFile",
-                            "BlobFileReader::GetBlob:ReadFromFile"}));
-
-TEST_P(DBBlobBasicIOErrorTest, GetBlob_IOError) {
-  Options options;
-  options.env = fault_injection_env_.get();
-  options.enable_blob_files = true;
-  options.min_blob_size = 0;
-
-  Reopen(options);
-
-  constexpr char key[] = "key";
-  constexpr char blob_value[] = "blob_value";
-
-  ASSERT_OK(Put(key, blob_value));
-
-  ASSERT_OK(Flush());
-
-  SyncPoint::GetInstance()->SetCallBack(sync_point_, [this](void* /* arg */) {
-    fault_injection_env_->SetFilesystemActive(false,
-                                              Status::IOError(sync_point_));
-  });
-  SyncPoint::GetInstance()->EnableProcessing();
-
-  PinnableSlice result;
-  ASSERT_TRUE(db_->Get(ReadOptions(), db_->DefaultColumnFamily(), key, &result)
-                  .IsIOError());
-
-  SyncPoint::GetInstance()->DisableProcessing();
-  SyncPoint::GetInstance()->ClearAllCallBacks();
-}
-
-}  // namespace ROCKSDB_NAMESPACE
-
-int main(int argc, char** argv) {
-  ROCKSDB_NAMESPACE::port::InstallStackTraceHandler();
-  ::testing::InitGoogleTest(&argc, argv);
-  return RUN_ALL_TESTS();
-}

db/blob/db_blob_index_test.cc

@@ -73,9 +73,6 @@ class DBBlobIndexTest : public DBTestBase {
     if (s.IsNotFound()) {
       return "NOT_FOUND";
     }
-    if (s.IsCorruption()) {
-      return "CORRUPTION";
-    }
     if (s.IsNotSupported()) {
       return "NOT_SUPPORTED";
     }
@@ -103,7 +100,6 @@ class DBBlobIndexTest : public DBTestBase {
 
   Options GetTestOptions() {
     Options options;
-    options.env = CurrentOptions().env;
     options.create_if_missing = true;
     options.num_levels = 2;
     options.disable_auto_compactions = true;
@@ -157,13 +153,8 @@ TEST_F(DBBlobIndexTest, Write) {
   }
 }
 
-// Note: the following test case pertains to the StackableDB-based BlobDB
-// implementation. Get should be able to return blob index if is_blob_index is
-// provided, otherwise it should return Status::NotSupported (when reading from
-// memtable) or Status::Corruption (when reading from SST). Reading from SST
-// returns Corruption because we can't differentiate between the application
-// accidentally opening the base DB of a stacked BlobDB and actual corruption
-// when using the integrated BlobDB.
+// Get should be able to return blob index if is_blob_index is provided,
+// otherwise return Status::NotSupported status.
 TEST_F(DBBlobIndexTest, Get) {
   for (auto tier : kAllTiers) {
     DestroyAndReopen(GetTestOptions());
@@ -180,22 +171,15 @@ TEST_F(DBBlobIndexTest, Get) {
     ASSERT_EQ("value", GetImpl("key", &is_blob_index));
     ASSERT_FALSE(is_blob_index);
     // Verify blob index
-    if (tier <= kImmutableMemtables) {
-      ASSERT_TRUE(Get("blob_key", &value).IsNotSupported());
-      ASSERT_EQ("NOT_SUPPORTED", GetImpl("blob_key"));
-    } else {
-      ASSERT_TRUE(Get("blob_key", &value).IsCorruption());
-      ASSERT_EQ("CORRUPTION", GetImpl("blob_key"));
-    }
+    ASSERT_TRUE(Get("blob_key", &value).IsNotSupported());
+    ASSERT_EQ("NOT_SUPPORTED", GetImpl("blob_key"));
     ASSERT_EQ("blob_index", GetImpl("blob_key", &is_blob_index));
     ASSERT_TRUE(is_blob_index);
   }
 }
 
-// Note: the following test case pertains to the StackableDB-based BlobDB
-// implementation. Get should NOT return Status::NotSupported/Status::Corruption
-// if blob index is updated with a normal value. See the test case above for
-// more details.
+// Get should NOT return Status::NotSupported if blob index is updated with
+// a normal value.
 TEST_F(DBBlobIndexTest, Updated) {
   for (auto tier : kAllTiers) {
     DestroyAndReopen(GetTestOptions());
@@ -222,11 +206,7 @@ TEST_F(DBBlobIndexTest, Updated) {
       ASSERT_EQ("blob_index", GetBlobIndex("key" + ToString(i), snapshot));
     }
     ASSERT_EQ("new_value", Get("key1"));
-    if (tier <= kImmutableMemtables) {
-      ASSERT_EQ("NOT_SUPPORTED", GetImpl("key2"));
-    } else {
-      ASSERT_EQ("CORRUPTION", GetImpl("key2"));
-    }
+    ASSERT_EQ("NOT_SUPPORTED", GetImpl("key2"));
     ASSERT_EQ("NOT_FOUND", Get("key3"));
     ASSERT_EQ("NOT_FOUND", Get("key4"));
     ASSERT_EQ("a,b,c", GetImpl("key5"));

db/builder.cc

@@ -13,13 +13,11 @@
 #include <deque>
 #include <vector>
 
-#include "db/blob/blob_file_builder.h"
 #include "db/compaction/compaction_iterator.h"
 #include "db/dbformat.h"
 #include "db/event_helpers.h"
 #include "db/internal_stats.h"
 #include "db/merge_helper.h"
-#include "db/output_validator.h"
 #include "db/range_del_aggregator.h"
 #include "db/table_cache.h"
 #include "db/version_edit.h"
@@ -69,14 +67,13 @@ TableBuilder* NewTableBuilder(
 }
 
 Status BuildTable(
-    const std::string& dbname, VersionSet* versions,
-    const ImmutableDBOptions& db_options, const ImmutableCFOptions& ioptions,
+    const std::string& dbname, Env* env, FileSystem* fs,
+    const ImmutableCFOptions& ioptions,
     const MutableCFOptions& mutable_cf_options, const FileOptions& file_options,
     TableCache* table_cache, InternalIterator* iter,
     std::vector<std::unique_ptr<FragmentedRangeTombstoneIterator>>
         range_del_iters,
-    FileMetaData* meta, std::vector<BlobFileAddition>* blob_file_additions,
-    const InternalKeyComparator& internal_comparator,
+    FileMetaData* meta, const InternalKeyComparator& internal_comparator,
     const std::vector<std::unique_ptr<IntTblPropCollectorFactory>>*
         int_tbl_prop_collector_factories,
     uint32_t column_family_id, const std::string& column_family_name,
@@ -91,18 +88,15 @@ Status BuildTable(
     TableProperties* table_properties, int level, const uint64_t creation_time,
     const uint64_t oldest_key_time, Env::WriteLifeTimeHint write_hint,
     const uint64_t file_creation_time, const std::string& db_id,
-    const std::string& db_session_id, const std::string* full_history_ts_low) {
+    const std::string& db_session_id) {
   assert((column_family_id ==
           TablePropertiesCollectorFactory::Context::kUnknownColumnFamily) ==
          column_family_name.empty());
   // Reports the IOStats for flush for every following bytes.
   const size_t kReportFlushIOStatsEvery = 1048576;
-  OutputValidator output_validator(
-      internal_comparator,
-      /*enable_order_check=*/
-      mutable_cf_options.check_flush_compaction_key_order,
-      /*enable_hash=*/paranoid_file_checks);
+  uint64_t paranoid_hash = 0;
   Status s;
+  IOStatus io_s;
   meta->fd.file_size = 0;
   iter->SeekToFirst();
   std::unique_ptr<CompactionRangeDelAggregator> range_del_agg(
@@ -113,29 +107,28 @@ Status BuildTable(
 
   std::string fname = TableFileName(ioptions.cf_paths, meta->fd.GetNumber(),
                                     meta->fd.GetPathId());
-  std::vector<std::string> blob_file_paths;
   std::string file_checksum = kUnknownFileChecksum;
   std::string file_checksum_func_name = kUnknownFileChecksumFuncName;
 #ifndef ROCKSDB_LITE
   EventHelpers::NotifyTableFileCreationStarted(
       ioptions.listeners, dbname, column_family_name, fname, job_id, reason);
 #endif  // !ROCKSDB_LITE
-  Env* env = db_options.env;
-  assert(env);
-  FileSystem* fs = db_options.fs.get();
-  assert(fs);
   TableProperties tp;
   if (iter->Valid() || !range_del_agg->IsEmpty()) {
     TableBuilder* builder;
     std::unique_ptr<WritableFileWriter> file_writer;
+    // Currently we only enable dictionary compression during compaction to the
+    // bottommost level.
+    CompressionOptions compression_opts_for_flush(compression_opts);
+    compression_opts_for_flush.max_dict_bytes = 0;
+    compression_opts_for_flush.zstd_max_train_bytes = 0;
     {
       std::unique_ptr<FSWritableFile> file;
 #ifndef NDEBUG
       bool use_direct_writes = file_options.use_direct_writes;
       TEST_SYNC_POINT_CALLBACK("BuildTable:create_file", &use_direct_writes);
 #endif  // !NDEBUG
-      IOStatus io_s = NewWritableFile(fs, fname, &file, file_options);
-      assert(s.ok());
+      io_s = NewWritableFile(fs, fname, &file, file_options);
       s = io_s;
       if (io_status->ok()) {
         *io_status = io_s;
@@ -159,7 +152,7 @@ Status BuildTable(
           ioptions, mutable_cf_options, internal_comparator,
           int_tbl_prop_collector_factories, column_family_id,
           column_family_name, file_writer.get(), compression,
-          sample_for_compression, compression_opts, level,
+          sample_for_compression, compression_opts_for_flush, level,
           false /* skip_filters */, creation_time, oldest_key_time,
           0 /*target_file_size*/, file_creation_time, db_id, db_session_id);
     }
@@ -170,35 +163,20 @@ Status BuildTable(
                       snapshots.empty() ? 0 : snapshots.back(),
                       snapshot_checker);
 
-    std::unique_ptr<BlobFileBuilder> blob_file_builder(
-        (mutable_cf_options.enable_blob_files && blob_file_additions)
-            ? new BlobFileBuilder(versions, env, fs, &ioptions,
-                                  &mutable_cf_options, &file_options, job_id,
-                                  column_family_id, column_family_name,
-                                  io_priority, write_hint, &blob_file_paths,
-                                  blob_file_additions)
-            : nullptr);
-
     CompactionIterator c_iter(
         iter, internal_comparator.user_comparator(), &merge, kMaxSequenceNumber,
         &snapshots, earliest_write_conflict_snapshot, snapshot_checker, env,
         ShouldReportDetailedTime(env, ioptions.statistics),
-        true /* internal key corruption is not ok */, range_del_agg.get(),
-        blob_file_builder.get(), ioptions.allow_data_in_errors,
-        /*compaction=*/nullptr,
-        /*compaction_filter=*/nullptr, /*shutting_down=*/nullptr,
-        /*preserve_deletes_seqnum=*/0, /*manual_compaction_paused=*/nullptr,
-        db_options.info_log, full_history_ts_low);
-
+        true /* internal key corruption is not ok */, range_del_agg.get());
     c_iter.SeekToFirst();
     for (; c_iter.Valid(); c_iter.Next()) {
       const Slice& key = c_iter.key();
       const Slice& value = c_iter.value();
       const ParsedInternalKey& ikey = c_iter.ikey();
-      // Generate a rolling 64-bit hash of the key and values
-      s = output_validator.Add(key, value);
-      if (!s.ok()) {
-        break;
+      if (paranoid_file_checks) {
+        // Generate a rolling 64-bit hash of the key and values
+        paranoid_hash = Hash64(key.data(), key.size(), paranoid_hash);
+        paranoid_hash = Hash64(value.data(), value.size(), paranoid_hash);
       }
       builder->Add(key, value);
       meta->UpdateBoundaries(key, value, ikey.sequence, ikey.type);
@@ -210,33 +188,29 @@ Status BuildTable(
             ThreadStatus::FLUSH_BYTES_WRITTEN, IOSTATS(bytes_written));
       }
     }
-    if (!s.ok()) {
-      c_iter.status().PermitUncheckedError();
-    } else if (!c_iter.status().ok()) {
-      s = c_iter.status();
-    }
-
-    if (s.ok()) {
-      auto range_del_it = range_del_agg->NewIterator();
-      for (range_del_it->SeekToFirst(); range_del_it->Valid();
-           range_del_it->Next()) {
-        auto tombstone = range_del_it->Tombstone();
-        auto kv = tombstone.Serialize();
-        builder->Add(kv.first.Encode(), kv.second);
-        meta->UpdateBoundariesForRange(kv.first, tombstone.SerializeEndKey(),
-                                       tombstone.seq_, internal_comparator);
-      }
+
+    auto range_del_it = range_del_agg->NewIterator();
+    for (range_del_it->SeekToFirst(); range_del_it->Valid();
+         range_del_it->Next()) {
+      auto tombstone = range_del_it->Tombstone();
+      auto kv = tombstone.Serialize();
+      builder->Add(kv.first.Encode(), kv.second);
+      meta->UpdateBoundariesForRange(kv.first, tombstone.SerializeEndKey(),
+                                     tombstone.seq_, internal_comparator);
     }
 
+    // Finish and check for builder errors
+    bool empty = builder->IsEmpty();
+    s = c_iter.status();
     TEST_SYNC_POINT("BuildTable:BeforeFinishBuildTable");
-    const bool empty = builder->IsEmpty();
     if (!s.ok() || empty) {
       builder->Abandon();
     } else {
       s = builder->Finish();
     }
+    io_s = builder->io_status();
     if (io_status->ok()) {
-      *io_status = builder->io_status();
+      *io_status = io_s;
     }
 
     if (s.ok() && !empty) {
@@ -273,14 +247,6 @@ Status BuildTable(
       s = *io_status;
     }
 
-    if (blob_file_builder) {
-      if (s.ok()) {
-        s = blob_file_builder->Finish();
-      }
-
-      blob_file_builder.reset();
-    }
-
     // TODO Also check the IO status when create the Iterator.
 
     if (s.ok() && !empty) {
@@ -305,15 +271,15 @@ Status BuildTable(
           /*allow_unprepared_value*/ false));
       s = it->status();
       if (s.ok() && paranoid_file_checks) {
-        OutputValidator file_validator(internal_comparator,
-                                       /*enable_order_check=*/true,
-                                       /*enable_hash=*/true);
+        uint64_t check_hash = 0;
         for (it->SeekToFirst(); it->Valid(); it->Next()) {
           // Generate a rolling 64-bit hash of the key and values
-          file_validator.Add(it->key(), it->value()).PermitUncheckedError();
+          check_hash = Hash64(it->key().data(), it->key().size(), check_hash);
+          check_hash =
+              Hash64(it->value().data(), it->value().size(), check_hash);
         }
         s = it->status();
-        if (s.ok() && !output_validator.CompareValidator(file_validator)) {
+        if (s.ok() && check_hash != paranoid_hash) {
           s = Status::Corruption("Paranoid checksums do not match");
         }
       }
@@ -326,21 +292,7 @@ Status BuildTable(
   }
 
   if (!s.ok() || meta->fd.GetFileSize() == 0) {
-    TEST_SYNC_POINT("BuildTable:BeforeDeleteFile");
-
-    constexpr IODebugContext* dbg = nullptr;
-
-    Status ignored = fs->DeleteFile(fname, IOOptions(), dbg);
-    ignored.PermitUncheckedError();
-
-    assert(blob_file_additions || blob_file_paths.empty());
-
-    if (blob_file_additions) {
-      for (const std::string& blob_file_path : blob_file_paths) {
-        ignored = fs->DeleteFile(blob_file_path, IOOptions(), dbg);
-        ignored.PermitUncheckedError();
-      }
-    }
+    fs->DeleteFile(fname, IOOptions(), nullptr);
   }
 
   if (meta->fd.GetFileSize() == 0) {

db/builder.h

@@ -27,10 +27,8 @@ namespace ROCKSDB_NAMESPACE {
 struct Options;
 struct FileMetaData;
 
-class VersionSet;
 class Env;
 struct EnvOptions;
-class BlobFileAddition;
 class Iterator;
 class SnapshotChecker;
 class TableCache;
@@ -65,14 +63,13 @@ TableBuilder* NewTableBuilder(
 // @param column_family_name Name of the column family that is also identified
 //    by column_family_id, or empty string if unknown.
 extern Status BuildTable(
-    const std::string& dbname, VersionSet* versions,
-    const ImmutableDBOptions& db_options, const ImmutableCFOptions& options,
+    const std::string& dbname, Env* env, FileSystem* fs,
+    const ImmutableCFOptions& options,
     const MutableCFOptions& mutable_cf_options, const FileOptions& file_options,
     TableCache* table_cache, InternalIterator* iter,
     std::vector<std::unique_ptr<FragmentedRangeTombstoneIterator>>
         range_del_iters,
-    FileMetaData* meta, std::vector<BlobFileAddition>* blob_file_additions,
-    const InternalKeyComparator& internal_comparator,
+    FileMetaData* meta, const InternalKeyComparator& internal_comparator,
     const std::vector<std::unique_ptr<IntTblPropCollectorFactory>>*
         int_tbl_prop_collector_factories,
     uint32_t column_family_id, const std::string& column_family_name,
@@ -89,7 +86,6 @@ extern Status BuildTable(
     const uint64_t creation_time = 0, const uint64_t oldest_key_time = 0,
     Env::WriteLifeTimeHint write_hint = Env::WLTH_NOT_SET,
     const uint64_t file_creation_time = 0, const std::string& db_id = "",
-    const std::string& db_session_id = "",
-    const std::string* full_history_ts_low = nullptr);
+    const std::string& db_session_id = "");
 
 }  // namespace ROCKSDB_NAMESPACE

db/c.cc

@@ -60,6 +60,7 @@ using ROCKSDB_NAMESPACE::ColumnFamilyDescriptor;
 using ROCKSDB_NAMESPACE::ColumnFamilyHandle;
 using ROCKSDB_NAMESPACE::ColumnFamilyOptions;
 using ROCKSDB_NAMESPACE::CompactionFilter;
+using ROCKSDB_NAMESPACE::CompactionFilterContext;
 using ROCKSDB_NAMESPACE::CompactionFilterFactory;
 using ROCKSDB_NAMESPACE::CompactionOptionsFIFO;
 using ROCKSDB_NAMESPACE::CompactRangeOptions;
@@ -81,6 +82,7 @@ using ROCKSDB_NAMESPACE::LiveFileMetaData;
 using ROCKSDB_NAMESPACE::Logger;
 using ROCKSDB_NAMESPACE::MemoryUtil;
 using ROCKSDB_NAMESPACE::MergeOperator;
+using ROCKSDB_NAMESPACE::MergeOperators;
 using ROCKSDB_NAMESPACE::NewBloomFilterPolicy;
 using ROCKSDB_NAMESPACE::NewGenericRateLimiter;
 using ROCKSDB_NAMESPACE::NewLRUCache;
@@ -113,8 +115,10 @@ using ROCKSDB_NAMESPACE::WriteBatch;
 using ROCKSDB_NAMESPACE::WriteBatchWithIndex;
 using ROCKSDB_NAMESPACE::WriteOptions;
 
+using std::shared_ptr;
 using std::vector;
 using std::unordered_set;
+using std::map;
 
 extern "C" {
 
@@ -177,9 +181,6 @@ struct rocksdb_transaction_options_t {
 struct rocksdb_transaction_t {
   Transaction* rep;
 };
-struct rocksdb_backupable_db_options_t {
-  BackupableDBOptions rep;
-};
 struct rocksdb_checkpoint_t {
   Checkpoint* rep;
 };
@@ -503,13 +504,13 @@ rocksdb_t* rocksdb_open_with_ttl(
   return result;
 }
 
-rocksdb_t* rocksdb_open_for_read_only(const rocksdb_options_t* options,
-                                      const char* name,
-                                      unsigned char error_if_wal_file_exists,
-                                      char** errptr) {
+rocksdb_t* rocksdb_open_for_read_only(
+    const rocksdb_options_t* options,
+    const char* name,
+    unsigned char error_if_log_file_exist,
+    char** errptr) {
   DB* db;
-  if (SaveError(errptr, DB::OpenForReadOnly(options->rep, std::string(name),
-                                            &db, error_if_wal_file_exists))) {
+  if (SaveError(errptr, DB::OpenForReadOnly(options->rep, std::string(name), &db, error_if_log_file_exist))) {
     return nullptr;
   }
   rocksdb_t* result = new rocksdb_t;
@@ -548,18 +549,6 @@ rocksdb_backup_engine_t* rocksdb_backup_engine_open(
   return result;
 }
 
-rocksdb_backup_engine_t* rocksdb_backup_engine_open_opts(
-    const rocksdb_backupable_db_options_t* options, rocksdb_env_t* env,
-    char** errptr) {
-  BackupEngine* be;
-  if (SaveError(errptr, BackupEngine::Open(options->rep, env->rep, &be))) {
-    return nullptr;
-  }
-  rocksdb_backup_engine_t* result = new rocksdb_backup_engine_t;
-  result->rep = be;
-  return result;
-}
-
 void rocksdb_backup_engine_create_new_backup(rocksdb_backup_engine_t* be,
                                              rocksdb_t* db,
                                              char** errptr) {
@@ -656,128 +645,6 @@ void rocksdb_backup_engine_close(rocksdb_backup_engine_t* be) {
   delete be;
 }
 
-rocksdb_backupable_db_options_t* rocksdb_backupable_db_options_create(
-    const char* backup_dir) {
-  return new rocksdb_backupable_db_options_t{
-      BackupableDBOptions(std::string(backup_dir))};
-}
-
-void rocksdb_backupable_db_options_set_backup_dir(
-    rocksdb_backupable_db_options_t* options, const char* backup_dir) {
-  options->rep.backup_dir = std::string(backup_dir);
-}
-
-void rocksdb_backupable_db_options_set_env(
-    rocksdb_backupable_db_options_t* options, rocksdb_env_t* env) {
-  options->rep.backup_env = (env ? env->rep : nullptr);
-}
-
-void rocksdb_backupable_db_options_set_share_table_files(
-    rocksdb_backupable_db_options_t* options, unsigned char val) {
-  options->rep.share_table_files = val;
-}
-
-unsigned char rocksdb_backupable_db_options_get_share_table_files(
-    rocksdb_backupable_db_options_t* options) {
-  return options->rep.share_table_files;
-}
-
-void rocksdb_backupable_db_options_set_sync(
-    rocksdb_backupable_db_options_t* options, unsigned char val) {
-  options->rep.sync = val;
-}
-
-unsigned char rocksdb_backupable_db_options_get_sync(
-    rocksdb_backupable_db_options_t* options) {
-  return options->rep.sync;
-}
-
-void rocksdb_backupable_db_options_set_destroy_old_data(
-    rocksdb_backupable_db_options_t* options, unsigned char val) {
-  options->rep.destroy_old_data = val;
-}
-
-unsigned char rocksdb_backupable_db_options_get_destroy_old_data(
-    rocksdb_backupable_db_options_t* options) {
-  return options->rep.destroy_old_data;
-}
-
-void rocksdb_backupable_db_options_set_backup_log_files(
-    rocksdb_backupable_db_options_t* options, unsigned char val) {
-  options->rep.backup_log_files = val;
-}
-
-unsigned char rocksdb_backupable_db_options_get_backup_log_files(
-    rocksdb_backupable_db_options_t* options) {
-  return options->rep.backup_log_files;
-}
-
-void rocksdb_backupable_db_options_set_backup_rate_limit(
-    rocksdb_backupable_db_options_t* options, uint64_t limit) {
-  options->rep.backup_rate_limit = limit;
-}
-
-uint64_t rocksdb_backupable_db_options_get_backup_rate_limit(
-    rocksdb_backupable_db_options_t* options) {
-  return options->rep.backup_rate_limit;
-}
-
-void rocksdb_backupable_db_options_set_restore_rate_limit(
-    rocksdb_backupable_db_options_t* options, uint64_t limit) {
-  options->rep.restore_rate_limit = limit;
-}
-
-uint64_t rocksdb_backupable_db_options_get_restore_rate_limit(
-    rocksdb_backupable_db_options_t* options) {
-  return options->rep.restore_rate_limit;
-}
-
-void rocksdb_backupable_db_options_set_max_background_operations(
-    rocksdb_backupable_db_options_t* options, int val) {
-  options->rep.max_background_operations = val;
-}
-
-int rocksdb_backupable_db_options_get_max_background_operations(
-    rocksdb_backupable_db_options_t* options) {
-  return options->rep.max_background_operations;
-}
-
-void rocksdb_backupable_db_options_set_callback_trigger_interval_size(
-    rocksdb_backupable_db_options_t* options, uint64_t size) {
-  options->rep.callback_trigger_interval_size = size;
-}
-
-uint64_t rocksdb_backupable_db_options_get_callback_trigger_interval_size(
-    rocksdb_backupable_db_options_t* options) {
-  return options->rep.callback_trigger_interval_size;
-}
-
-void rocksdb_backupable_db_options_set_max_valid_backups_to_open(
-    rocksdb_backupable_db_options_t* options, int val) {
-  options->rep.max_valid_backups_to_open = val;
-}
-
-int rocksdb_backupable_db_options_get_max_valid_backups_to_open(
-    rocksdb_backupable_db_options_t* options) {
-  return options->rep.max_valid_backups_to_open;
-}
-
-void rocksdb_backupable_db_options_set_share_files_with_checksum_naming(
-    rocksdb_backupable_db_options_t* options, int val) {
-  options->rep.share_files_with_checksum_naming =
-      static_cast<BackupableDBOptions::ShareFilesNaming>(val);
-}
-
-int rocksdb_backupable_db_options_get_share_files_with_checksum_naming(
-    rocksdb_backupable_db_options_t* options) {
-  return static_cast<int>(options->rep.share_files_with_checksum_naming);
-}
-
-void rocksdb_backupable_db_options_destroy(
-    rocksdb_backupable_db_options_t* options) {
-  delete options;
-}
-
 rocksdb_checkpoint_t* rocksdb_checkpoint_object_create(rocksdb_t* db,
                                                        char** errptr) {
   Checkpoint* checkpoint;
@@ -880,7 +747,7 @@ rocksdb_t* rocksdb_open_for_read_only_column_families(
     int num_column_families, const char* const* column_family_names,
     const rocksdb_options_t* const* column_family_options,
     rocksdb_column_family_handle_t** column_family_handles,
-    unsigned char error_if_wal_file_exists, char** errptr) {
+    unsigned char error_if_log_file_exist, char** errptr) {
   std::vector<ColumnFamilyDescriptor> column_families;
   for (int i = 0; i < num_column_families; i++) {
     column_families.push_back(ColumnFamilyDescriptor(
@@ -890,10 +757,8 @@ rocksdb_t* rocksdb_open_for_read_only_column_families(
 
   DB* db;
   std::vector<ColumnFamilyHandle*> handles;
-  if (SaveError(errptr,
-                DB::OpenForReadOnly(DBOptions(db_options->rep),
-                                    std::string(name), column_families,
-                                    &handles, &db, error_if_wal_file_exists))) {
+  if (SaveError(errptr, DB::OpenForReadOnly(DBOptions(db_options->rep),
+          std::string(name), column_families, &handles, &db, error_if_log_file_exist))) {
     return nullptr;
   }
 
@@ -4118,36 +3983,20 @@ void rocksdb_env_set_background_threads(rocksdb_env_t* env, int n) {
   env->rep->SetBackgroundThreads(n);
 }
 
-int rocksdb_env_get_background_threads(rocksdb_env_t* env) {
-  return env->rep->GetBackgroundThreads();
-}
-
 void rocksdb_env_set_bottom_priority_background_threads(rocksdb_env_t* env,
                                                         int n) {
   env->rep->SetBackgroundThreads(n, Env::BOTTOM);
 }
 
-int rocksdb_env_get_bottom_priority_background_threads(rocksdb_env_t* env) {
-  return env->rep->GetBackgroundThreads(Env::BOTTOM);
-}
-
 void rocksdb_env_set_high_priority_background_threads(rocksdb_env_t* env, int n) {
   env->rep->SetBackgroundThreads(n, Env::HIGH);
 }
 
-int rocksdb_env_get_high_priority_background_threads(rocksdb_env_t* env) {
-  return env->rep->GetBackgroundThreads(Env::HIGH);
-}
-
 void rocksdb_env_set_low_priority_background_threads(rocksdb_env_t* env,
                                                      int n) {
   env->rep->SetBackgroundThreads(n, Env::LOW);
 }
 
-int rocksdb_env_get_low_priority_background_threads(rocksdb_env_t* env) {
-  return env->rep->GetBackgroundThreads(Env::LOW);
-}
-
 void rocksdb_env_join_all_threads(rocksdb_env_t* env) {
   env->rep->WaitForJoin();
 }
@@ -4375,62 +4224,32 @@ void rocksdb_universal_compaction_options_set_size_ratio(
   uco->rep->size_ratio = ratio;
 }
 
-int rocksdb_universal_compaction_options_get_size_ratio(
-    rocksdb_universal_compaction_options_t* uco) {
-  return uco->rep->size_ratio;
-}
-
 void rocksdb_universal_compaction_options_set_min_merge_width(
   rocksdb_universal_compaction_options_t* uco, int w) {
   uco->rep->min_merge_width = w;
 }
 
-int rocksdb_universal_compaction_options_get_min_merge_width(
-    rocksdb_universal_compaction_options_t* uco) {
-  return uco->rep->min_merge_width;
-}
-
 void rocksdb_universal_compaction_options_set_max_merge_width(
   rocksdb_universal_compaction_options_t* uco, int w) {
   uco->rep->max_merge_width = w;
 }
 
-int rocksdb_universal_compaction_options_get_max_merge_width(
-    rocksdb_universal_compaction_options_t* uco) {
-  return uco->rep->max_merge_width;
-}
-
 void rocksdb_universal_compaction_options_set_max_size_amplification_percent(
   rocksdb_universal_compaction_options_t* uco, int p) {
   uco->rep->max_size_amplification_percent = p;
 }
 
-int rocksdb_universal_compaction_options_get_max_size_amplification_percent(
-    rocksdb_universal_compaction_options_t* uco) {
-  return uco->rep->max_size_amplification_percent;
-}
-
 void rocksdb_universal_compaction_options_set_compression_size_percent(
   rocksdb_universal_compaction_options_t* uco, int p) {
   uco->rep->compression_size_percent = p;
 }
 
-int rocksdb_universal_compaction_options_get_compression_size_percent(
-    rocksdb_universal_compaction_options_t* uco) {
-  return uco->rep->compression_size_percent;
-}
-
 void rocksdb_universal_compaction_options_set_stop_style(
   rocksdb_universal_compaction_options_t* uco, int style) {
   uco->rep->stop_style =
       static_cast<ROCKSDB_NAMESPACE::CompactionStopStyle>(style);
 }
 
-int rocksdb_universal_compaction_options_get_stop_style(
-    rocksdb_universal_compaction_options_t* uco) {
-  return static_cast<int>(uco->rep->stop_style);
-}
-
 void rocksdb_universal_compaction_options_destroy(
   rocksdb_universal_compaction_options_t* uco) {
   delete uco->rep;
@@ -4448,11 +4267,6 @@ void rocksdb_fifo_compaction_options_set_max_table_files_size(
   fifo_opts->rep.max_table_files_size = size;
 }
 
-uint64_t rocksdb_fifo_compaction_options_get_max_table_files_size(
-    rocksdb_fifo_compaction_options_t* fifo_opts) {
-  return fifo_opts->rep.max_table_files_size;
-}
-
 void rocksdb_fifo_compaction_options_destroy(
     rocksdb_fifo_compaction_options_t* fifo_opts) {
   delete fifo_opts;

db/c_test.c

@@ -58,11 +58,7 @@ static void StartPhase(const char* name) {
 static const char* GetTempDir(void) {
     const char* ret = getenv("TEST_TMPDIR");
     if (ret == NULL || ret[0] == '\0')
-#ifdef OS_WIN
-      ret = getenv("TEMP");
-#else
-      ret = "/tmp";
-#endif
+        ret = "/tmp";
     return ret;
 }
 #ifdef _MSC_VER
@@ -2355,124 +2351,6 @@ int main(int argc, char** argv) {
     rocksdb_cache_destroy(co);
   }
 
-  StartPhase("env");
-  {
-    rocksdb_env_t* e;
-    e = rocksdb_create_default_env();
-
-    rocksdb_env_set_background_threads(e, 10);
-    CheckCondition(10 == rocksdb_env_get_background_threads(e));
-
-    rocksdb_env_set_high_priority_background_threads(e, 20);
-    CheckCondition(20 == rocksdb_env_get_high_priority_background_threads(e));
-
-    rocksdb_env_set_low_priority_background_threads(e, 30);
-    CheckCondition(30 == rocksdb_env_get_low_priority_background_threads(e));
-
-    rocksdb_env_set_bottom_priority_background_threads(e, 40);
-    CheckCondition(40 == rocksdb_env_get_bottom_priority_background_threads(e));
-
-    rocksdb_env_destroy(e);
-  }
-
-  StartPhase("universal_compaction_options");
-  {
-    rocksdb_universal_compaction_options_t* uco;
-    uco = rocksdb_universal_compaction_options_create();
-
-    rocksdb_universal_compaction_options_set_size_ratio(uco, 5);
-    CheckCondition(5 ==
-                   rocksdb_universal_compaction_options_get_size_ratio(uco));
-
-    rocksdb_universal_compaction_options_set_min_merge_width(uco, 15);
-    CheckCondition(
-        15 == rocksdb_universal_compaction_options_get_min_merge_width(uco));
-
-    rocksdb_universal_compaction_options_set_max_merge_width(uco, 25);
-    CheckCondition(
-        25 == rocksdb_universal_compaction_options_get_max_merge_width(uco));
-
-    rocksdb_universal_compaction_options_set_max_size_amplification_percent(uco,
-                                                                            35);
-    CheckCondition(
-        35 ==
-        rocksdb_universal_compaction_options_get_max_size_amplification_percent(
-            uco));
-
-    rocksdb_universal_compaction_options_set_compression_size_percent(uco, 45);
-    CheckCondition(
-        45 ==
-        rocksdb_universal_compaction_options_get_compression_size_percent(uco));
-
-    rocksdb_universal_compaction_options_set_stop_style(uco, 1);
-    CheckCondition(1 ==
-                   rocksdb_universal_compaction_options_get_stop_style(uco));
-
-    rocksdb_universal_compaction_options_destroy(uco);
-  }
-
-  StartPhase("fifo_compaction_options");
-  {
-    rocksdb_fifo_compaction_options_t* fco;
-    fco = rocksdb_fifo_compaction_options_create();
-
-    rocksdb_fifo_compaction_options_set_max_table_files_size(fco, 100000);
-    CheckCondition(
-        100000 ==
-        rocksdb_fifo_compaction_options_get_max_table_files_size(fco));
-
-    rocksdb_fifo_compaction_options_destroy(fco);
-  }
-
-  StartPhase("backupable_db_option");
-  {
-    rocksdb_backupable_db_options_t* bdo;
-    bdo = rocksdb_backupable_db_options_create("path");
-
-    rocksdb_backupable_db_options_set_share_table_files(bdo, 1);
-    CheckCondition(1 ==
-                   rocksdb_backupable_db_options_get_share_table_files(bdo));
-
-    rocksdb_backupable_db_options_set_sync(bdo, 1);
-    CheckCondition(1 == rocksdb_backupable_db_options_get_sync(bdo));
-
-    rocksdb_backupable_db_options_set_destroy_old_data(bdo, 1);
-    CheckCondition(1 ==
-                   rocksdb_backupable_db_options_get_destroy_old_data(bdo));
-
-    rocksdb_backupable_db_options_set_backup_log_files(bdo, 1);
-    CheckCondition(1 ==
-                   rocksdb_backupable_db_options_get_backup_log_files(bdo));
-
-    rocksdb_backupable_db_options_set_backup_rate_limit(bdo, 123);
-    CheckCondition(123 ==
-                   rocksdb_backupable_db_options_get_backup_rate_limit(bdo));
-
-    rocksdb_backupable_db_options_set_restore_rate_limit(bdo, 37);
-    CheckCondition(37 ==
-                   rocksdb_backupable_db_options_get_restore_rate_limit(bdo));
-
-    rocksdb_backupable_db_options_set_max_background_operations(bdo, 20);
-    CheckCondition(
-        20 == rocksdb_backupable_db_options_get_max_background_operations(bdo));
-
-    rocksdb_backupable_db_options_set_callback_trigger_interval_size(bdo, 9000);
-    CheckCondition(
-        9000 ==
-        rocksdb_backupable_db_options_get_callback_trigger_interval_size(bdo));
-
-    rocksdb_backupable_db_options_set_max_valid_backups_to_open(bdo, 40);
-    CheckCondition(
-        40 == rocksdb_backupable_db_options_get_max_valid_backups_to_open(bdo));
-
-    rocksdb_backupable_db_options_set_share_files_with_checksum_naming(bdo, 2);
-    CheckCondition(
-        2 == rocksdb_backupable_db_options_get_share_files_with_checksum_naming(
-                 bdo));
-
-    rocksdb_backupable_db_options_destroy(bdo);
-  }
-
   StartPhase("iterate_upper_bound");
   {
     // Create new empty database

db/column_family.cc

@@ -16,7 +16,6 @@
 #include <string>
 #include <vector>
 
-#include "db/blob/blob_file_cache.h"
 #include "db/compaction/compaction_picker.h"
 #include "db/compaction/compaction_picker_fifo.h"
 #include "db/compaction/compaction_picker_level.h"
@@ -33,7 +32,7 @@
 #include "monitoring/thread_status_util.h"
 #include "options/options_helper.h"
 #include "port/port.h"
-#include "rocksdb/table.h"
+#include "table/block_based/block_based_table_factory.h"
 #include "table/merging_iterator.h"
 #include "util/autovector.h"
 #include "util/cast_util.h"
@@ -358,8 +357,8 @@ ColumnFamilyOptions SanitizeOptions(const ImmutableDBOptions& db_options,
     result.max_compaction_bytes = result.target_file_size_base * 25;
   }
 
-  bool is_block_based_table = (result.table_factory->IsInstanceOf(
-      TableFactory::kBlockBasedTableName()));
+  bool is_block_based_table =
+      (result.table_factory->Name() == BlockBasedTableFactory::kName);
 
   const uint64_t kAdjustedTtl = 30 * 24 * 60 * 60;
   if (result.ttl == kDefaultTtl) {
@@ -560,10 +559,6 @@ ColumnFamilyData::ColumnFamilyData(
         new InternalStats(ioptions_.num_levels, db_options.env, this));
     table_cache_.reset(new TableCache(ioptions_, file_options, _table_cache,
                                       block_cache_tracer, io_tracer));
-    blob_file_cache_.reset(
-        new BlobFileCache(_table_cache, ioptions(), soptions(), id_,
-                          internal_stats_->GetBlobFileReadHist()));
-
     if (ioptions_.compaction_style == kCompactionStyleLevel) {
       compaction_picker_.reset(
           new LevelCompactionPicker(ioptions_, &internal_comparator_));
@@ -1088,7 +1083,7 @@ bool ColumnFamilyData::RangeOverlapWithCompaction(
 
 Status ColumnFamilyData::RangesOverlapWithMemtables(
     const autovector<Range>& ranges, SuperVersion* super_version,
-    bool allow_data_in_errors, bool* overlap) {
+    bool* overlap) {
   assert(overlap != nullptr);
   *overlap = false;
   // Create an InternalIterator over all unflushed memtables
@@ -1107,12 +1102,10 @@ Status ColumnFamilyData::RangesOverlapWithMemtables(
       super_version->mem->NewRangeTombstoneIterator(read_opts, read_seq);
   range_del_agg.AddTombstones(
       std::unique_ptr<FragmentedRangeTombstoneIterator>(active_range_del_iter));
-  Status status;
-  status = super_version->imm->AddRangeTombstoneIterators(
-      read_opts, nullptr /* arena */, &range_del_agg);
-  // AddRangeTombstoneIterators always return Status::OK.
-  assert(status.ok());
+  super_version->imm->AddRangeTombstoneIterators(read_opts, nullptr /* arena */,
+                                                 &range_del_agg);
 
+  Status status;
   for (size_t i = 0; i < ranges.size() && status.ok() && !*overlap; ++i) {
     auto* vstorage = super_version->current->storage_info();
     auto* ucmp = vstorage->InternalComparator()->user_comparator();
@@ -1121,12 +1114,12 @@ Status ColumnFamilyData::RangesOverlapWithMemtables(
     memtable_iter->Seek(range_start.Encode());
     status = memtable_iter->status();
     ParsedInternalKey seek_result;
-
-    if (status.ok() && memtable_iter->Valid()) {
-      status = ParseInternalKey(memtable_iter->key(), &seek_result,
-                                allow_data_in_errors);
+    if (status.ok()) {
+      if (memtable_iter->Valid() &&
+          !ParseInternalKey(memtable_iter->key(), &seek_result)) {
+        status = Status::Corruption("DB have corrupted keys");
+      }
     }
-
     if (status.ok()) {
       if (memtable_iter->Valid() &&
           ucmp->Compare(seek_result.user_key, ranges[i].limit) <= 0) {
@@ -1323,8 +1316,7 @@ Status ColumnFamilyData::ValidateOptions(
   }
 
   if (cf_options.ttl > 0 && cf_options.ttl != kDefaultTtl) {
-    if (!cf_options.table_factory->IsInstanceOf(
-            TableFactory::kBlockBasedTableName())) {
+    if (cf_options.table_factory->Name() != BlockBasedTableFactory::kName) {
       return Status::NotSupported(
           "TTL is only supported in Block-Based Table format. ");
     }
@@ -1332,8 +1324,7 @@ Status ColumnFamilyData::ValidateOptions(
 
   if (cf_options.periodic_compaction_seconds > 0 &&
       cf_options.periodic_compaction_seconds != kDefaultPeriodicCompSecs) {
-    if (!cf_options.table_factory->IsInstanceOf(
-            TableFactory::kBlockBasedTableName())) {
+    if (cf_options.table_factory->Name() != BlockBasedTableFactory::kName) {
       return Status::NotSupported(
           "Periodic Compaction is only supported in "
           "Block-Based Table format. ");

db/column_family.h

@@ -44,7 +44,6 @@ class LogBuffer;
 class InstrumentedMutex;
 class InstrumentedMutexLock;
 struct SuperVersionContext;
-class BlobFileCache;
 
 extern const double kIncSlowdownRatio;
 // This file contains a list of data structures for managing column family
@@ -382,7 +381,6 @@ class ColumnFamilyData {
                          SequenceNumber earliest_seq);
 
   TableCache* table_cache() const { return table_cache_.get(); }
-  BlobFileCache* blob_file_cache() const { return blob_file_cache_.get(); }
 
   // See documentation in compaction_picker.h
   // REQUIRES: DB mutex held
@@ -406,8 +404,7 @@ class ColumnFamilyData {
   //
   // Thread-safe
   Status RangesOverlapWithMemtables(const autovector<Range>& ranges,
-                                    SuperVersion* super_version,
-                                    bool allow_data_in_errors, bool* overlap);
+                                    SuperVersion* super_version, bool* overlap);
 
   // A flag to tell a manual compaction is to compact all levels together
   // instead of a specific level.
@@ -546,7 +543,6 @@ class ColumnFamilyData {
   const bool is_delete_range_supported_;
 
   std::unique_ptr<TableCache> table_cache_;
-  std::unique_ptr<BlobFileCache> blob_file_cache_;
 
   std::unique_ptr<InternalStats> internal_stats_;
 

db/column_family_test.cc

@@ -35,10 +35,10 @@ namespace ROCKSDB_NAMESPACE {
 static const int kValueSize = 1000;
 
 // counts how many operations were performed
-class EnvCounter : public SpecialEnv {
+class EnvCounter : public EnvWrapper {
  public:
   explicit EnvCounter(Env* base)
-      : SpecialEnv(base), num_new_writable_file_(0) {}
+      : EnvWrapper(base), num_new_writable_file_(0) {}
   int GetNumberOfNewWritableFileCalls() {
     return num_new_writable_file_;
   }
@@ -68,7 +68,6 @@ class ColumnFamilyTestBase : public testing::Test {
 #endif  // !ROCKSDB_LITE
     EXPECT_NE(nullptr, base_env);
     env_ = new EnvCounter(base_env);
-    env_->skip_fsync_ = true;
     dbname_ = test::PerThreadDBPath("column_family_test");
     db_options_.create_if_missing = true;
     db_options_.fail_if_options_file_error = true;
@@ -80,14 +79,10 @@ class ColumnFamilyTestBase : public testing::Test {
     std::vector<ColumnFamilyDescriptor> column_families;
     for (auto h : handles_) {
       ColumnFamilyDescriptor cfdescriptor;
-      Status s = h->GetDescriptor(&cfdescriptor);
-#ifdef ROCKSDB_LITE
-      EXPECT_TRUE(s.IsNotSupported());
-#else
-      EXPECT_OK(s);
-#endif  // ROCKSDB_LITE
+      h->GetDescriptor(&cfdescriptor);
       column_families.push_back(cfdescriptor);
     }
+    Close();
     ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->DisableProcessing();
     Destroy(column_families);
     delete env_;
@@ -173,7 +168,7 @@ class ColumnFamilyTestBase : public testing::Test {
   void Close() {
     for (auto h : handles_) {
       if (h) {
-        ASSERT_OK(db_->DestroyColumnFamilyHandle(h));
+        db_->DestroyColumnFamilyHandle(h);
       }
     }
     handles_.clear();
@@ -284,11 +279,9 @@ class ColumnFamilyTestBase : public testing::Test {
       // Verify the CF options of the returned CF handle.
       ColumnFamilyDescriptor desc;
       ASSERT_OK(handles_[cfi]->GetDescriptor(&desc));
-      // Need to sanitize the default column family options before comparing
-      // them.
-      ASSERT_OK(RocksDBOptionsParser::VerifyCFOptions(
-          ConfigOptions(), desc.options,
-          SanitizeOptions(dbfull()->immutable_db_options(), current_cf_opt)));
+      RocksDBOptionsParser::VerifyCFOptions(ConfigOptions(), desc.options,
+                                            current_cf_opt);
+
 #endif  // !ROCKSDB_LITE
       cfi++;
     }
@@ -314,7 +307,7 @@ class ColumnFamilyTestBase : public testing::Test {
   void DropColumnFamilies(const std::vector<int>& cfs) {
     for (auto cf : cfs) {
       ASSERT_OK(db_->DropColumnFamily(handles_[cf]));
-      ASSERT_OK(db_->DestroyColumnFamilyHandle(handles_[cf]));
+      db_->DestroyColumnFamilyHandle(handles_[cf]);
       handles_[cf] = nullptr;
       names_[cf] = "";
     }
@@ -335,7 +328,7 @@ class ColumnFamilyTestBase : public testing::Test {
         ASSERT_OK(Put(cf, key, rnd_.RandomString(key_value_size - 10)));
       }
     }
-    ASSERT_OK(db_->FlushWAL(/*sync=*/false));
+    db_->FlushWAL(false);
   }
 
 #ifndef ROCKSDB_LITE  // TEST functions in DB are not supported in lite
@@ -657,7 +650,7 @@ TEST_P(FlushEmptyCFTestWithParam, FlushEmptyCFTest) {
   Flush(0);
   ASSERT_OK(Put(1, "bar", "v3"));  // seqID 4
   ASSERT_OK(Put(1, "foo", "v4"));  // seqID 5
-  ASSERT_OK(db_->FlushWAL(/*sync=*/false));
+  db_->FlushWAL(false);
 
   // Preserve file system state up to here to simulate a crash condition.
   fault_env->SetFilesystemActive(false);
@@ -720,7 +713,7 @@ TEST_P(FlushEmptyCFTestWithParam, FlushEmptyCFTest2) {
   // Write to log file D
   ASSERT_OK(Put(1, "bar", "v4"));  // seqID 7
   ASSERT_OK(Put(1, "bar", "v5"));  // seqID 8
-  ASSERT_OK(db_->FlushWAL(/*sync=*/false));
+  db_->FlushWAL(false);
   // Preserve file system state up to here to simulate a crash condition.
   fault_env->SetFilesystemActive(false);
   std::vector<std::string> names;
@@ -849,15 +842,13 @@ TEST_P(ColumnFamilyTest, WriteBatchFailure) {
   Open();
   CreateColumnFamiliesAndReopen({"one", "two"});
   WriteBatch batch;
-  ASSERT_OK(batch.Put(handles_[0], Slice("existing"), Slice("column-family")));
-  ASSERT_OK(
-      batch.Put(handles_[1], Slice("non-existing"), Slice("column-family")));
+  batch.Put(handles_[0], Slice("existing"), Slice("column-family"));
+  batch.Put(handles_[1], Slice("non-existing"), Slice("column-family"));
   ASSERT_OK(db_->Write(WriteOptions(), &batch));
   DropColumnFamilies({1});
   WriteOptions woptions_ignore_missing_cf;
   woptions_ignore_missing_cf.ignore_missing_column_families = true;
-  ASSERT_OK(
-      batch.Put(handles_[0], Slice("still here"), Slice("column-family")));
+  batch.Put(handles_[0], Slice("still here"), Slice("column-family"));
   ASSERT_OK(db_->Write(woptions_ignore_missing_cf, &batch));
   ASSERT_EQ("column-family", Get(0, "still here"));
   Status s = db_->Write(WriteOptions(), &batch);
@@ -896,10 +887,10 @@ TEST_P(ColumnFamilyTest, IgnoreRecoveredLog) {
   ASSERT_OK(env_->CreateDirIfMissing(dbname_));
   ASSERT_OK(env_->CreateDirIfMissing(backup_logs));
   std::vector<std::string> old_files;
-  ASSERT_OK(env_->GetChildren(backup_logs, &old_files));
+  env_->GetChildren(backup_logs, &old_files);
   for (auto& file : old_files) {
     if (file != "." && file != "..") {
-      ASSERT_OK(env_->DeleteFile(backup_logs + "/" + file));
+      env_->DeleteFile(backup_logs + "/" + file);
     }
   }
 
@@ -927,7 +918,7 @@ TEST_P(ColumnFamilyTest, IgnoreRecoveredLog) {
 
   // copy the logs to backup
   std::vector<std::string> logs;
-  ASSERT_OK(env_->GetChildren(db_options_.wal_dir, &logs));
+  env_->GetChildren(db_options_.wal_dir, &logs);
   for (auto& log : logs) {
     if (log != ".." && log != ".") {
       CopyFile(db_options_.wal_dir + "/" + log, backup_logs + "/" + log);
@@ -992,7 +983,6 @@ TEST_P(ColumnFamilyTest, FlushTest) {
     ASSERT_OK(Put(0, "foofoo", "bar"));
 
     for (auto* it : iterators) {
-      ASSERT_OK(it->status());
       delete it;
     }
   }
@@ -1090,8 +1080,8 @@ TEST_P(ColumnFamilyTest, CrashAfterFlush) {
   CreateColumnFamilies({"one"});
 
   WriteBatch batch;
-  ASSERT_OK(batch.Put(handles_[0], Slice("foo"), Slice("bar")));
-  ASSERT_OK(batch.Put(handles_[1], Slice("foo"), Slice("bar")));
+  batch.Put(handles_[0], Slice("foo"), Slice("bar"));
+  batch.Put(handles_[1], Slice("foo"), Slice("bar"));
   ASSERT_OK(db_->Write(WriteOptions(), &batch));
   Flush(0);
   fault_env->SetFilesystemActive(false);
@@ -2077,7 +2067,6 @@ std::string IterStatus(Iterator* iter) {
   if (iter->Valid()) {
     result = iter->key().ToString() + "->" + iter->value().ToString();
   } else {
-    EXPECT_OK(iter->status());
     result = "(invalid)";
   }
   return result;
@@ -2332,7 +2321,7 @@ TEST_P(ColumnFamilyTest, ReadDroppedColumnFamily) {
         ASSERT_OK(db_->DropColumnFamily(handles_[2]));
       } else {
         // delete CF two
-        ASSERT_OK(db_->DestroyColumnFamilyHandle(handles_[2]));
+        db_->DestroyColumnFamilyHandle(handles_[2]);
         handles_[2] = nullptr;
       }
       // Make sure iterator created can still be used.
@@ -2388,6 +2377,7 @@ TEST_P(ColumnFamilyTest, LiveIteratorWithDroppedColumnFamily) {
   // 1MB should create ~10 files for each CF
   int kKeysNum = 10000;
   PutRandomData(1, kKeysNum, 100);
+
   {
     std::unique_ptr<Iterator> iterator(
         db_->NewIterator(ReadOptions(), handles_[1]));
@@ -3038,7 +3028,6 @@ TEST_P(ColumnFamilyTest, IteratorCloseWALFile1) {
   ASSERT_OK(Put(1, "fodor", "mirko"));
   // Create an iterator holding the current super version.
   Iterator* it = db_->NewIterator(ReadOptions(), handles_[1]);
-  ASSERT_OK(it->status());
   // A flush will make `it` hold the last reference of its super version.
   Flush(1);
 
@@ -3091,7 +3080,6 @@ TEST_P(ColumnFamilyTest, IteratorCloseWALFile2) {
   ReadOptions ro;
   ro.background_purge_on_iterator_cleanup = true;
   Iterator* it = db_->NewIterator(ro, handles_[1]);
-  ASSERT_OK(it->status());
   // A flush will make `it` hold the last reference of its super version.
   Flush(1);
 
@@ -3186,8 +3174,6 @@ TEST_P(ColumnFamilyTest, ForwardIteratorCloseWALFile) {
   // Deleting the iterator will clear its super version, triggering
   // closing all files
   it->Seek("");
-  ASSERT_OK(it->status());
-
   ASSERT_EQ(2, env.num_open_wal_file_.load());
   ASSERT_EQ(0, env.delete_count_.load());
 
@@ -3218,8 +3204,8 @@ TEST_P(ColumnFamilyTest, LogSyncConflictFlush) {
   Open();
   CreateColumnFamiliesAndReopen({"one", "two"});
 
-  ASSERT_OK(Put(0, "", ""));
-  ASSERT_OK(Put(1, "foo", "bar"));
+  Put(0, "", "");
+  Put(1, "foo", "bar");
 
   ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->LoadDependency(
       {{"DBImpl::SyncWAL:BeforeMarkLogsSynced:1",
@@ -3229,11 +3215,11 @@ TEST_P(ColumnFamilyTest, LogSyncConflictFlush) {
 
   ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->EnableProcessing();
 
-  ROCKSDB_NAMESPACE::port::Thread thread([&] { ASSERT_OK(db_->SyncWAL()); });
+  ROCKSDB_NAMESPACE::port::Thread thread([&] { db_->SyncWAL(); });
 
   TEST_SYNC_POINT("ColumnFamilyTest::LogSyncConflictFlush:1");
   Flush(1);
-  ASSERT_OK(Put(1, "foo", "bar"));
+  Put(1, "foo", "bar");
   Flush(1);
 
   TEST_SYNC_POINT("ColumnFamilyTest::LogSyncConflictFlush:2");
@@ -3271,7 +3257,7 @@ TEST_P(ColumnFamilyTest, DISABLED_LogTruncationTest) {
     FileType type;
     if (!(ParseFileName(filenames[i], &number, &type))) continue;
 
-    if (type != kWalFile) continue;
+    if (type != kLogFile) continue;
 
     logfs.push_back(filenames[i]);
   }
@@ -3316,7 +3302,7 @@ TEST_P(ColumnFamilyTest, DISABLED_LogTruncationTest) {
   Close();
 
   // cleanup
-  ASSERT_OK(env_->DeleteDir(backup_logs));
+  env_->DeleteDir(backup_logs);
 }
 
 TEST_P(ColumnFamilyTest, DefaultCfPathsTest) {
@@ -3378,11 +3364,9 @@ TEST_P(ColumnFamilyTest, MultipleCFPathsTest) {
     read_options.readahead_size = 0;
     auto it = dbi->NewIterator(read_options, handles_[cf]);
     for (it->SeekToFirst(); it->Valid(); it->Next()) {
-      ASSERT_OK(it->status());
       Slice key(it->key());
       ASSERT_NE(keys_[cf].end(), keys_[cf].find(key.ToString()));
     }
-    ASSERT_OK(it->status());
     delete it;
 
     for (const auto& key : keys_[cf]) {

db/compacted_db_impl.cc

@@ -41,11 +41,8 @@ Status CompactedDBImpl::Get(const ReadOptions& options, ColumnFamilyHandle*,
                          GetContext::kNotFound, key, value, nullptr, nullptr,
                          nullptr, true, nullptr, nullptr);
   LookupKey lkey(key, kMaxSequenceNumber);
-  Status s = files_.files[FindFile(key)].fd.table_reader->Get(
-      options, lkey.internal_key(), &get_context, nullptr);
-  if (!s.ok() && !s.IsNotFound()) {
-    return s;
-  }
+  files_.files[FindFile(key)].fd.table_reader->Get(options, lkey.internal_key(),
+                                                   &get_context, nullptr);
   if (get_context.State() == GetContext::kFound) {
     return Status::OK();
   }
@@ -77,14 +74,10 @@ std::vector<Status> CompactedDBImpl::MultiGet(const ReadOptions& options,
                              GetContext::kNotFound, keys[idx], &pinnable_val,
                              nullptr, nullptr, nullptr, true, nullptr, nullptr);
       LookupKey lkey(keys[idx], kMaxSequenceNumber);
-      Status s = r->Get(options, lkey.internal_key(), &get_context, nullptr);
-      if (!s.ok() && !s.IsNotFound()) {
-        statuses[idx] = s;
-      } else {
-        value.assign(pinnable_val.data(), pinnable_val.size());
-        if (get_context.State() == GetContext::kFound) {
-          statuses[idx] = Status::OK();
-        }
+      r->Get(options, lkey.internal_key(), &get_context, nullptr);
+      value.assign(pinnable_val.data(), pinnable_val.size());
+      if (get_context.State() == GetContext::kFound) {
+        statuses[idx] = Status::OK();
       }
     }
     ++idx;
@@ -156,7 +149,7 @@ Status CompactedDBImpl::Open(const Options& options,
   std::unique_ptr<CompactedDBImpl> db(new CompactedDBImpl(db_options, dbname));
   Status s = db->Init(options);
   if (s.ok()) {
-    db->StartPeriodicWorkScheduler();
+    db->StartStatsDumpScheduler();
     ROCKS_LOG_INFO(db->immutable_db_options_.info_log,
                    "Opened the db as fully compacted mode");
     LogFlush(db->immutable_db_options_.info_log);

db/compaction/compaction.cc

@@ -248,6 +248,12 @@ Compaction::Compaction(VersionStorageInfo* vstorage,
   if (max_subcompactions_ == 0) {
     max_subcompactions_ = _mutable_db_options.max_subcompactions;
   }
+  if (!bottommost_level_) {
+    // Currently we only enable dictionary compression during compaction to the
+    // bottommost level.
+    output_compression_opts_.max_dict_bytes = 0;
+    output_compression_opts_.zstd_max_train_bytes = 0;
+  }
 
 #ifndef NDEBUG
   for (size_t i = 1; i < inputs_.size(); ++i) {
@@ -377,13 +383,7 @@ bool Compaction::KeyNotExistsBeyondOutputLevel(
         auto* f = files[level_ptrs->at(lvl)];
         if (user_cmp->Compare(user_key, f->largest.user_key()) <= 0) {
           // We've advanced far enough
-          // In the presence of user-defined timestamp, we may need to handle
-          // the case in which f->smallest.user_key() (including ts) has the
-          // same user key, but the ts part is smaller. If so,
-          // Compare(user_key, f->smallest.user_key()) returns -1.
-          // That's why we need CompareWithoutTimestamp().
-          if (user_cmp->CompareWithoutTimestamp(user_key,
-                                                f->smallest.user_key()) >= 0) {
+          if (user_cmp->Compare(user_key, f->smallest.user_key()) >= 0) {
             // Key falls in this file's range, so it may
             // exist beyond output level
             return false;

db/compaction/compaction_iterator.cc

@@ -3,11 +3,9 @@
 //  COPYING file in the root directory) and Apache 2.0 License
 //  (found in the LICENSE.Apache file in the root directory).
 
-#include "db/compaction/compaction_iterator.h"
-
 #include <cinttypes>
 
-#include "db/blob/blob_file_builder.h"
+#include "db/compaction/compaction_iterator.h"
 #include "db/snapshot_checker.h"
 #include "port/likely.h"
 #include "rocksdb/listener.h"
@@ -38,23 +36,20 @@ CompactionIterator::CompactionIterator(
     SequenceNumber earliest_write_conflict_snapshot,
     const SnapshotChecker* snapshot_checker, Env* env,
     bool report_detailed_time, bool expect_valid_internal_key,
-    CompactionRangeDelAggregator* range_del_agg,
-    BlobFileBuilder* blob_file_builder, bool allow_data_in_errors,
-    const Compaction* compaction, const CompactionFilter* compaction_filter,
+    CompactionRangeDelAggregator* range_del_agg, const Compaction* compaction,
+    const CompactionFilter* compaction_filter,
     const std::atomic<bool>* shutting_down,
     const SequenceNumber preserve_deletes_seqnum,
     const std::atomic<int>* manual_compaction_paused,
-    const std::shared_ptr<Logger> info_log,
-    const std::string* full_history_ts_low)
+    const std::shared_ptr<Logger> info_log)
     : CompactionIterator(
           input, cmp, merge_helper, last_sequence, snapshots,
           earliest_write_conflict_snapshot, snapshot_checker, env,
           report_detailed_time, expect_valid_internal_key, range_del_agg,
-          blob_file_builder, allow_data_in_errors,
           std::unique_ptr<CompactionProxy>(
-              compaction ? new RealCompaction(compaction) : nullptr),
+              compaction ? new CompactionProxy(compaction) : nullptr),
           compaction_filter, shutting_down, preserve_deletes_seqnum,
-          manual_compaction_paused, info_log, full_history_ts_low) {}
+          manual_compaction_paused, info_log) {}
 
 CompactionIterator::CompactionIterator(
     InternalIterator* input, const Comparator* cmp, MergeHelper* merge_helper,
@@ -63,14 +58,12 @@ CompactionIterator::CompactionIterator(
     const SnapshotChecker* snapshot_checker, Env* env,
     bool report_detailed_time, bool expect_valid_internal_key,
     CompactionRangeDelAggregator* range_del_agg,
-    BlobFileBuilder* blob_file_builder, bool allow_data_in_errors,
     std::unique_ptr<CompactionProxy> compaction,
     const CompactionFilter* compaction_filter,
     const std::atomic<bool>* shutting_down,
     const SequenceNumber preserve_deletes_seqnum,
     const std::atomic<int>* manual_compaction_paused,
-    const std::shared_ptr<Logger> info_log,
-    const std::string* full_history_ts_low)
+    const std::shared_ptr<Logger> info_log)
     : input_(input),
       cmp_(cmp),
       merge_helper_(merge_helper),
@@ -81,21 +74,16 @@ CompactionIterator::CompactionIterator(
       report_detailed_time_(report_detailed_time),
       expect_valid_internal_key_(expect_valid_internal_key),
       range_del_agg_(range_del_agg),
-      blob_file_builder_(blob_file_builder),
       compaction_(std::move(compaction)),
       compaction_filter_(compaction_filter),
       shutting_down_(shutting_down),
       manual_compaction_paused_(manual_compaction_paused),
       preserve_deletes_seqnum_(preserve_deletes_seqnum),
-      info_log_(info_log),
-      allow_data_in_errors_(allow_data_in_errors),
-      timestamp_size_(cmp_ ? cmp_->timestamp_size() : 0),
-      full_history_ts_low_(full_history_ts_low),
       current_user_key_sequence_(0),
       current_user_key_snapshot_(0),
       merge_out_iter_(merge_helper_),
       current_key_committed_(false),
-      cmp_with_history_ts_low_(0) {
+      info_log_(info_log) {
   assert(compaction_filter_ == nullptr || compaction_ != nullptr);
   assert(snapshots_ != nullptr);
   bottommost_level_ = compaction_ == nullptr
@@ -122,8 +110,6 @@ CompactionIterator::CompactionIterator(
   for (size_t i = 1; i < snapshots_->size(); ++i) {
     assert(snapshots_->at(i - 1) < snapshots_->at(i));
   }
-  assert(timestamp_size_ == 0 || !full_history_ts_low_ ||
-         timestamp_size_ == full_history_ts_low_->size());
 #endif
   input_->SetPinnedItersMgr(&pinned_iters_mgr_);
   TEST_SYNC_POINT_CALLBACK("CompactionIterator:AfterInit", compaction_.get());
@@ -158,13 +144,13 @@ void CompactionIterator::Next() {
     if (merge_out_iter_.Valid()) {
       key_ = merge_out_iter_.key();
       value_ = merge_out_iter_.value();
-      Status s = ParseInternalKey(key_, &ikey_, allow_data_in_errors_);
+      bool valid_key = ParseInternalKey(key_, &ikey_);
       // MergeUntil stops when it encounters a corrupt key and does not
       // include them in the result, so we expect the keys here to be valid.
-      assert(s.ok());
-      if (!s.ok()) {
-        ROCKS_LOG_FATAL(info_log_, "Invalid key in compaction. %s",
-                        s.getState());
+      assert(valid_key);
+      if (!valid_key) {
+        ROCKS_LOG_FATAL(info_log_, "Invalid key (%s) in compaction",
+                        key_.ToString(true).c_str());
       }
 
       // Keep current_key_ in sync.
@@ -277,15 +263,15 @@ void CompactionIterator::NextFromInput() {
     value_ = input_->value();
     iter_stats_.num_input_records++;
 
-    Status pik_status = ParseInternalKey(key_, &ikey_, allow_data_in_errors_);
-    if (!pik_status.ok()) {
+    if (!ParseInternalKey(key_, &ikey_)) {
       iter_stats_.num_input_corrupt_records++;
-
       // If `expect_valid_internal_key_` is false, return the corrupted key
       // and let the caller decide what to do with it.
+      // TODO(noetzli): We should have a more elegant solution for this.
       if (expect_valid_internal_key_) {
-        status_ = pik_status;
-        return;
+        assert(!"Corrupted internal key not expected.");
+        status_ = Status::Corruption("Corrupted internal key not expected.");
+        break;
       }
       key_ = current_key_.SetInternalKey(key_);
       has_current_user_key_ = false;
@@ -297,8 +283,7 @@ void CompactionIterator::NextFromInput() {
     TEST_SYNC_POINT_CALLBACK("CompactionIterator:ProcessKV", &ikey_);
 
     // Update input statistics
-    if (ikey_.type == kTypeDeletion || ikey_.type == kTypeSingleDeletion ||
-        ikey_.type == kTypeDeletionWithTimestamp) {
+    if (ikey_.type == kTypeDeletion || ikey_.type == kTypeSingleDeletion) {
       iter_stats_.num_input_deletion_records++;
     }
     iter_stats_.total_input_raw_key_bytes += key_.size();
@@ -311,56 +296,19 @@ void CompactionIterator::NextFromInput() {
     // merge_helper_->compaction_filter_skip_until_.
     Slice skip_until;
 
-    int cmp_user_key_without_ts = 0;
-    int cmp_ts = 0;
-    if (has_current_user_key_) {
-      cmp_user_key_without_ts =
-          timestamp_size_
-              ? cmp_->CompareWithoutTimestamp(ikey_.user_key, current_user_key_)
-              : cmp_->Compare(ikey_.user_key, current_user_key_);
-      // if timestamp_size_ > 0, then curr_ts_ has been initialized by a
-      // previous key.
-      cmp_ts = timestamp_size_ ? cmp_->CompareTimestamp(
-                                     ExtractTimestampFromUserKey(
-                                         ikey_.user_key, timestamp_size_),
-                                     curr_ts_)
-                               : 0;
-    }
-
     // Check whether the user key changed. After this if statement current_key_
     // is a copy of the current input key (maybe converted to a delete by the
     // compaction filter). ikey_.user_key is pointing to the copy.
-    if (!has_current_user_key_ || cmp_user_key_without_ts != 0 || cmp_ts != 0) {
+    if (!has_current_user_key_ ||
+        !cmp_->Equal(ikey_.user_key, current_user_key_)) {
       // First occurrence of this user key
       // Copy key for output
       key_ = current_key_.SetInternalKey(key_, &ikey_);
-
-      // If timestamp_size_ > 0, then copy from ikey_ to curr_ts_ for the use
-      // in next iteration to compare with the timestamp of next key.
-      UpdateTimestampAndCompareWithFullHistoryLow();
-
-      // If
-      // (1) !has_current_user_key_, OR
-      // (2) timestamp is disabled, OR
-      // (3) all history will be preserved, OR
-      // (4) user key (excluding timestamp) is different from previous key, OR
-      // (5) timestamp is NO older than *full_history_ts_low_
-      // then current_user_key_ must be treated as a different user key.
-      // This means, if a user key (excluding ts) is the same as the previous
-      // user key, and its ts is older than *full_history_ts_low_, then we
-      // consider this key for GC, e.g. it may be dropped if certain conditions
-      // match.
-      if (!has_current_user_key_ || !timestamp_size_ || !full_history_ts_low_ ||
-          0 != cmp_user_key_without_ts || cmp_with_history_ts_low_ >= 0) {
-        // Initialize for future comparison for rule (A) and etc.
-        current_user_key_sequence_ = kMaxSequenceNumber;
-        current_user_key_snapshot_ = 0;
-        has_current_user_key_ = true;
-      }
       current_user_key_ = ikey_.user_key;
-
+      has_current_user_key_ = true;
       has_outputted_key_ = false;
-
+      current_user_key_sequence_ = kMaxSequenceNumber;
+      current_user_key_snapshot_ = 0;
       current_key_committed_ = KeyCommitted(ikey_.sequence);
 
       // Apply the compaction filter to the first committed version of the user
@@ -475,9 +423,7 @@ void CompactionIterator::NextFromInput() {
 
       // Check whether the next key exists, is not corrupt, and is the same key
       // as the single delete.
-      if (input_->Valid() &&
-          ParseInternalKey(input_->key(), &next_ikey, allow_data_in_errors_)
-              .ok() &&
+      if (input_->Valid() && ParseInternalKey(input_->key(), &next_ikey) &&
           cmp_->Equal(ikey_.user_key, next_ikey.user_key)) {
         // Check whether the next key belongs to the same snapshot as the
         // SingleDelete.
@@ -581,12 +527,9 @@ void CompactionIterator::NextFromInput() {
                         last_sequence, current_user_key_sequence_);
       }
 
-      ++iter_stats_.num_record_drop_hidden;  // rule (A)
+      ++iter_stats_.num_record_drop_hidden;  // (A)
       input_->Next();
-    } else if (compaction_ != nullptr &&
-               (ikey_.type == kTypeDeletion ||
-                (ikey_.type == kTypeDeletionWithTimestamp &&
-                 cmp_with_history_ts_low_ < 0)) &&
+    } else if (compaction_ != nullptr && ikey_.type == kTypeDeletion &&
                IN_EARLIEST_SNAPSHOT(ikey_.sequence) &&
                ikeyNotNeededForIncrementalSnapshot() &&
                compaction_->KeyNotExistsBeyondOutputLevel(ikey_.user_key,
@@ -610,19 +553,13 @@ void CompactionIterator::NextFromInput() {
       // given that:
       // (1) The deletion is earlier than earliest_write_conflict_snapshot, and
       // (2) No value exist earlier than the deletion.
-      //
-      // Note also that a deletion marker of type kTypeDeletionWithTimestamp
-      // will be treated as a different user key unless the timestamp is older
-      // than *full_history_ts_low_.
       ++iter_stats_.num_record_drop_obsolete;
       if (!bottommost_level_) {
         ++iter_stats_.num_optimized_del_drop_obsolete;
       }
       input_->Next();
-    } else if ((ikey_.type == kTypeDeletion ||
-                (ikey_.type == kTypeDeletionWithTimestamp &&
-                 cmp_with_history_ts_low_ < 0)) &&
-               bottommost_level_ && ikeyNotNeededForIncrementalSnapshot()) {
+    } else if ((ikey_.type == kTypeDeletion) && bottommost_level_ &&
+               ikeyNotNeededForIncrementalSnapshot()) {
       // Handle the case where we have a delete key at the bottom most level
       // We can skip outputting the key iff there are no subsequent puts for this
       // key
@@ -630,29 +567,19 @@ void CompactionIterator::NextFromInput() {
                                  ikey_.user_key, &level_ptrs_));
       ParsedInternalKey next_ikey;
       input_->Next();
-      // Skip over all versions of this key that happen to occur in the same
-      // snapshot range as the delete.
-      //
-      // Note that a deletion marker of type kTypeDeletionWithTimestamp will be
-      // considered to have a different user key unless the timestamp is older
-      // than *full_history_ts_low_.
+      // Skip over all versions of this key that happen to occur in the same snapshot
+      // range as the delete
       while (!IsPausingManualCompaction() && !IsShuttingDown() &&
-             input_->Valid() &&
-             (ParseInternalKey(input_->key(), &next_ikey, allow_data_in_errors_)
-                  .ok()) &&
-             0 == cmp_->CompareWithoutTimestamp(ikey_.user_key,
-                                                next_ikey.user_key) &&
+             input_->Valid() && ParseInternalKey(input_->key(), &next_ikey) &&
+             cmp_->Equal(ikey_.user_key, next_ikey.user_key) &&
              (prev_snapshot == 0 ||
               DEFINITELY_NOT_IN_SNAPSHOT(next_ikey.sequence, prev_snapshot))) {
         input_->Next();
       }
       // If you find you still need to output a row with this key, we need to output the
       // delete too
-      if (input_->Valid() &&
-          (ParseInternalKey(input_->key(), &next_ikey, allow_data_in_errors_)
-               .ok()) &&
-          0 == cmp_->CompareWithoutTimestamp(ikey_.user_key,
-                                             next_ikey.user_key)) {
+      if (input_->Valid() && ParseInternalKey(input_->key(), &next_ikey) &&
+          cmp_->Equal(ikey_.user_key, next_ikey.user_key)) {
         valid_ = true;
         at_next_ = true;
       }
@@ -668,9 +595,8 @@ void CompactionIterator::NextFromInput() {
       // have hit (A)
       // We encapsulate the merge related state machine in a different
       // object to minimize change to the existing flow.
-      Status s =
-          merge_helper_->MergeUntil(input_, range_del_agg_, prev_snapshot,
-                                    bottommost_level_, allow_data_in_errors_);
+      Status s = merge_helper_->MergeUntil(input_, range_del_agg_,
+                                           prev_snapshot, bottommost_level_);
       merge_out_iter_.SeekToFirst();
 
       if (!s.ok() && !s.IsMergeInProgress()) {
@@ -681,13 +607,13 @@ void CompactionIterator::NextFromInput() {
         //       These will be correctly set below.
         key_ = merge_out_iter_.key();
         value_ = merge_out_iter_.value();
-        pik_status = ParseInternalKey(key_, &ikey_, allow_data_in_errors_);
+        bool valid_key = ParseInternalKey(key_, &ikey_);
         // MergeUntil stops when it encounters a corrupt key and does not
         // include them in the result, so we expect the keys here to valid.
-        assert(pik_status.ok());
-        if (!pik_status.ok()) {
-          ROCKS_LOG_FATAL(info_log_, "Invalid key in compaction. %s",
-                          pik_status.getState());
+        assert(valid_key);
+        if (!valid_key) {
+          ROCKS_LOG_FATAL(info_log_, "Invalid key (%s) in compaction",
+                          key_.ToString(true).c_str());
         }
         // Keep current_key_ in sync.
         current_key_.UpdateInternalKey(ikey_.sequence, ikey_.type);
@@ -735,37 +661,20 @@ void CompactionIterator::NextFromInput() {
 
 void CompactionIterator::PrepareOutput() {
   if (valid_) {
-    if (ikey_.type == kTypeValue) {
-      if (blob_file_builder_) {
-        blob_index_.clear();
-        const Status s =
-            blob_file_builder_->Add(user_key(), value_, &blob_index_);
+    if (compaction_filter_ && ikey_.type == kTypeBlobIndex) {
+      const auto blob_decision = compaction_filter_->PrepareBlobOutput(
+          user_key(), value_, &compaction_filter_value_);
 
-        if (!s.ok()) {
-          status_ = s;
-          valid_ = false;
-        } else if (!blob_index_.empty()) {
-          value_ = blob_index_;
-          ikey_.type = kTypeBlobIndex;
-          current_key_.UpdateInternalKey(ikey_.sequence, ikey_.type);
-        }
-      }
-    } else if (ikey_.type == kTypeBlobIndex) {
-      if (compaction_filter_) {
-        const auto blob_decision = compaction_filter_->PrepareBlobOutput(
-            user_key(), value_, &compaction_filter_value_);
-
-        if (blob_decision == CompactionFilter::BlobDecision::kCorruption) {
-          status_ = Status::Corruption(
-              "Corrupted blob reference encountered during GC");
-          valid_ = false;
-        } else if (blob_decision == CompactionFilter::BlobDecision::kIOError) {
-          status_ = Status::IOError("Could not relocate blob during GC");
-          valid_ = false;
-        } else if (blob_decision ==
-                   CompactionFilter::BlobDecision::kChangeValue) {
-          value_ = compaction_filter_value_;
-        }
+      if (blob_decision == CompactionFilter::BlobDecision::kCorruption) {
+        status_ = Status::Corruption(
+            "Corrupted blob reference encountered during GC");
+        valid_ = false;
+      } else if (blob_decision == CompactionFilter::BlobDecision::kIOError) {
+        status_ = Status::IOError("Could not relocate blob during GC");
+        valid_ = false;
+      } else if (blob_decision ==
+                 CompactionFilter::BlobDecision::kChangeValue) {
+        value_ = compaction_filter_value_;
       }
     }
 
@@ -791,18 +700,7 @@ void CompactionIterator::PrepareOutput() {
                         ikey_.type);
       }
       ikey_.sequence = 0;
-      if (!timestamp_size_) {
-        current_key_.UpdateInternalKey(0, ikey_.type);
-      } else if (full_history_ts_low_ && cmp_with_history_ts_low_ < 0) {
-        // We can also zero out timestamp for better compression.
-        // For the same user key (excluding timestamp), the timestamp-based
-        // history can be collapsed to save some space if the timestamp is
-        // older than *full_history_ts_low_.
-        const std::string kTsMin(timestamp_size_, static_cast<char>(0));
-        const Slice ts_slice = kTsMin;
-        ikey_.SetTimestamp(ts_slice);
-        current_key_.UpdateInternalKey(0, ikey_.type, &ts_slice);
-      }
+      current_key_.UpdateInternalKey(0, ikey_.type);
     }
   }
 }

db/compaction/compaction_iterator.h

@@ -21,65 +21,40 @@
 
 namespace ROCKSDB_NAMESPACE {
 
-class BlobFileBuilder;
-
 class CompactionIterator {
  public:
   // A wrapper around Compaction. Has a much smaller interface, only what
   // CompactionIterator uses. Tests can override it.
   class CompactionProxy {
    public:
+    explicit CompactionProxy(const Compaction* compaction)
+        : compaction_(compaction) {}
+
     virtual ~CompactionProxy() = default;
-
-    virtual int level() const = 0;
-
-    virtual bool KeyNotExistsBeyondOutputLevel(
-        const Slice& user_key, std::vector<size_t>* level_ptrs) const = 0;
-
-    virtual bool bottommost_level() const = 0;
-
-    virtual int number_levels() const = 0;
-
-    virtual Slice GetLargestUserKey() const = 0;
-
-    virtual bool allow_ingest_behind() const = 0;
-
-    virtual bool preserve_deletes() const = 0;
-  };
-
-  class RealCompaction : public CompactionProxy {
-   public:
-    explicit RealCompaction(const Compaction* compaction)
-        : compaction_(compaction) {
-      assert(compaction_);
-      assert(compaction_->immutable_cf_options());
+    virtual int level(size_t /*compaction_input_level*/ = 0) const {
+      return compaction_->level();
     }
-
-    int level() const override { return compaction_->level(); }
-
-    bool KeyNotExistsBeyondOutputLevel(
-        const Slice& user_key, std::vector<size_t>* level_ptrs) const override {
+    virtual bool KeyNotExistsBeyondOutputLevel(
+        const Slice& user_key, std::vector<size_t>* level_ptrs) const {
       return compaction_->KeyNotExistsBeyondOutputLevel(user_key, level_ptrs);
     }
-
-    bool bottommost_level() const override {
+    virtual bool bottommost_level() const {
       return compaction_->bottommost_level();
     }
-
-    int number_levels() const override { return compaction_->number_levels(); }
-
-    Slice GetLargestUserKey() const override {
+    virtual int number_levels() const { return compaction_->number_levels(); }
+    virtual Slice GetLargestUserKey() const {
       return compaction_->GetLargestUserKey();
     }
-
-    bool allow_ingest_behind() const override {
+    virtual bool allow_ingest_behind() const {
       return compaction_->immutable_cf_options()->allow_ingest_behind;
     }
-
-    bool preserve_deletes() const override {
+    virtual bool preserve_deletes() const {
       return compaction_->immutable_cf_options()->preserve_deletes;
     }
 
+   protected:
+    CompactionProxy() = default;
+
    private:
     const Compaction* compaction_;
   };
@@ -91,15 +66,12 @@ class CompactionIterator {
                      const SnapshotChecker* snapshot_checker, Env* env,
                      bool report_detailed_time, bool expect_valid_internal_key,
                      CompactionRangeDelAggregator* range_del_agg,
-                     BlobFileBuilder* blob_file_builder,
-                     bool allow_data_in_errors,
                      const Compaction* compaction = nullptr,
                      const CompactionFilter* compaction_filter = nullptr,
                      const std::atomic<bool>* shutting_down = nullptr,
                      const SequenceNumber preserve_deletes_seqnum = 0,
                      const std::atomic<int>* manual_compaction_paused = nullptr,
-                     const std::shared_ptr<Logger> info_log = nullptr,
-                     const std::string* full_history_ts_low = nullptr);
+                     const std::shared_ptr<Logger> info_log = nullptr);
 
   // Constructor with custom CompactionProxy, used for tests.
   CompactionIterator(InternalIterator* input, const Comparator* cmp,
@@ -109,15 +81,12 @@ class CompactionIterator {
                      const SnapshotChecker* snapshot_checker, Env* env,
                      bool report_detailed_time, bool expect_valid_internal_key,
                      CompactionRangeDelAggregator* range_del_agg,
-                     BlobFileBuilder* blob_file_builder,
-                     bool allow_data_in_errors,
                      std::unique_ptr<CompactionProxy> compaction,
                      const CompactionFilter* compaction_filter = nullptr,
                      const std::atomic<bool>* shutting_down = nullptr,
                      const SequenceNumber preserve_deletes_seqnum = 0,
                      const std::atomic<int>* manual_compaction_paused = nullptr,
-                     const std::shared_ptr<Logger> info_log = nullptr,
-                     const std::string* full_history_ts_low = nullptr);
+                     const std::shared_ptr<Logger> info_log = nullptr);
 
   ~CompactionIterator();
 
@@ -177,20 +146,6 @@ class CompactionIterator {
 
   bool IsInEarliestSnapshot(SequenceNumber sequence);
 
-  // Extract user-defined timestamp from user key if possible and compare it
-  // with *full_history_ts_low_ if applicable.
-  inline void UpdateTimestampAndCompareWithFullHistoryLow() {
-    if (!timestamp_size_) {
-      return;
-    }
-    Slice ts = ExtractTimestampFromUserKey(ikey_.user_key, timestamp_size_);
-    curr_ts_.assign(ts.data(), ts.size());
-    if (full_history_ts_low_) {
-      cmp_with_history_ts_low_ =
-          cmp_->CompareTimestamp(ts, *full_history_ts_low_);
-    }
-  }
-
   InternalIterator* input_;
   const Comparator* cmp_;
   MergeHelper* merge_helper_;
@@ -208,7 +163,6 @@ class CompactionIterator {
   bool report_detailed_time_;
   bool expect_valid_internal_key_;
   CompactionRangeDelAggregator* range_del_agg_;
-  BlobFileBuilder* blob_file_builder_;
   std::unique_ptr<CompactionProxy> compaction_;
   const CompactionFilter* compaction_filter_;
   const std::atomic<bool>* shutting_down_;
@@ -220,20 +174,6 @@ class CompactionIterator {
   SequenceNumber earliest_snapshot_;
   SequenceNumber latest_snapshot_;
 
-  std::shared_ptr<Logger> info_log_;
-
-  bool allow_data_in_errors_;
-
-  // Comes from comparator.
-  const size_t timestamp_size_;
-
-  // Lower bound timestamp to retain full history in terms of user-defined
-  // timestamp. If a key's timestamp is older than full_history_ts_low_, then
-  // the key *may* be eligible for garbage collection (GC). The skipping logic
-  // is in `NextFromInput()` and `PrepareOutput()`.
-  // If nullptr, NO GC will be performed and all history will be preserved.
-  const std::string* const full_history_ts_low_;
-
   // State
   //
   // Points to a copy of the current compaction iterator output (current_key_)
@@ -252,13 +192,11 @@ class CompactionIterator {
   // Stores whether ikey_.user_key is valid. If set to false, the user key is
   // not compared against the current key in the underlying iterator.
   bool has_current_user_key_ = false;
-  // If false, the iterator holds a copy of the current compaction iterator
-  // output (or current key in the underlying iterator during NextFromInput()).
-  bool at_next_ = false;
-
+  bool at_next_ = false;  // If false, the iterator
+  // Holds a copy of the current compaction iterator output (or current key in
+  // the underlying iterator during NextFromInput()).
   IterKey current_key_;
   Slice current_user_key_;
-  std::string curr_ts_;
   SequenceNumber current_user_key_sequence_;
   SequenceNumber current_user_key_snapshot_;
 
@@ -273,7 +211,6 @@ class CompactionIterator {
   // PinnedIteratorsManager used to pin input_ Iterator blocks while reading
   // merge operands and then releasing them after consuming them.
   PinnedIteratorsManager pinned_iters_mgr_;
-  std::string blob_index_;
   std::string compaction_filter_value_;
   InternalKey compaction_filter_skip_until_;
   // "level_ptrs" holds indices that remember which file of an associated
@@ -288,9 +225,7 @@ class CompactionIterator {
   // Used to avoid purging uncommitted values. The application can specify
   // uncommitted values by providing a SnapshotChecker object.
   bool current_key_committed_;
-
-  // Saved result of ucmp->CompareTimestamp(current_ts_, *full_history_ts_low_)
-  int cmp_with_history_ts_low_;
+  std::shared_ptr<Logger> info_log_;
 
   bool IsShuttingDown() {
     // This is a best-effort facility, so memory_order_relaxed is sufficient.

db/compaction/compaction_iterator_test.cc

@@ -156,22 +156,19 @@ class LoggingForwardVectorIterator : public InternalIterator {
 
 class FakeCompaction : public CompactionIterator::CompactionProxy {
  public:
-  int level() const override { return 0; }
+  FakeCompaction() = default;
 
+  int level(size_t /*compaction_input_level*/) const override { return 0; }
   bool KeyNotExistsBeyondOutputLevel(
       const Slice& /*user_key*/,
       std::vector<size_t>* /*level_ptrs*/) const override {
     return is_bottommost_level || key_not_exists_beyond_output_level;
   }
-
   bool bottommost_level() const override { return is_bottommost_level; }
-
   int number_levels() const override { return 1; }
-
   Slice GetLargestUserKey() const override {
     return "\xff\xff\xff\xff\xff\xff\xff\xff\xff";
   }
-
   bool allow_ingest_behind() const override { return is_allow_ingest_behind; }
 
   bool preserve_deletes() const override { return false; }
@@ -219,9 +216,6 @@ class CompactionIteratorTest : public testing::TestWithParam<bool> {
   CompactionIteratorTest()
       : cmp_(BytewiseComparator()), icmp_(cmp_), snapshots_({}) {}
 
-  explicit CompactionIteratorTest(const Comparator* ucmp)
-      : cmp_(ucmp), icmp_(cmp_), snapshots_({}) {}
-
   void InitIterators(
       const std::vector<std::string>& ks, const std::vector<std::string>& vs,
       const std::vector<std::string>& range_del_ks,
@@ -230,9 +224,7 @@ class CompactionIteratorTest : public testing::TestWithParam<bool> {
       SequenceNumber last_committed_sequence = kMaxSequenceNumber,
       MergeOperator* merge_op = nullptr, CompactionFilter* filter = nullptr,
       bool bottommost_level = false,
-      SequenceNumber earliest_write_conflict_snapshot = kMaxSequenceNumber,
-      bool key_not_exists_beyond_output_level = false,
-      const std::string* full_history_ts_low = nullptr) {
+      SequenceNumber earliest_write_conflict_snapshot = kMaxSequenceNumber) {
     std::unique_ptr<InternalIterator> unfragmented_range_del_iter(
         new test::VectorIterator(range_del_ks, range_del_vs));
     auto tombstone_list = std::make_shared<FragmentedRangeTombstoneList>(
@@ -244,12 +236,10 @@ class CompactionIteratorTest : public testing::TestWithParam<bool> {
     range_del_agg_->AddTombstones(std::move(range_del_iter));
 
     std::unique_ptr<CompactionIterator::CompactionProxy> compaction;
-    if (filter || bottommost_level || key_not_exists_beyond_output_level) {
+    if (filter || bottommost_level) {
       compaction_proxy_ = new FakeCompaction();
       compaction_proxy_->is_bottommost_level = bottommost_level;
       compaction_proxy_->is_allow_ingest_behind = AllowIngestBehind();
-      compaction_proxy_->key_not_exists_beyond_output_level =
-          key_not_exists_beyond_output_level;
       compaction.reset(compaction_proxy_);
     }
     bool use_snapshot_checker = UseSnapshotChecker() || GetParam();
@@ -262,22 +252,13 @@ class CompactionIteratorTest : public testing::TestWithParam<bool> {
                         0 /*latest_snapshot*/, snapshot_checker_.get(),
                         0 /*level*/, nullptr /*statistics*/, &shutting_down_));
 
-    if (c_iter_) {
-      // Since iter_ is still used in ~CompactionIterator(), we call
-      // ~CompactionIterator() first.
-      c_iter_.reset();
-    }
     iter_.reset(new LoggingForwardVectorIterator(ks, vs));
     iter_->SeekToFirst();
     c_iter_.reset(new CompactionIterator(
         iter_.get(), cmp_, merge_helper_.get(), last_sequence, &snapshots_,
         earliest_write_conflict_snapshot, snapshot_checker_.get(),
         Env::Default(), false /* report_detailed_time */, false,
-        range_del_agg_.get(), nullptr /* blob_file_builder */,
-        true /*allow_data_in_errors*/, std::move(compaction), filter,
-        &shutting_down_, /*preserve_deletes_seqnum=*/0,
-        /*manual_compaction_paused=*/nullptr, /*info_log=*/nullptr,
-        full_history_ts_low));
+        range_del_agg_.get(), std::move(compaction), filter, &shutting_down_));
   }
 
   void AddSnapshot(SequenceNumber snapshot,
@@ -299,13 +280,10 @@ class CompactionIteratorTest : public testing::TestWithParam<bool> {
       MergeOperator* merge_operator = nullptr,
       CompactionFilter* compaction_filter = nullptr,
       bool bottommost_level = false,
-      SequenceNumber earliest_write_conflict_snapshot = kMaxSequenceNumber,
-      bool key_not_exists_beyond_output_level = false,
-      const std::string* full_history_ts_low = nullptr) {
+      SequenceNumber earliest_write_conflict_snapshot = kMaxSequenceNumber) {
     InitIterators(input_keys, input_values, {}, {}, kMaxSequenceNumber,
                   last_committed_seq, merge_operator, compaction_filter,
-                  bottommost_level, earliest_write_conflict_snapshot,
-                  key_not_exists_beyond_output_level, full_history_ts_low);
+                  bottommost_level, earliest_write_conflict_snapshot);
     c_iter_->SeekToFirst();
     for (size_t i = 0; i < expected_keys.size(); i++) {
       std::string info = "i = " + ToString(i);
@@ -315,15 +293,9 @@ class CompactionIteratorTest : public testing::TestWithParam<bool> {
       ASSERT_EQ(expected_values[i], c_iter_->value().ToString()) << info;
       c_iter_->Next();
     }
-    ASSERT_OK(c_iter_->status());
     ASSERT_FALSE(c_iter_->Valid());
   }
 
-  void ClearSnapshots() {
-    snapshots_.clear();
-    snapshot_map_.clear();
-  }
-
   const Comparator* cmp_;
   const InternalKeyComparator icmp_;
   std::vector<SequenceNumber> snapshots_;
@@ -345,7 +317,6 @@ TEST_P(CompactionIteratorTest, EmptyResult) {
                  test::KeyStr("a", 3, kTypeValue)},
                 {"", "val"}, {}, {}, 5);
   c_iter_->SeekToFirst();
-  ASSERT_OK(c_iter_->status());
   ASSERT_FALSE(c_iter_->Valid());
 }
 
@@ -367,7 +338,6 @@ TEST_P(CompactionIteratorTest, CorruptionAfterSingleDeletion) {
   ASSERT_TRUE(c_iter_->Valid());
   ASSERT_EQ(test::KeyStr("b", 10, kTypeValue), c_iter_->key().ToString());
   c_iter_->Next();
-  ASSERT_OK(c_iter_->status());
   ASSERT_FALSE(c_iter_->Valid());
 }
 
@@ -384,7 +354,6 @@ TEST_P(CompactionIteratorTest, SimpleRangeDeletion) {
   ASSERT_TRUE(c_iter_->Valid());
   ASSERT_EQ(test::KeyStr("night", 3, kTypeValue), c_iter_->key().ToString());
   c_iter_->Next();
-  ASSERT_OK(c_iter_->status());
   ASSERT_FALSE(c_iter_->Valid());
 }
 
@@ -406,7 +375,6 @@ TEST_P(CompactionIteratorTest, RangeDeletionWithSnapshots) {
   ASSERT_TRUE(c_iter_->Valid());
   ASSERT_EQ(test::KeyStr("night", 40, kTypeValue), c_iter_->key().ToString());
   c_iter_->Next();
-  ASSERT_OK(c_iter_->status());
   ASSERT_FALSE(c_iter_->Valid());
 }
 
@@ -500,7 +468,6 @@ TEST_P(CompactionIteratorTest, CompactionFilterSkipUntil) {
   ASSERT_EQ(test::KeyStr("h", 91, kTypeValue), c_iter_->key().ToString());
   ASSERT_EQ("hv91", c_iter_->value().ToString());
   c_iter_->Next();
-  ASSERT_OK(c_iter_->status());
   ASSERT_FALSE(c_iter_->Valid());
 
   // Check that the compaction iterator did the correct sequence of calls on
@@ -694,7 +661,6 @@ TEST_P(CompactionIteratorTest, SingleMergeOperand) {
   ASSERT_TRUE(c_iter_->Valid());
   ASSERT_EQ("bv1bv2", c_iter_->value().ToString());
   c_iter_->Next();
-  ASSERT_OK(c_iter_->status());
   ASSERT_EQ("cv1cv2", c_iter_->value().ToString());
 }
 
@@ -1058,188 +1024,6 @@ INSTANTIATE_TEST_CASE_P(CompactionIteratorWithAllowIngestBehindTestInstance,
                         CompactionIteratorWithAllowIngestBehindTest,
                         testing::Values(true, false));
 
-class CompactionIteratorTsGcTest : public CompactionIteratorTest {
- public:
-  CompactionIteratorTsGcTest()
-      : CompactionIteratorTest(test::ComparatorWithU64Ts()) {}
-};
-
-TEST_P(CompactionIteratorTsGcTest, NoKeyEligibleForGC) {
-  constexpr char user_key[][2] = {{'a', '\0'}, {'b', '\0'}};
-  const std::vector<std::string> input_keys = {
-      test::KeyStr(/*ts=*/103, user_key[0], /*seq=*/4, kTypeValue),
-      test::KeyStr(/*ts=*/102, user_key[0], /*seq=*/3,
-                   kTypeDeletionWithTimestamp),
-      test::KeyStr(/*ts=*/104, user_key[1], /*seq=*/5, kTypeValue)};
-  const std::vector<std::string> input_values = {"a3", "", "b2"};
-  std::string full_history_ts_low;
-  // All keys' timestamps are newer than or equal to 102, thus none of them
-  // will be eligible for GC.
-  PutFixed64(&full_history_ts_low, 102);
-  const std::vector<std::string>& expected_keys = input_keys;
-  const std::vector<std::string>& expected_values = input_values;
-  const std::vector<std::pair<bool, bool>> params = {
-      {false, false}, {false, true}, {true, true}};
-  for (const std::pair<bool, bool>& param : params) {
-    const bool bottommost_level = param.first;
-    const bool key_not_exists_beyond_output_level = param.second;
-    RunTest(input_keys, input_values, expected_keys, expected_values,
-            /*last_committed_seq=*/kMaxSequenceNumber,
-            /*merge_operator=*/nullptr, /*compaction_filter=*/nullptr,
-            bottommost_level,
-            /*earliest_write_conflict_snapshot=*/kMaxSequenceNumber,
-            key_not_exists_beyond_output_level, &full_history_ts_low);
-  }
-}
-
-TEST_P(CompactionIteratorTsGcTest, AllKeysOlderThanThreshold) {
-  constexpr char user_key[][2] = {{'a', '\0'}, {'b', '\0'}};
-  const std::vector<std::string> input_keys = {
-      test::KeyStr(/*ts=*/103, user_key[0], /*seq=*/4,
-                   kTypeDeletionWithTimestamp),
-      test::KeyStr(/*ts=*/102, user_key[0], /*seq=*/3, kTypeValue),
-      test::KeyStr(/*ts=*/101, user_key[0], /*seq=*/2, kTypeValue),
-      test::KeyStr(/*ts=*/104, user_key[1], /*seq=*/5, kTypeValue)};
-  const std::vector<std::string> input_values = {"", "a2", "a1", "b5"};
-  std::string full_history_ts_low;
-  PutFixed64(&full_history_ts_low, std::numeric_limits<uint64_t>::max());
-  {
-    // With a snapshot at seq 3, both the deletion marker and the key at 3 must
-    // be preserved.
-    AddSnapshot(3);
-    const std::vector<std::string> expected_keys = {
-        input_keys[0], input_keys[1], input_keys[3]};
-    const std::vector<std::string> expected_values = {"", "a2", "b5"};
-    RunTest(input_keys, input_values, expected_keys, expected_values,
-            /*last_committed_seq=*/kMaxSequenceNumber,
-            /*merge_operator=*/nullptr, /*compaction_filter=*/nullptr,
-            /*bottommost_level=*/false,
-            /*earliest_write_conflict_snapshot=*/kMaxSequenceNumber,
-            /*key_not_exists_beyond_output_level=*/false, &full_history_ts_low);
-    ClearSnapshots();
-  }
-  {
-    // No snapshot, the deletion marker should be preserved because the user
-    // key may appear beyond output level.
-    const std::vector<std::string> expected_keys = {input_keys[0],
-                                                    input_keys[3]};
-    const std::vector<std::string> expected_values = {"", "b5"};
-    RunTest(input_keys, input_values, expected_keys, expected_values,
-            /*last_committed_seq=*/kMaxSequenceNumber,
-            /*merge_operator=*/nullptr, /*compaction_filter=*/nullptr,
-            /*bottommost_level=*/false,
-            /*earliest_write_conflict_snapshot=*/kMaxSequenceNumber,
-            /*key_not_exists_beyond_output_level=*/false, &full_history_ts_low);
-  }
-  {
-    // No snapshot, the deletion marker can be dropped because the user key
-    // does not appear in higher levels.
-    const std::vector<std::string> expected_keys = {input_keys[3]};
-    const std::vector<std::string> expected_values = {"b5"};
-    RunTest(input_keys, input_values, expected_keys, expected_values,
-            /*last_committed_seq=*/kMaxSequenceNumber,
-            /*merge_operator=*/nullptr, /*compaction_filter=*/nullptr,
-            /*bottommost_level=*/false,
-            /*earliest_write_conflict_snapshot=*/kMaxSequenceNumber,
-            /*key_not_exists_beyond_output_level=*/true, &full_history_ts_low);
-  }
-}
-
-TEST_P(CompactionIteratorTsGcTest, NewHidesOldSameSnapshot) {
-  constexpr char user_key[] = "a";
-  const std::vector<std::string> input_keys = {
-      test::KeyStr(/*ts=*/103, user_key, /*seq=*/4, kTypeDeletionWithTimestamp),
-      test::KeyStr(/*ts=*/102, user_key, /*seq=*/3, kTypeValue),
-      test::KeyStr(/*ts=*/101, user_key, /*seq=*/2, kTypeValue),
-      test::KeyStr(/*ts=*/100, user_key, /*seq=*/1, kTypeValue)};
-  const std::vector<std::string> input_values = {"", "a2", "a1", "a0"};
-  {
-    std::string full_history_ts_low;
-    // Keys whose timestamps larger than or equal to 102 will be preserved.
-    PutFixed64(&full_history_ts_low, 102);
-    const std::vector<std::string> expected_keys = {input_keys[0],
-                                                    input_keys[1]};
-    const std::vector<std::string> expected_values = {"", "a2"};
-    RunTest(input_keys, input_values, expected_keys, expected_values,
-            /*last_committed_seq=*/kMaxSequenceNumber,
-            /*merge_operator=*/nullptr, /*compaction_filter=*/nullptr,
-            /*bottommost_level=*/false,
-            /*earliest_write_conflict_snapshot=*/kMaxSequenceNumber,
-            /*key_not_exists_beyond_output_level=*/false, &full_history_ts_low);
-  }
-}
-
-TEST_P(CompactionIteratorTsGcTest, DropTombstones) {
-  constexpr char user_key[] = "a";
-  const std::vector<std::string> input_keys = {
-      test::KeyStr(/*ts=*/103, user_key, /*seq=*/4, kTypeDeletionWithTimestamp),
-      test::KeyStr(/*ts=*/102, user_key, /*seq=*/3, kTypeValue),
-      test::KeyStr(/*ts=*/101, user_key, /*seq=*/2, kTypeDeletionWithTimestamp),
-      test::KeyStr(/*ts=*/100, user_key, /*seq=*/1, kTypeValue)};
-  const std::vector<std::string> input_values = {"", "a2", "", "a0"};
-  const std::vector<std::string> expected_keys = {input_keys[0], input_keys[1]};
-  const std::vector<std::string> expected_values = {"", "a2"};
-
-  // Take a snapshot at seq 2.
-  AddSnapshot(2);
-
-  {
-    // Non-bottommost level, but key does not exist beyond output level.
-    std::string full_history_ts_low;
-    PutFixed64(&full_history_ts_low, 102);
-    RunTest(input_keys, input_values, expected_keys, expected_values,
-            /*last_committed_sequence=*/kMaxSequenceNumber,
-            /*merge_op=*/nullptr, /*compaction_filter=*/nullptr,
-            /*bottommost_level=*/false,
-            /*earliest_write_conflict_snapshot=*/kMaxSequenceNumber,
-            /*key_not_exists_beyond_output_level=*/true, &full_history_ts_low);
-  }
-  {
-    // Bottommost level
-    std::string full_history_ts_low;
-    PutFixed64(&full_history_ts_low, 102);
-    RunTest(input_keys, input_values, expected_keys, expected_values,
-            /*last_committed_seq=*/kMaxSequenceNumber,
-            /*merge_operator=*/nullptr, /*compaction_filter=*/nullptr,
-            /*bottommost_level=*/true,
-            /*earliest_write_conflict_snapshot=*/kMaxSequenceNumber,
-            /*key_not_exists_beyond_output_level=*/false, &full_history_ts_low);
-  }
-}
-
-TEST_P(CompactionIteratorTsGcTest, RewriteTs) {
-  constexpr char user_key[] = "a";
-  const std::vector<std::string> input_keys = {
-      test::KeyStr(/*ts=*/103, user_key, /*seq=*/4, kTypeDeletionWithTimestamp),
-      test::KeyStr(/*ts=*/102, user_key, /*seq=*/3, kTypeValue),
-      test::KeyStr(/*ts=*/101, user_key, /*seq=*/2, kTypeDeletionWithTimestamp),
-      test::KeyStr(/*ts=*/100, user_key, /*seq=*/1, kTypeValue)};
-  const std::vector<std::string> input_values = {"", "a2", "", "a0"};
-  const std::vector<std::string> expected_keys = {
-      input_keys[0], input_keys[1], input_keys[2],
-      test::KeyStr(/*ts=*/0, user_key, /*seq=*/0, kTypeValue)};
-  const std::vector<std::string> expected_values = {"", "a2", "", "a0"};
-
-  AddSnapshot(1);
-  AddSnapshot(2);
-
-  {
-    // Bottommost level and need to rewrite both ts and seq.
-    std::string full_history_ts_low;
-    PutFixed64(&full_history_ts_low, 102);
-    RunTest(input_keys, input_values, expected_keys, expected_values,
-            /*last_committed_seq=*/kMaxSequenceNumber,
-            /*merge_operator=*/nullptr, /*compaction_filter=*/nullptr,
-            /*bottommost_level=*/true,
-            /*earliest_write_conflict_snapshot=*/kMaxSequenceNumber,
-            /*key_not_exists_beyond_output_level=*/true, &full_history_ts_low);
-  }
-}
-
-INSTANTIATE_TEST_CASE_P(CompactionIteratorTsGcTestInstance,
-                        CompactionIteratorTsGcTest,
-                        testing::Values(true, false));
-
 }  // namespace ROCKSDB_NAMESPACE
 
 int main(int argc, char** argv) {

db/compaction/compaction_job.cc

@@ -20,8 +20,6 @@
 #include <utility>
 #include <vector>
 
-#include "db/blob/blob_file_addition.h"
-#include "db/blob/blob_file_builder.h"
 #include "db/builder.h"
 #include "db/db_impl/db_impl.h"
 #include "db/db_iter.h"
@@ -34,7 +32,6 @@
 #include "db/memtable_list.h"
 #include "db/merge_context.h"
 #include "db/merge_helper.h"
-#include "db/output_validator.h"
 #include "db/range_del_aggregator.h"
 #include "db/version_set.h"
 #include "file/filename.h"
@@ -127,20 +124,14 @@ struct CompactionJob::SubcompactionState {
 
   // Files produced by this subcompaction
   struct Output {
-    Output(FileMetaData&& _meta, const InternalKeyComparator& _icmp,
-           bool _enable_order_check, bool _enable_hash)
-        : meta(std::move(_meta)),
-          validator(_icmp, _enable_order_check, _enable_hash),
-          finished(false) {}
     FileMetaData meta;
-    OutputValidator validator;
     bool finished;
+    uint64_t paranoid_hash;
     std::shared_ptr<const TableProperties> table_properties;
   };
 
   // State kept for output being generated
   std::vector<Output> outputs;
-  std::vector<BlobFileAddition> blob_file_additions;
   std::unique_ptr<WritableFileWriter> outfile;
   std::unique_ptr<TableBuilder> builder;
 
@@ -179,16 +170,17 @@ struct CompactionJob::SubcompactionState {
 
   // Adds the key and value to the builder
   // If paranoid is true, adds the key-value to the paranoid hash
-  Status AddToBuilder(const Slice& key, const Slice& value) {
+  void AddToBuilder(const Slice& key, const Slice& value, bool paranoid) {
     auto curr = current_output();
     assert(builder != nullptr);
     assert(curr != nullptr);
-    Status s = curr->validator.Add(key, value);
-    if (!s.ok()) {
-      return s;
+    if (paranoid) {
+      // Generate a rolling 64-bit hash of the key and values
+      curr->paranoid_hash = Hash64(key.data(), key.size(), curr->paranoid_hash);
+      curr->paranoid_hash =
+          Hash64(value.data(), value.size(), curr->paranoid_hash);
     }
     builder->Add(key, value);
-    return Status::OK();
   }
 
   // Returns true iff we should stop building the current output
@@ -234,13 +226,21 @@ struct CompactionJob::CompactionState {
   std::vector<CompactionJob::SubcompactionState> sub_compact_states;
   Status status;
 
-  size_t num_output_files = 0;
-  uint64_t total_bytes = 0;
-  size_t num_blob_output_files = 0;
-  uint64_t total_blob_bytes = 0;
-  uint64_t num_output_records = 0;
+  uint64_t total_bytes;
+  uint64_t num_output_records;
 
-  explicit CompactionState(Compaction* c) : compaction(c) {}
+  explicit CompactionState(Compaction* c)
+      : compaction(c),
+        total_bytes(0),
+        num_output_records(0) {}
+
+  size_t NumOutputFiles() {
+    size_t total = 0;
+    for (auto& s : sub_compact_states) {
+      total += s.outputs.size();
+    }
+    return total;
+  }
 
   Slice SmallestUserKey() {
     for (const auto& sub_compact_state : sub_compact_states) {
@@ -267,30 +267,14 @@ struct CompactionJob::CompactionState {
 };
 
 void CompactionJob::AggregateStatistics() {
-  assert(compact_);
-
   for (SubcompactionState& sc : compact_->sub_compact_states) {
-    auto& outputs = sc.outputs;
-
-    if (!outputs.empty() && !outputs.back().meta.fd.file_size) {
-      // An error occurred, so ignore the last output.
-      outputs.pop_back();
-    }
-
-    compact_->num_output_files += outputs.size();
     compact_->total_bytes += sc.total_bytes;
-
-    const auto& blobs = sc.blob_file_additions;
-
-    compact_->num_blob_output_files += blobs.size();
-
-    for (const auto& blob : blobs) {
-      compact_->total_blob_bytes += blob.GetTotalBlobBytes();
-    }
-
     compact_->num_output_records += sc.num_output_records;
-
-    compaction_job_stats_->Add(sc.compaction_job_stats);
+  }
+  if (compaction_job_stats_) {
+    for (SubcompactionState& sc : compact_->sub_compact_states) {
+      compaction_job_stats_->Add(sc.compaction_job_stats);
+    }
   }
 }
 
@@ -299,8 +283,7 @@ CompactionJob::CompactionJob(
     const FileOptions& file_options, VersionSet* versions,
     const std::atomic<bool>* shutting_down,
     const SequenceNumber preserve_deletes_seqnum, LogBuffer* log_buffer,
-    FSDirectory* db_directory, FSDirectory* output_directory,
-    FSDirectory* blob_output_directory, Statistics* stats,
+    FSDirectory* db_directory, FSDirectory* output_directory, Statistics* stats,
     InstrumentedMutex* db_mutex, ErrorHandler* db_error_handler,
     std::vector<SequenceNumber> existing_snapshots,
     SequenceNumber earliest_write_conflict_snapshot,
@@ -309,7 +292,7 @@ CompactionJob::CompactionJob(
     const std::string& dbname, CompactionJobStats* compaction_job_stats,
     Env::Priority thread_pri, const std::shared_ptr<IOTracer>& io_tracer,
     const std::atomic<int>* manual_compaction_paused, const std::string& db_id,
-    const std::string& db_session_id, std::string full_history_ts_low)
+    const std::string& db_session_id)
     : job_id_(job_id),
       compact_(new CompactionState(compaction)),
       compaction_job_stats_(compaction_job_stats),
@@ -331,7 +314,6 @@ CompactionJob::CompactionJob(
       log_buffer_(log_buffer),
       db_directory_(db_directory),
       output_directory_(output_directory),
-      blob_output_directory_(blob_output_directory),
       stats_(stats),
       db_mutex_(db_mutex),
       db_error_handler_(db_error_handler),
@@ -344,9 +326,7 @@ CompactionJob::CompactionJob(
       paranoid_file_checks_(paranoid_file_checks),
       measure_io_stats_(measure_io_stats),
       write_hint_(Env::WLTH_NOT_SET),
-      thread_pri_(thread_pri),
-      full_history_ts_low_(std::move(full_history_ts_low)) {
-  assert(compaction_job_stats_ != nullptr);
+      thread_pri_(thread_pri) {
   assert(log_buffer_ != nullptr);
   const auto* cfd = compact_->compaction->column_family_data();
   ThreadStatusUtil::SetColumnFamily(cfd, cfd->ioptions()->env,
@@ -398,9 +378,10 @@ void CompactionJob::ReportStartedCompaction(Compaction* compaction) {
   // to ensure GetThreadList() can always show them all together.
   ThreadStatusUtil::SetThreadOperation(ThreadStatus::OP_COMPACTION);
 
-  compaction_job_stats_->is_manual_compaction =
-      compaction->is_manual_compaction();
-  compaction_job_stats_->is_full_compaction = compaction->is_full_compaction();
+  if (compaction_job_stats_) {
+    compaction_job_stats_->is_manual_compaction =
+        compaction->is_manual_compaction();
+  }
 }
 
 void CompactionJob::Prepare() {
@@ -620,34 +601,18 @@ Status CompactionJob::Run() {
   // Check if any thread encountered an error during execution
   Status status;
   IOStatus io_s;
-  bool wrote_new_blob_files = false;
-
   for (const auto& state : compact_->sub_compact_states) {
     if (!state.status.ok()) {
       status = state.status;
       io_s = state.io_status;
       break;
     }
-
-    if (!state.blob_file_additions.empty()) {
-      wrote_new_blob_files = true;
-    }
   }
-
   if (io_status_.ok()) {
     io_status_ = io_s;
   }
-  if (status.ok()) {
-    constexpr IODebugContext* dbg = nullptr;
-
-    if (output_directory_) {
-      io_s = output_directory_->Fsync(IOOptions(), dbg);
-    }
-
-    if (io_s.ok() && wrote_new_blob_files && blob_output_directory_ &&
-        blob_output_directory_ != output_directory_) {
-      io_s = blob_output_directory_->Fsync(IOOptions(), dbg);
-    }
+  if (status.ok() && output_directory_) {
+    io_s = output_directory_->Fsync(IOOptions(), nullptr);
   }
   if (io_status_.ok()) {
     io_status_ = io_s;
@@ -697,20 +662,14 @@ Status CompactionJob::Run() {
         auto s = iter->status();
 
         if (s.ok() && paranoid_file_checks_) {
-          OutputValidator validator(cfd->internal_comparator(),
-                                    /*_enable_order_check=*/true,
-                                    /*_enable_hash=*/true);
+          uint64_t hash = 0;
           for (iter->SeekToFirst(); iter->Valid(); iter->Next()) {
-            s = validator.Add(iter->key(), iter->value());
-            if (!s.ok()) {
-              break;
-            }
+            // Generate a rolling 64-bit hash of the key and values, using the
+            hash = Hash64(iter->key().data(), iter->key().size(), hash);
+            hash = Hash64(iter->value().data(), iter->value().size(), hash);
           }
-          if (s.ok()) {
-            s = iter->status();
-          }
-          if (s.ok() &&
-              !validator.CompareValidator(files_output[file_idx]->validator)) {
+          s = iter->status();
+          if (s.ok() && hash != files_output[file_idx]->paranoid_hash) {
             s = Status::Corruption("Paranoid checksums do not match");
           }
         }
@@ -753,7 +712,6 @@ Status CompactionJob::Run() {
   // Finish up all book-keeping to unify the subcompaction results
   AggregateStatistics();
   UpdateCompactionStats();
-
   RecordCompactionIOStats();
   LogFlush(db_options_.info_log);
   TEST_SYNC_POINT("CompactionJob::Run():End");
@@ -763,16 +721,11 @@ Status CompactionJob::Run() {
 }
 
 Status CompactionJob::Install(const MutableCFOptions& mutable_cf_options) {
-  assert(compact_);
-
   AutoThreadOperationStageUpdater stage_updater(
       ThreadStatus::STAGE_COMPACTION_INSTALL);
   db_mutex_->AssertHeld();
   Status status = compact_->status;
-
   ColumnFamilyData* cfd = compact_->compaction->column_family_data();
-  assert(cfd);
-
   cfd->internal_stats()->AddCompactionStats(
       compact_->compaction->output_level(), thread_pri_, compaction_stats_);
 
@@ -782,7 +735,6 @@ Status CompactionJob::Install(const MutableCFOptions& mutable_cf_options) {
   if (!versions_->io_status().ok()) {
     io_status_ = versions_->io_status();
   }
-
   VersionStorageInfo::LevelSummaryStorage tmp;
   auto vstorage = cfd->current()->storage_info();
   const auto& stats = compaction_stats_;
@@ -807,8 +759,6 @@ Status CompactionJob::Install(const MutableCFOptions& mutable_cf_options) {
         stats.bytes_written / static_cast<double>(stats.micros);
   }
 
-  const std::string& column_family_name = cfd->GetName();
-
   ROCKS_LOG_BUFFER(
       log_buffer_,
       "[%s] compacted to: %s, MB/sec: %.1f rd, %.1f wr, level %d, "
@@ -816,9 +766,8 @@ Status CompactionJob::Install(const MutableCFOptions& mutable_cf_options) {
       "MB in(%.1f, %.1f) out(%.1f), read-write-amplify(%.1f) "
       "write-amplify(%.1f) %s, records in: %" PRIu64
       ", records dropped: %" PRIu64 " output_compression: %s\n",
-      column_family_name.c_str(), vstorage->LevelSummary(&tmp),
-      bytes_read_per_sec, bytes_written_per_sec,
-      compact_->compaction->output_level(),
+      cfd->GetName().c_str(), vstorage->LevelSummary(&tmp), bytes_read_per_sec,
+      bytes_written_per_sec, compact_->compaction->output_level(),
       stats.num_input_files_in_non_output_levels,
       stats.num_input_files_in_output_level, stats.num_output_files,
       stats.bytes_read_non_output_levels / 1048576.0,
@@ -829,15 +778,6 @@ Status CompactionJob::Install(const MutableCFOptions& mutable_cf_options) {
       CompressionTypeToString(compact_->compaction->output_compression())
           .c_str());
 
-  const auto& blob_files = vstorage->GetBlobFiles();
-  if (!blob_files.empty()) {
-    ROCKS_LOG_BUFFER(log_buffer_,
-                     "[%s] Blob file summary: head=%" PRIu64 ", tail=%" PRIu64
-                     "\n",
-                     column_family_name.c_str(), blob_files.begin()->first,
-                     blob_files.rbegin()->first);
-  }
-
   UpdateCompactionJobStats(stats);
 
   auto stream = event_logger_->LogToBuffer(log_buffer_);
@@ -846,26 +786,21 @@ Status CompactionJob::Install(const MutableCFOptions& mutable_cf_options) {
          << "compaction_time_micros" << stats.micros
          << "compaction_time_cpu_micros" << stats.cpu_micros << "output_level"
          << compact_->compaction->output_level() << "num_output_files"
-         << compact_->num_output_files << "total_output_size"
-         << compact_->total_bytes;
-
-  if (compact_->num_blob_output_files > 0) {
-    stream << "num_blob_output_files" << compact_->num_blob_output_files
-           << "total_blob_output_size" << compact_->total_blob_bytes;
-  }
-
-  stream << "num_input_records" << stats.num_input_records
-         << "num_output_records" << compact_->num_output_records
-         << "num_subcompactions" << compact_->sub_compact_states.size()
-         << "output_compression"
+         << compact_->NumOutputFiles() << "total_output_size"
+         << compact_->total_bytes << "num_input_records"
+         << stats.num_input_records << "num_output_records"
+         << compact_->num_output_records << "num_subcompactions"
+         << compact_->sub_compact_states.size() << "output_compression"
          << CompressionTypeToString(compact_->compaction->output_compression());
 
-  stream << "num_single_delete_mismatches"
-         << compaction_job_stats_->num_single_del_mismatch;
-  stream << "num_single_delete_fallthrough"
-         << compaction_job_stats_->num_single_del_fallthru;
+  if (compaction_job_stats_ != nullptr) {
+    stream << "num_single_delete_mismatches"
+           << compaction_job_stats_->num_single_del_mismatch;
+    stream << "num_single_delete_fallthrough"
+           << compaction_job_stats_->num_single_del_fallthru;
+  }
 
-  if (measure_io_stats_) {
+  if (measure_io_stats_ && compaction_job_stats_ != nullptr) {
     stream << "file_write_nanos" << compaction_job_stats_->file_write_nanos;
     stream << "file_range_sync_nanos"
            << compaction_job_stats_->file_range_sync_nanos;
@@ -881,18 +816,12 @@ Status CompactionJob::Install(const MutableCFOptions& mutable_cf_options) {
   }
   stream.EndArray();
 
-  if (!blob_files.empty()) {
-    stream << "blob_file_head" << blob_files.begin()->first;
-    stream << "blob_file_tail" << blob_files.rbegin()->first;
-  }
-
   CleanupCompaction();
   return status;
 }
 
 void CompactionJob::ProcessKeyValueCompaction(SubcompactionState* sub_compact) {
-  assert(sub_compact);
-  assert(sub_compact->compaction);
+  assert(sub_compact != nullptr);
 
   uint64_t prev_cpu_micros = env_->NowCPUNanos() / 1000;
 
@@ -963,22 +892,6 @@ void CompactionJob::ProcessKeyValueCompaction(SubcompactionState* sub_compact) {
       snapshot_checker_, compact_->compaction->level(),
       db_options_.statistics.get());
 
-  const MutableCFOptions* mutable_cf_options =
-      sub_compact->compaction->mutable_cf_options();
-  assert(mutable_cf_options);
-
-  std::vector<std::string> blob_file_paths;
-
-  std::unique_ptr<BlobFileBuilder> blob_file_builder(
-      mutable_cf_options->enable_blob_files
-          ? new BlobFileBuilder(
-                versions_, env_, fs_.get(),
-                sub_compact->compaction->immutable_cf_options(),
-                mutable_cf_options, &file_options_, job_id_, cfd->GetID(),
-                cfd->GetName(), Env::IOPriority::IO_LOW, write_hint_,
-                &blob_file_paths, &sub_compact->blob_file_additions)
-          : nullptr);
-
   TEST_SYNC_POINT("CompactionJob::Run():Inprogress");
   TEST_SYNC_POINT_CALLBACK(
       "CompactionJob::Run():PausingManualCompaction:1",
@@ -996,17 +909,14 @@ void CompactionJob::ProcessKeyValueCompaction(SubcompactionState* sub_compact) {
   }
 
   Status status;
-  const std::string* const full_history_ts_low =
-      full_history_ts_low_.empty() ? nullptr : &full_history_ts_low_;
   sub_compact->c_iter.reset(new CompactionIterator(
       input.get(), cfd->user_comparator(), &merge, versions_->LastSequence(),
       &existing_snapshots_, earliest_write_conflict_snapshot_,
       snapshot_checker_, env_, ShouldReportDetailedTime(env_, stats_),
       /*expect_valid_internal_key=*/true, &range_del_agg,
-      blob_file_builder.get(), db_options_.allow_data_in_errors,
       sub_compact->compaction, compaction_filter, shutting_down_,
-      preserve_deletes_seqnum_, manual_compaction_paused_, db_options_.info_log,
-      full_history_ts_low));
+      preserve_deletes_seqnum_, manual_compaction_paused_,
+      db_options_.info_log));
   auto c_iter = sub_compact->c_iter.get();
   c_iter->SeekToFirst();
   if (c_iter->Valid() && sub_compact->compaction->output_level() != 0) {
@@ -1050,10 +960,7 @@ void CompactionJob::ProcessKeyValueCompaction(SubcompactionState* sub_compact) {
         break;
       }
     }
-    status = sub_compact->AddToBuilder(key, value);
-    if (!status.ok()) {
-      break;
-    }
+    sub_compact->AddToBuilder(key, value, paranoid_file_checks_);
 
     sub_compact->current_output_file_size =
         sub_compact->builder->EstimatedFileSize();
@@ -1071,11 +978,13 @@ void CompactionJob::ProcessKeyValueCompaction(SubcompactionState* sub_compact) {
     // going to be 1.2MB and max_output_file_size = 1MB, prefer to have 0.6MB
     // and 0.6MB instead of 1MB and 0.2MB)
     bool output_file_ended = false;
+    Status input_status;
     if (sub_compact->compaction->output_level() != 0 &&
         sub_compact->current_output_file_size >=
             sub_compact->compaction->max_output_file_size()) {
       // (1) this key terminates the file. For historical reasons, the iterator
       // status before advancing will be given to FinishCompactionOutputFile().
+      input_status = input->status();
       output_file_ended = true;
     }
     TEST_SYNC_POINT_CALLBACK(
@@ -1102,6 +1011,7 @@ void CompactionJob::ProcessKeyValueCompaction(SubcompactionState* sub_compact) {
         // (2) this key belongs to the next file. For historical reasons, the
         // iterator status after advancing will be given to
         // FinishCompactionOutputFile().
+        input_status = input->status();
         output_file_ended = true;
       }
     }
@@ -1111,9 +1021,9 @@ void CompactionJob::ProcessKeyValueCompaction(SubcompactionState* sub_compact) {
         next_key = &c_iter->key();
       }
       CompactionIterationStats range_del_out_stats;
-      status = FinishCompactionOutputFile(input->status(), sub_compact,
-                                          &range_del_agg, &range_del_out_stats,
-                                          next_key);
+      status =
+          FinishCompactionOutputFile(input_status, sub_compact, &range_del_agg,
+                                     &range_del_out_stats, next_key);
       RecordDroppedKeys(range_del_out_stats,
                         &sub_compact->compaction_job_stats);
     }
@@ -1169,20 +1079,12 @@ void CompactionJob::ProcessKeyValueCompaction(SubcompactionState* sub_compact) {
     CompactionIterationStats range_del_out_stats;
     Status s = FinishCompactionOutputFile(status, sub_compact, &range_del_agg,
                                           &range_del_out_stats);
-    if (!s.ok() && status.ok()) {
+    if (status.ok()) {
       status = s;
     }
     RecordDroppedKeys(range_del_out_stats, &sub_compact->compaction_job_stats);
   }
 
-  if (blob_file_builder) {
-    if (status.ok()) {
-      status = blob_file_builder->Finish();
-    }
-
-    blob_file_builder.reset();
-  }
-
   sub_compact->compaction_job_stats.cpu_micros =
       env_->NowCPUNanos() / 1000 - prev_cpu_micros;
 
@@ -1203,16 +1105,6 @@ void CompactionJob::ProcessKeyValueCompaction(SubcompactionState* sub_compact) {
       SetPerfLevel(prev_perf_level);
     }
   }
-#ifdef ROCKSDB_ASSERT_STATUS_CHECKED
-  if (!status.ok()) {
-    if (sub_compact->c_iter) {
-      sub_compact->c_iter->status().PermitUncheckedError();
-    }
-    if (input) {
-      input->status().PermitUncheckedError();
-    }
-  }
-#endif  // ROCKSDB_ASSERT_STATUS_CHECKED
 
   sub_compact->c_iter.reset();
   input.reset();
@@ -1442,6 +1334,7 @@ Status CompactionJob::FinishCompactionOutputFile(
              ExtractInternalKeyFooter(meta->smallest.Encode()) !=
                  PackSequenceAndType(0, kTypeRangeDeletion));
     }
+    meta->marked_for_compaction = sub_compact->builder->NeedCompact();
   }
   const uint64_t current_entries = sub_compact->builder->NumEntries();
   if (s.ok()) {
@@ -1456,7 +1349,6 @@ Status CompactionJob::FinishCompactionOutputFile(
   const uint64_t current_bytes = sub_compact->builder->FileSize();
   if (s.ok()) {
     meta->fd.file_size = current_bytes;
-    meta->marked_for_compaction = sub_compact->builder->NeedCompact();
   }
   sub_compact->current_output()->finished = true;
   sub_compact->total_bytes += current_bytes;
@@ -1482,9 +1374,6 @@ Status CompactionJob::FinishCompactionOutputFile(
   }
   if (sub_compact->io_status.ok()) {
     sub_compact->io_status = io_s;
-    // Since this error is really a copy of the
-    // "normal" status, it does not also need to be checked
-    sub_compact->io_status.PermitUncheckedError();
   }
   sub_compact->outfile.reset();
 
@@ -1543,10 +1432,7 @@ Status CompactionJob::FinishCompactionOutputFile(
   auto sfm =
       static_cast<SstFileManagerImpl*>(db_options_.sst_file_manager.get());
   if (sfm && meta != nullptr && meta->fd.GetPathId() == 0) {
-    Status add_s = sfm->OnAddFile(fname);
-    if (!add_s.ok() && s.ok()) {
-      s = add_s;
-    }
+    sfm->OnAddFile(fname);
     if (sfm->IsMaxAllowedSpaceReached()) {
       // TODO(ajkr): should we return OK() if max space was reached by the final
       // compaction output file (similarly to how flush works when full)?
@@ -1555,9 +1441,7 @@ Status CompactionJob::FinishCompactionOutputFile(
           "CompactionJob::FinishCompactionOutputFile:"
           "MaxAllowedSpaceReached");
       InstrumentedMutexLock l(db_mutex_);
-      // Should handle return error?
-      db_error_handler_->SetBGError(s, BackgroundErrorReason::kCompaction)
-          .PermitUncheckedError();
+      db_error_handler_->SetBGError(s, BackgroundErrorReason::kCompaction);
     }
   }
 #endif
@@ -1569,13 +1453,9 @@ Status CompactionJob::FinishCompactionOutputFile(
 
 Status CompactionJob::InstallCompactionResults(
     const MutableCFOptions& mutable_cf_options) {
-  assert(compact_);
-
   db_mutex_->AssertHeld();
 
   auto* compaction = compact_->compaction;
-  assert(compaction);
-
   // paranoia: verify that the files that we started with
   // still exist in the current version and in the same original level.
   // This ensures that a concurrent compaction did not erroneously
@@ -1591,32 +1471,23 @@ Status CompactionJob::InstallCompactionResults(
 
   {
     Compaction::InputLevelSummaryBuffer inputs_summary;
-    ROCKS_LOG_INFO(db_options_.info_log,
-                   "[%s] [JOB %d] Compacted %s => %" PRIu64 " bytes",
-                   compaction->column_family_data()->GetName().c_str(), job_id_,
-                   compaction->InputLevelSummary(&inputs_summary),
-                   compact_->total_bytes + compact_->total_blob_bytes);
+    ROCKS_LOG_INFO(
+        db_options_.info_log, "[%s] [JOB %d] Compacted %s => %" PRIu64 " bytes",
+        compaction->column_family_data()->GetName().c_str(), job_id_,
+        compaction->InputLevelSummary(&inputs_summary), compact_->total_bytes);
   }
 
-  VersionEdit* const edit = compaction->edit();
-  assert(edit);
-
   // Add compaction inputs
-  compaction->AddInputDeletions(edit);
+  compaction->AddInputDeletions(compact_->compaction->edit());
 
   for (const auto& sub_compact : compact_->sub_compact_states) {
     for (const auto& out : sub_compact.outputs) {
-      edit->AddFile(compaction->output_level(), out.meta);
-    }
-
-    for (const auto& blob : sub_compact.blob_file_additions) {
-      edit->AddBlobFile(blob);
+      compaction->edit()->AddFile(compaction->output_level(), out.meta);
     }
   }
-
   return versions_->LogAndApply(compaction->column_family_data(),
-                                mutable_cf_options, edit, db_mutex_,
-                                db_directory_);
+                                mutable_cf_options, compaction->edit(),
+                                db_mutex_, db_directory_);
 }
 
 void CompactionJob::RecordCompactionIOStats() {
@@ -1671,9 +1542,6 @@ Status CompactionJob::OpenCompactionOutputFile(
   s = io_s;
   if (sub_compact->io_status.ok()) {
     sub_compact->io_status = io_s;
-    // Since this error is really a copy of the io_s that is checked below as s,
-    // it does not also need to be checked.
-    sub_compact->io_status.PermitUncheckedError();
   }
   if (!s.ok()) {
     ROCKS_LOG_ERROR(
@@ -1709,17 +1577,14 @@ Status CompactionJob::OpenCompactionOutputFile(
 
   // Initialize a SubcompactionState::Output and add it to sub_compact->outputs
   {
-    FileMetaData meta;
-    meta.fd = FileDescriptor(file_number,
-                             sub_compact->compaction->output_path_id(), 0);
-    meta.oldest_ancester_time = oldest_ancester_time;
-    meta.file_creation_time = current_time;
-    sub_compact->outputs.emplace_back(
-        std::move(meta), cfd->internal_comparator(),
-        /*enable_order_check=*/
-        sub_compact->compaction->mutable_cf_options()
-            ->check_flush_compaction_key_order,
-        /*enable_hash=*/paranoid_file_checks_);
+    SubcompactionState::Output out;
+    out.meta.fd = FileDescriptor(file_number,
+                                 sub_compact->compaction->output_path_id(), 0);
+    out.meta.oldest_ancester_time = oldest_ancester_time;
+    out.meta.file_creation_time = current_time;
+    out.finished = false;
+    out.paranoid_hash = 0;
+    sub_compact->outputs.push_back(out);
   }
 
   writable_file->SetIOPriority(Env::IOPriority::IO_LOW);
@@ -1772,9 +1637,6 @@ void CompactionJob::CleanupCompaction() {
         TableCache::Evict(table_cache_.get(), out.meta.fd.GetNumber());
       }
     }
-    // TODO: sub_compact.io_status is not checked like status. Not sure if thats
-    // intentional. So ignoring the io_status as of now.
-    sub_compact.io_status.PermitUncheckedError();
   }
   delete compact_;
   compact_ = nullptr;
@@ -1792,8 +1654,6 @@ void CopyPrefix(const Slice& src, size_t prefix_length, std::string* dst) {
 #endif  // !ROCKSDB_LITE
 
 void CompactionJob::UpdateCompactionStats() {
-  assert(compact_);
-
   Compaction* compaction = compact_->compaction;
   compaction_stats_.num_input_files_in_non_output_levels = 0;
   compaction_stats_.num_input_files_in_output_level = 0;
@@ -1811,15 +1671,27 @@ void CompactionJob::UpdateCompactionStats() {
     }
   }
 
-  compaction_stats_.num_output_files =
-      static_cast<int>(compact_->num_output_files) +
-      static_cast<int>(compact_->num_blob_output_files);
-  compaction_stats_.bytes_written =
-      compact_->total_bytes + compact_->total_blob_bytes;
+  uint64_t num_output_records = 0;
 
-  if (compaction_stats_.num_input_records > compact_->num_output_records) {
+  for (const auto& sub_compact : compact_->sub_compact_states) {
+    size_t num_output_files = sub_compact.outputs.size();
+    if (sub_compact.builder != nullptr) {
+      // An error occurred so ignore the last output.
+      assert(num_output_files > 0);
+      --num_output_files;
+    }
+    compaction_stats_.num_output_files += static_cast<int>(num_output_files);
+
+    num_output_records += sub_compact.num_output_records;
+
+    for (const auto& out : sub_compact.outputs) {
+      compaction_stats_.bytes_written += out.meta.fd.file_size;
+    }
+  }
+
+  if (compaction_stats_.num_input_records > num_output_records) {
     compaction_stats_.num_dropped_records =
-        compaction_stats_.num_input_records - compact_->num_output_records;
+        compaction_stats_.num_input_records - num_output_records;
   }
 }
 
@@ -1841,29 +1713,32 @@ void CompactionJob::UpdateCompactionInputStatsHelper(int* num_files,
 void CompactionJob::UpdateCompactionJobStats(
     const InternalStats::CompactionStats& stats) const {
 #ifndef ROCKSDB_LITE
-  compaction_job_stats_->elapsed_micros = stats.micros;
+  if (compaction_job_stats_) {
+    compaction_job_stats_->elapsed_micros = stats.micros;
 
-  // input information
-  compaction_job_stats_->total_input_bytes =
-      stats.bytes_read_non_output_levels + stats.bytes_read_output_level;
-  compaction_job_stats_->num_input_records = stats.num_input_records;
-  compaction_job_stats_->num_input_files =
-      stats.num_input_files_in_non_output_levels +
-      stats.num_input_files_in_output_level;
-  compaction_job_stats_->num_input_files_at_output_level =
-      stats.num_input_files_in_output_level;
+    // input information
+    compaction_job_stats_->total_input_bytes =
+        stats.bytes_read_non_output_levels + stats.bytes_read_output_level;
+    compaction_job_stats_->num_input_records = stats.num_input_records;
+    compaction_job_stats_->num_input_files =
+        stats.num_input_files_in_non_output_levels +
+        stats.num_input_files_in_output_level;
+    compaction_job_stats_->num_input_files_at_output_level =
+        stats.num_input_files_in_output_level;
 
-  // output information
-  compaction_job_stats_->total_output_bytes = stats.bytes_written;
-  compaction_job_stats_->num_output_records = compact_->num_output_records;
-  compaction_job_stats_->num_output_files = stats.num_output_files;
+    // output information
+    compaction_job_stats_->total_output_bytes = stats.bytes_written;
+    compaction_job_stats_->num_output_records = compact_->num_output_records;
+    compaction_job_stats_->num_output_files = stats.num_output_files;
 
-  if (stats.num_output_files > 0) {
-    CopyPrefix(compact_->SmallestUserKey(),
-               CompactionJobStats::kMaxPrefixLength,
-               &compaction_job_stats_->smallest_output_key_prefix);
-    CopyPrefix(compact_->LargestUserKey(), CompactionJobStats::kMaxPrefixLength,
-               &compaction_job_stats_->largest_output_key_prefix);
+    if (compact_->NumOutputFiles() > 0U) {
+      CopyPrefix(compact_->SmallestUserKey(),
+                 CompactionJobStats::kMaxPrefixLength,
+                 &compaction_job_stats_->smallest_output_key_prefix);
+      CopyPrefix(compact_->LargestUserKey(),
+                 CompactionJobStats::kMaxPrefixLength,
+                 &compaction_job_stats_->largest_output_key_prefix);
+    }
   }
 #else
   (void)stats;

db/compaction/compaction_job.h

@@ -68,8 +68,8 @@ class CompactionJob {
       const std::atomic<bool>* shutting_down,
       const SequenceNumber preserve_deletes_seqnum, LogBuffer* log_buffer,
       FSDirectory* db_directory, FSDirectory* output_directory,
-      FSDirectory* blob_output_directory, Statistics* stats,
-      InstrumentedMutex* db_mutex, ErrorHandler* db_error_handler,
+      Statistics* stats, InstrumentedMutex* db_mutex,
+      ErrorHandler* db_error_handler,
       std::vector<SequenceNumber> existing_snapshots,
       SequenceNumber earliest_write_conflict_snapshot,
       const SnapshotChecker* snapshot_checker,
@@ -78,8 +78,7 @@ class CompactionJob {
       const std::string& dbname, CompactionJobStats* compaction_job_stats,
       Env::Priority thread_pri, const std::shared_ptr<IOTracer>& io_tracer,
       const std::atomic<int>* manual_compaction_paused = nullptr,
-      const std::string& db_id = "", const std::string& db_session_id = "",
-      std::string full_history_ts_low = "");
+      const std::string& db_id = "", const std::string& db_session_id = "");
 
   ~CompactionJob();
 
@@ -170,7 +169,6 @@ class CompactionJob {
   LogBuffer* log_buffer_;
   FSDirectory* db_directory_;
   FSDirectory* output_directory_;
-  FSDirectory* blob_output_directory_;
   Statistics* stats_;
   InstrumentedMutex* db_mutex_;
   ErrorHandler* db_error_handler_;
@@ -202,7 +200,6 @@ class CompactionJob {
   Env::WriteLifeTimeHint write_hint_;
   Env::Priority thread_pri_;
   IOStatus io_status_;
-  std::string full_history_ts_low_;
 };
 
 }  // namespace ROCKSDB_NAMESPACE

db/compaction/compaction_job_stats_test.cc

@@ -24,6 +24,7 @@
 #include "db/write_batch_internal.h"
 #include "env/mock_env.h"
 #include "file/filename.h"
+#include "logging/logging.h"
 #include "memtable/hash_linklist_rep.h"
 #include "monitoring/statistics.h"
 #include "monitoring/thread_status_util.h"
@@ -458,7 +459,6 @@ class CompactionJobStatsChecker : public EventListener {
     ASSERT_EQ(current_stats.num_output_files,
         stats.num_output_files);
 
-    ASSERT_EQ(current_stats.is_full_compaction, stats.is_full_compaction);
     ASSERT_EQ(current_stats.is_manual_compaction,
         stats.is_manual_compaction);
 
@@ -571,7 +571,7 @@ CompactionJobStats NewManualCompactionJobStats(
     uint64_t num_input_records, size_t key_size, size_t value_size,
     size_t num_output_files, uint64_t num_output_records,
     double compression_ratio, uint64_t num_records_replaced,
-    bool is_full = false, bool is_manual = true) {
+    bool is_manual = true) {
   CompactionJobStats stats;
   stats.Reset();
 
@@ -595,7 +595,6 @@ CompactionJobStats NewManualCompactionJobStats(
   stats.total_input_raw_value_bytes =
       num_input_records * value_size;
 
-  stats.is_full_compaction = is_full;
   stats.is_manual_compaction = is_manual;
 
   stats.num_records_replaced = num_records_replaced;
@@ -797,7 +796,7 @@ TEST_P(CompactionJobStatsTest, CompactionJobStatsTest) {
     }
 
     ASSERT_OK(Flush(1));
-    ASSERT_OK(static_cast_with_check<DBImpl>(db_)->TEST_WaitForCompact());
+    static_cast_with_check<DBImpl>(db_)->TEST_WaitForCompact();
 
     stats_checker->set_verify_next_comp_io_stats(true);
     std::atomic<bool> first_prepare_write(true);
@@ -895,7 +894,7 @@ TEST_P(CompactionJobStatsTest, DeletionStatsTest) {
   CompactRangeOptions cr_options;
   cr_options.change_level = true;
   cr_options.target_level = 2;
-  ASSERT_OK(db_->CompactRange(cr_options, handles_[1], nullptr, nullptr));
+  db_->CompactRange(cr_options, handles_[1], nullptr, nullptr);
   ASSERT_GT(NumTableFilesAtLevel(2, 1), 0);
 
   // Stage 2: Generate files including keys from the entire key range
@@ -982,21 +981,26 @@ TEST_P(CompactionJobStatsTest, UniversalCompactionTest) {
     if (num_input_units == 0) {
       continue;
     }
-    // A full compaction only happens when the number of flushes equals to
-    // the number of compaction input runs.
-    bool is_full = num_flushes == num_input_units;
     // The following statement determines the expected smallest key
-    // based on whether it is a full compaction.
-    uint64_t smallest_key = is_full ? key_base : key_base * (num_flushes - 1);
+    // based on whether it is a full compaction.  A full compaction only
+    // happens when the number of flushes equals to the number of compaction
+    // input runs.
+    uint64_t smallest_key =
+        (num_flushes == num_input_units) ?
+            key_base : key_base * (num_flushes - 1);
 
-    stats_checker->AddExpectedStats(NewManualCompactionJobStats(
-        Key(smallest_key, 10),
-        Key(smallest_key + key_base * num_input_units - key_interval, 10),
-        num_input_units, num_input_units > 2 ? num_input_units / 2 : 0,
-        num_keys_per_table * num_input_units, kKeySize, kValueSize,
-        num_input_units, num_keys_per_table * num_input_units, 1.0, 0, is_full,
-        false));
-    ASSERT_OK(dbfull()->TEST_WaitForCompact());
+    stats_checker->AddExpectedStats(
+        NewManualCompactionJobStats(
+            Key(smallest_key, 10),
+            Key(smallest_key + key_base * num_input_units - key_interval, 10),
+            num_input_units,
+            num_input_units > 2 ? num_input_units / 2 : 0,
+            num_keys_per_table * num_input_units,
+            kKeySize, kValueSize,
+            num_input_units,
+            num_keys_per_table * num_input_units,
+            1.0, 0, false));
+    dbfull()->TEST_WaitForCompact();
   }
   ASSERT_EQ(stats_checker->NumberOfUnverifiedStats(), 3U);
 
@@ -1007,7 +1011,7 @@ TEST_P(CompactionJobStatsTest, UniversalCompactionTest) {
         &rnd, start_key, start_key + key_base - 1,
         kKeySize, kValueSize, key_interval,
         compression_ratio, 1);
-    ASSERT_OK(static_cast_with_check<DBImpl>(db_)->TEST_WaitForCompact());
+    static_cast_with_check<DBImpl>(db_)->TEST_WaitForCompact();
   }
   ASSERT_EQ(stats_checker->NumberOfUnverifiedStats(), 0U);
 }

db/compaction/compaction_job_test.cc

@@ -67,14 +67,13 @@ void VerifyInitializationOfCompactionJobStats(
 
 }  // namespace
 
-class CompactionJobTestBase : public testing::Test {
- protected:
-  CompactionJobTestBase(std::string dbname, const Comparator* ucmp,
-                        std::function<std::string(uint64_t)> encode_u64_ts)
+// TODO(icanadi) Make it simpler once we mock out VersionSet
+class CompactionJobTest : public testing::Test {
+ public:
+  CompactionJobTest()
       : env_(Env::Default()),
         fs_(std::make_shared<LegacyFileSystemWrapper>(env_)),
-        dbname_(std::move(dbname)),
-        ucmp_(ucmp),
+        dbname_(test::PerThreadDBPath("compaction_job_test")),
         db_options_(),
         mutable_cf_options_(cf_options_),
         mutable_db_options_(),
@@ -87,17 +86,12 @@ class CompactionJobTestBase : public testing::Test {
         shutting_down_(false),
         preserve_deletes_seqnum_(0),
         mock_table_factory_(new mock::MockTableFactory()),
-        error_handler_(nullptr, db_options_, &mutex_),
-        encode_u64_ts_(std::move(encode_u64_ts)) {}
-
-  void SetUp() override {
+        error_handler_(nullptr, db_options_, &mutex_) {
     EXPECT_OK(env_->CreateDirIfMissing(dbname_));
     db_options_.env = env_;
     db_options_.fs = fs_;
     db_options_.db_paths.emplace_back(dbname_,
                                       std::numeric_limits<uint64_t>::max());
-    cf_options_.comparator = ucmp_;
-    cf_options_.table_factory = mock_table_factory_;
   }
 
   std::string GenerateFileName(uint64_t file_number) {
@@ -108,10 +102,9 @@ class CompactionJobTestBase : public testing::Test {
     return TableFileName(db_paths, meta.fd.GetNumber(), meta.fd.GetPathId());
   }
 
-  std::string KeyStr(const std::string& user_key, const SequenceNumber seq_num,
-                     const ValueType t, uint64_t ts = 0) {
-    std::string user_key_with_ts = user_key + encode_u64_ts_(ts);
-    return InternalKey(user_key_with_ts, seq_num, t).Encode().ToString();
+  static std::string KeyStr(const std::string& user_key,
+                            const SequenceNumber seq_num, const ValueType t) {
+    return InternalKey(user_key, seq_num, t).Encode().ToString();
   }
 
   static std::string BlobStr(uint64_t blob_file_number, uint64_t offset,
@@ -137,7 +130,7 @@ class CompactionJobTestBase : public testing::Test {
     return blob_index;
   }
 
-  void AddMockFile(const mock::KVVector& contents, int level = 0) {
+  void AddMockFile(const stl_wrappers::KVMap& contents, int level = 0) {
     assert(contents.size() > 0);
 
     bool first_key = true;
@@ -151,8 +144,7 @@ class CompactionJobTestBase : public testing::Test {
       std::string skey;
       std::string value;
       std::tie(skey, value) = kv;
-      const Status pik_status =
-          ParseInternalKey(skey, &key, true /* log_err_key */);
+      bool parsed = ParseInternalKey(skey, &key);
 
       smallest_seqno = std::min(smallest_seqno, key.sequence);
       largest_seqno = std::max(largest_seqno, key.sequence);
@@ -170,7 +162,7 @@ class CompactionJobTestBase : public testing::Test {
 
       first_key = false;
 
-      if (pik_status.ok() && key.type == kTypeBlobIndex) {
+      if (parsed && key.type == kTypeBlobIndex) {
         BlobIndex blob_index;
         const Status s = blob_index.DecodeFrom(value);
         if (!s.ok()) {
@@ -200,9 +192,8 @@ class CompactionJobTestBase : public testing::Test {
                  kUnknownFileChecksum, kUnknownFileChecksumFuncName);
 
     mutex_.Lock();
-    EXPECT_OK(
-        versions_->LogAndApply(versions_->GetColumnFamilySet()->GetDefault(),
-                               mutable_cf_options_, &edit, &mutex_));
+    versions_->LogAndApply(versions_->GetColumnFamilySet()->GetDefault(),
+                           mutable_cf_options_, &edit, &mutex_);
     mutex_.Unlock();
   }
 
@@ -213,11 +204,11 @@ class CompactionJobTestBase : public testing::Test {
   }
 
   // returns expected result after compaction
-  mock::KVVector CreateTwoFiles(bool gen_corrupted_keys) {
-    stl_wrappers::KVMap expected_results;
-    constexpr int kKeysPerFile = 10000;
-    constexpr int kCorruptKeysPerFile = 200;
-    constexpr int kMatchingKeys = kKeysPerFile / 2;
+  stl_wrappers::KVMap CreateTwoFiles(bool gen_corrupted_keys) {
+    auto expected_results = mock::MakeMockFile();
+    const int kKeysPerFile = 10000;
+    const int kCorruptKeysPerFile = 200;
+    const int kMatchingKeys = kKeysPerFile / 2;
     SequenceNumber sequence_number = 0;
 
     auto corrupt_id = [&](int id) {
@@ -240,29 +231,23 @@ class CompactionJobTestBase : public testing::Test {
           test::CorruptKeyType(&internal_key);
           test::CorruptKeyType(&bottommost_internal_key);
         }
-        contents.push_back({internal_key.Encode().ToString(), value});
+        contents.insert({ internal_key.Encode().ToString(), value });
         if (i == 1 || k < kMatchingKeys || corrupt_id(k - kMatchingKeys)) {
           expected_results.insert(
-              {bottommost_internal_key.Encode().ToString(), value});
+              { bottommost_internal_key.Encode().ToString(), value });
         }
       }
-      mock::SortKVVector(&contents, ucmp_);
 
       AddMockFile(contents);
     }
 
     SetLastSequence(sequence_number);
 
-    mock::KVVector expected_results_kvvector;
-    for (auto& kv : expected_results) {
-      expected_results_kvvector.push_back({kv.first, kv.second});
-    }
-
-    return expected_results_kvvector;
+    return expected_results;
   }
 
   void NewDB() {
-    EXPECT_OK(DestroyDB(dbname_, Options()));
+    DestroyDB(dbname_, Options());
     EXPECT_OK(env_->CreateDirIfMissing(dbname_));
     versions_.reset(
         new VersionSet(dbname_, &db_options_, env_options_, table_cache_.get(),
@@ -272,6 +257,12 @@ class CompactionJobTestBase : public testing::Test {
     SetIdentityFile(env_, dbname_);
 
     VersionEdit new_db;
+    if (db_options_.write_dbid_to_manifest) {
+      DBImpl* impl = new DBImpl(DBOptions(), dbname_);
+      std::string db_id;
+      impl->GetDbIdentityFromIdentityFile(&db_id);
+      new_db.SetDBId(db_id);
+    }
     new_db.SetLogNumber(0);
     new_db.SetNextFile(2);
     new_db.SetLastSequence(0);
@@ -293,20 +284,19 @@ class CompactionJobTestBase : public testing::Test {
     // Make "CURRENT" file that points to the new manifest file.
     s = SetCurrentFile(fs_.get(), dbname_, 1, nullptr);
 
-    ASSERT_OK(s);
-
+    std::vector<ColumnFamilyDescriptor> column_families;
+    cf_options_.table_factory = mock_table_factory_;
     cf_options_.merge_operator = merge_op_;
     cf_options_.compaction_filter = compaction_filter_.get();
-    std::vector<ColumnFamilyDescriptor> column_families;
     column_families.emplace_back(kDefaultColumnFamilyName, cf_options_);
 
-    ASSERT_OK(versions_->Recover(column_families, false));
+    EXPECT_OK(versions_->Recover(column_families, false));
     cfd_ = versions_->GetColumnFamilySet()->GetDefault();
   }
 
   void RunCompaction(
       const std::vector<std::vector<FileMetaData*>>& input_files,
-      const mock::KVVector& expected_results,
+      const stl_wrappers::KVMap& expected_results,
       const std::vector<SequenceNumber>& snapshots = {},
       SequenceNumber earliest_write_conflict_snapshot = kMaxSequenceNumber,
       int output_level = 1, bool verify = true,
@@ -338,27 +328,22 @@ class CompactionJobTestBase : public testing::Test {
     EventLogger event_logger(db_options_.info_log.get());
     // TODO(yiwu) add a mock snapshot checker and add test for it.
     SnapshotChecker* snapshot_checker = nullptr;
-    ASSERT_TRUE(full_history_ts_low_.empty() ||
-                ucmp_->timestamp_size() == full_history_ts_low_.size());
     CompactionJob compaction_job(
         0, &compaction, db_options_, env_options_, versions_.get(),
         &shutting_down_, preserve_deletes_seqnum_, &log_buffer, nullptr,
-        nullptr, nullptr, nullptr, &mutex_, &error_handler_, snapshots,
+        nullptr, nullptr, &mutex_, &error_handler_, snapshots,
         earliest_write_conflict_snapshot, snapshot_checker, table_cache_,
         &event_logger, false, false, dbname_, &compaction_job_stats_,
-        Env::Priority::USER, nullptr /* IOTracer */,
-        /*manual_compaction_paused=*/nullptr, /*db_id=*/"",
-        /*db_session_id=*/"", full_history_ts_low_);
+        Env::Priority::USER, nullptr /* IOTracer */);
     VerifyInitializationOfCompactionJobStats(compaction_job_stats_);
 
     compaction_job.Prepare();
     mutex_.Unlock();
-    Status s = compaction_job.Run();
+    Status s;
+    s = compaction_job.Run();
     ASSERT_OK(s);
-    ASSERT_OK(compaction_job.io_status());
     mutex_.Lock();
     ASSERT_OK(compaction_job.Install(*cfd->GetLatestMutableCFOptions()));
-    ASSERT_OK(compaction_job.io_status());
     mutex_.Unlock();
 
     if (verify) {
@@ -383,7 +368,6 @@ class CompactionJobTestBase : public testing::Test {
   Env* env_;
   std::shared_ptr<FileSystem> fs_;
   std::string dbname_;
-  const Comparator* const ucmp_;
   EnvOptions env_options_;
   ImmutableDBOptions db_options_;
   ColumnFamilyOptions cf_options_;
@@ -402,17 +386,6 @@ class CompactionJobTestBase : public testing::Test {
   std::unique_ptr<CompactionFilter> compaction_filter_;
   std::shared_ptr<MergeOperator> merge_op_;
   ErrorHandler error_handler_;
-  std::string full_history_ts_low_;
-  const std::function<std::string(uint64_t)> encode_u64_ts_;
-};
-
-// TODO(icanadi) Make it simpler once we mock out VersionSet
-class CompactionJobTest : public CompactionJobTestBase {
- public:
-  CompactionJobTest()
-      : CompactionJobTestBase(test::PerThreadDBPath("compaction_job_test"),
-                              BytewiseComparator(),
-                              [](uint64_t /*ts*/) { return ""; }) {}
 };
 
 TEST_F(CompactionJobTest, Simple) {
@@ -666,7 +639,7 @@ TEST_F(CompactionJobTest, FilterAllMergeOperands) {
   SetLastSequence(11U);
   auto files = cfd_->current()->storage_info()->LevelFiles(0);
 
-  mock::KVVector empty_map;
+  stl_wrappers::KVMap empty_map;
   RunCompaction({files}, empty_map);
 }
 
@@ -1093,118 +1066,6 @@ TEST_F(CompactionJobTest, OldestBlobFileNumber) {
                 /* expected_oldest_blob_file_number */ 19);
 }
 
-class CompactionJobTimestampTest : public CompactionJobTestBase {
- public:
-  CompactionJobTimestampTest()
-      : CompactionJobTestBase(test::PerThreadDBPath("compaction_job_ts_test"),
-                              test::ComparatorWithU64Ts(), test::EncodeInt) {}
-};
-
-TEST_F(CompactionJobTimestampTest, GCDisabled) {
-  NewDB();
-
-  auto file1 =
-      mock::MakeMockFile({{KeyStr("a", 10, ValueType::kTypeValue, 100), "a10"},
-                          {KeyStr("a", 9, ValueType::kTypeValue, 99), "a9"},
-                          {KeyStr("b", 8, ValueType::kTypeValue, 98), "b8"}});
-  AddMockFile(file1);
-
-  auto file2 = mock::MakeMockFile(
-      {{KeyStr("b", 7, ValueType::kTypeDeletionWithTimestamp, 97), ""},
-       {KeyStr("c", 6, ValueType::kTypeDeletionWithTimestamp, 96), ""},
-       {KeyStr("c", 5, ValueType::kTypeValue, 95), "c5"}});
-  AddMockFile(file2);
-
-  SetLastSequence(10);
-
-  auto expected_results = mock::MakeMockFile(
-      {{KeyStr("a", 10, ValueType::kTypeValue, 100), "a10"},
-       {KeyStr("a", 9, ValueType::kTypeValue, 99), "a9"},
-       {KeyStr("b", 8, ValueType::kTypeValue, 98), "b8"},
-       {KeyStr("b", 7, ValueType::kTypeDeletionWithTimestamp, 97), ""},
-       {KeyStr("c", 6, ValueType::kTypeDeletionWithTimestamp, 96), ""},
-       {KeyStr("c", 5, ValueType::kTypeValue, 95), "c5"}});
-  const auto& files = cfd_->current()->storage_info()->LevelFiles(0);
-  RunCompaction({files}, expected_results);
-}
-
-TEST_F(CompactionJobTimestampTest, NoKeyExpired) {
-  NewDB();
-
-  auto file1 =
-      mock::MakeMockFile({{KeyStr("a", 6, ValueType::kTypeValue, 100), "a6"},
-                          {KeyStr("b", 7, ValueType::kTypeValue, 101), "b7"},
-                          {KeyStr("c", 5, ValueType::kTypeValue, 99), "c5"}});
-  AddMockFile(file1);
-
-  auto file2 =
-      mock::MakeMockFile({{KeyStr("a", 4, ValueType::kTypeValue, 98), "a4"},
-                          {KeyStr("c", 3, ValueType::kTypeValue, 97), "c3"}});
-  AddMockFile(file2);
-
-  SetLastSequence(101);
-
-  auto expected_results =
-      mock::MakeMockFile({{KeyStr("a", 6, ValueType::kTypeValue, 100), "a6"},
-                          {KeyStr("a", 4, ValueType::kTypeValue, 98), "a4"},
-                          {KeyStr("b", 7, ValueType::kTypeValue, 101), "b7"},
-                          {KeyStr("c", 5, ValueType::kTypeValue, 99), "c5"},
-                          {KeyStr("c", 3, ValueType::kTypeValue, 97), "c3"}});
-  const auto& files = cfd_->current()->storage_info()->LevelFiles(0);
-
-  full_history_ts_low_ = encode_u64_ts_(0);
-  RunCompaction({files}, expected_results);
-}
-
-TEST_F(CompactionJobTimestampTest, AllKeysExpired) {
-  NewDB();
-
-  auto file1 = mock::MakeMockFile(
-      {{KeyStr("a", 5, ValueType::kTypeDeletionWithTimestamp, 100), ""},
-       {KeyStr("b", 6, ValueType::kTypeValue, 99), "b6"}});
-  AddMockFile(file1);
-
-  auto file2 = mock::MakeMockFile(
-      {{KeyStr("a", 4, ValueType::kTypeValue, 98), "a4"},
-       {KeyStr("b", 3, ValueType::kTypeDeletionWithTimestamp, 97), ""},
-       {KeyStr("b", 2, ValueType::kTypeValue, 96), "b2"}});
-  AddMockFile(file2);
-
-  SetLastSequence(6);
-
-  auto expected_results =
-      mock::MakeMockFile({{KeyStr("b", 0, ValueType::kTypeValue, 0), "b6"}});
-  const auto& files = cfd_->current()->storage_info()->LevelFiles(0);
-
-  full_history_ts_low_ = encode_u64_ts_(std::numeric_limits<uint64_t>::max());
-  RunCompaction({files}, expected_results);
-}
-
-TEST_F(CompactionJobTimestampTest, SomeKeysExpired) {
-  NewDB();
-
-  auto file1 =
-      mock::MakeMockFile({{KeyStr("a", 5, ValueType::kTypeValue, 50), "a5"},
-                          {KeyStr("b", 6, ValueType::kTypeValue, 49), "b6"}});
-  AddMockFile(file1);
-
-  auto file2 = mock::MakeMockFile(
-      {{KeyStr("a", 3, ValueType::kTypeValue, 48), "a3"},
-       {KeyStr("a", 2, ValueType::kTypeValue, 46), "a2"},
-       {KeyStr("b", 4, ValueType::kTypeDeletionWithTimestamp, 47), ""}});
-  AddMockFile(file2);
-
-  SetLastSequence(6);
-
-  auto expected_results =
-      mock::MakeMockFile({{KeyStr("a", 5, ValueType::kTypeValue, 50), "a5"},
-                          {KeyStr("b", 6, ValueType::kTypeValue, 49), "b6"}});
-  const auto& files = cfd_->current()->storage_info()->LevelFiles(0);
-
-  full_history_ts_low_ = encode_u64_ts_(49);
-  RunCompaction({files}, expected_results);
-}
-
 }  // namespace ROCKSDB_NAMESPACE
 
 int main(int argc, char** argv) {

db/compaction/compaction_picker.cc

@@ -139,9 +139,11 @@ CompressionOptions GetCompressionOptions(const MutableCFOptions& cf_options,
   if (!enable_compression) {
     return cf_options.compression_opts;
   }
-  // If bottommost_compression_opts is enabled and we are compacting to the
-  // bottommost level then we should use the specified compression options.
-  if (level >= (vstorage->num_non_empty_levels() - 1) &&
+  // If bottommost_compression is set and we are compacting to the
+  // bottommost level then we should use the specified compression options
+  // for the bottmomost_compression.
+  if (cf_options.bottommost_compression != kDisableCompressionOption &&
+      level >= (vstorage->num_non_empty_levels() - 1) &&
       cf_options.bottommost_compression_opts.enabled) {
     return cf_options.bottommost_compression_opts;
   }
@@ -1043,8 +1045,6 @@ void CompactionPicker::RegisterCompaction(Compaction* c) {
     level0_compactions_in_progress_.insert(c);
   }
   compactions_in_progress_.insert(c);
-  TEST_SYNC_POINT_CALLBACK("CompactionPicker::RegisterCompaction:Registered",
-                           c);
 }
 
 void CompactionPicker::UnregisterCompaction(Compaction* c) {

db/compaction/compaction_picker_test.cc

@@ -12,6 +12,7 @@
 #include "db/compaction/compaction_picker_level.h"
 #include "db/compaction/compaction_picker_universal.h"
 
+#include "logging/logging.h"
 #include "test_util/testharness.h"
 #include "test_util/testutil.h"
 #include "util/string_util.h"

db/compaction/compaction_picker_universal.cc

@@ -461,6 +461,7 @@ Compaction* UniversalCompactionBuilder::PickCompaction() {
 
 // validate that all the chosen files of L0 are non overlapping in time
 #ifndef NDEBUG
+  SequenceNumber prev_smallest_seqno = 0U;
   bool is_first = true;
 
   size_t level_index = 0U;
@@ -470,6 +471,7 @@ Compaction* UniversalCompactionBuilder::PickCompaction() {
       if (is_first) {
         is_first = false;
       }
+      prev_smallest_seqno = f->fd.smallest_seqno;
     }
     level_index = 1U;
   }
@@ -481,7 +483,16 @@ Compaction* UniversalCompactionBuilder::PickCompaction() {
                               &largest_seqno);
       if (is_first) {
         is_first = false;
+      } else if (prev_smallest_seqno > 0) {
+        // A level is considered as the bottommost level if there are
+        // no files in higher levels or if files in higher levels do
+        // not overlap with the files being compacted. Sequence numbers
+        // of files in bottommost level can be set to 0 to help
+        // compression. As a result, the following assert may not hold
+        // if the prev_smallest_seqno is 0.
+        assert(prev_smallest_seqno > largest_seqno);
       }
+      prev_smallest_seqno = smallest_seqno;
     }
   }
 #endif
@@ -996,9 +1007,6 @@ Compaction* UniversalCompactionBuilder::PickCompactionToOldest(
       comp_reason_print_string = "size amp";
     } else {
       assert(false);
-      comp_reason_print_string = "unknown: ";
-      comp_reason_print_string.append(
-          std::to_string(static_cast<int>(compaction_reason)));
     }
 
     char file_num_buf[256];

db/comparator_db_test.cc

@@ -17,6 +17,7 @@
 #include "util/string_util.h"
 #include "utilities/merge_operators.h"
 
+using std::unique_ptr;
 
 namespace ROCKSDB_NAMESPACE {
 namespace {

db/corruption_test.cc

@@ -9,6 +9,7 @@
 
 #ifndef ROCKSDB_LITE
 
+#include <errno.h>
 #include <fcntl.h>
 #include <sys/stat.h>
 #include <sys/types.h>
@@ -32,13 +33,12 @@
 #include "table/mock_table.h"
 #include "test_util/testharness.h"
 #include "test_util/testutil.h"
-#include "util/cast_util.h"
 #include "util/random.h"
 #include "util/string_util.h"
 
 namespace ROCKSDB_NAMESPACE {
 
-static constexpr int kValueSize = 1000;
+static const int kValueSize = 1000;
 
 class CorruptionTest : public testing::Test {
  public:
@@ -56,8 +56,7 @@ class CorruptionTest : public testing::Test {
     options_.wal_recovery_mode = WALRecoveryMode::kTolerateCorruptedTailRecords;
     options_.env = &env_;
     dbname_ = test::PerThreadDBPath("corruption_test");
-    Status s = DestroyDB(dbname_, options_);
-    EXPECT_OK(s);
+    DestroyDB(dbname_, options_);
 
     db_ = nullptr;
     options_.create_if_missing = true;
@@ -69,16 +68,9 @@ class CorruptionTest : public testing::Test {
   }
 
   ~CorruptionTest() override {
-    SyncPoint::GetInstance()->DisableProcessing();
-    SyncPoint::GetInstance()->LoadDependency({});
-    SyncPoint::GetInstance()->ClearAllCallBacks();
     delete db_;
     db_ = nullptr;
-    if (getenv("KEEP_DB")) {
-      fprintf(stdout, "db is still at %s\n", dbname_.c_str());
-    } else {
-      EXPECT_OK(DestroyDB(dbname_, Options()));
-    }
+    DestroyDB(dbname_, Options());
   }
 
   void CloseDb() {
@@ -119,12 +111,12 @@ class CorruptionTest : public testing::Test {
     for (int i = 0; i < n; i++) {
       if (flush_every != 0 && i != 0 && i % flush_every == 0) {
         DBImpl* dbi = static_cast_with_check<DBImpl>(db_);
-        ASSERT_OK(dbi->TEST_FlushMemTable());
+        dbi->TEST_FlushMemTable();
       }
       //if ((i % 100) == 0) fprintf(stderr, "@ %d of %d\n", i, n);
       Slice key = Key(i + start, &key_space);
       batch.Clear();
-      ASSERT_OK(batch.Put(key, Value(i + start, &value_space)));
+      batch.Put(key, Value(i, &value_space));
       ASSERT_OK(db_->Write(WriteOptions(), &batch));
     }
   }
@@ -145,7 +137,6 @@ class CorruptionTest : public testing::Test {
     // occurred.
     Iterator* iter = db_->NewIterator(ReadOptions(false, true));
     for (iter->SeekToFirst(); iter->Valid(); iter->Next()) {
-      ASSERT_OK(iter->status());
       uint64_t key;
       Slice in(iter->key());
       if (!ConsumeDecimalNumber(&in, &key) ||
@@ -162,7 +153,6 @@ class CorruptionTest : public testing::Test {
         correct++;
       }
     }
-    iter->status().PermitUncheckedError();
     delete iter;
 
     fprintf(stderr,
@@ -191,7 +181,7 @@ class CorruptionTest : public testing::Test {
     }
     ASSERT_TRUE(!fname.empty()) << filetype;
 
-    ASSERT_OK(test::CorruptFile(&env_, fname, offset, bytes_to_corrupt));
+    test::CorruptFile(fname, offset, bytes_to_corrupt);
   }
 
   // corrupts exactly one file at level `level`. if no file found at level,
@@ -201,8 +191,7 @@ class CorruptionTest : public testing::Test {
     db_->GetLiveFilesMetaData(&metadata);
     for (const auto& m : metadata) {
       if (m.level == level) {
-        ASSERT_OK(test::CorruptFile(&env_, dbname_ + "/" + m.name, offset,
-                                    bytes_to_corrupt));
+        test::CorruptFile(dbname_ + "/" + m.name, offset, bytes_to_corrupt);
         return;
       }
     }
@@ -257,8 +246,8 @@ TEST_F(CorruptionTest, Recovery) {
   // is not available for WAL though.
   CloseDb();
 #endif
-  Corrupt(kWalFile, 19, 1);  // WriteBatch tag for first record
-  Corrupt(kWalFile, log::kBlockSize + 1000, 1);  // Somewhere in second block
+  Corrupt(kLogFile, 19, 1);      // WriteBatch tag for first record
+  Corrupt(kLogFile, log::kBlockSize + 1000, 1);  // Somewhere in second block
   ASSERT_TRUE(!TryReopen().ok());
   options_.paranoid_checks = false;
   Reopen(&options_);
@@ -283,7 +272,7 @@ TEST_F(CorruptionTest, NewFileErrorDuringWrite) {
   bool failed = false;
   for (int i = 0; i < num; i++) {
     WriteBatch batch;
-    ASSERT_OK(batch.Put("a", Value(100, &value_storage)));
+    batch.Put("a", Value(100, &value_storage));
     s = db_->Write(WriteOptions(), &batch);
     if (!s.ok()) {
       failed = true;
@@ -299,9 +288,9 @@ TEST_F(CorruptionTest, NewFileErrorDuringWrite) {
 TEST_F(CorruptionTest, TableFile) {
   Build(100);
   DBImpl* dbi = static_cast_with_check<DBImpl>(db_);
-  ASSERT_OK(dbi->TEST_FlushMemTable());
-  ASSERT_OK(dbi->TEST_CompactRange(0, nullptr, nullptr));
-  ASSERT_OK(dbi->TEST_CompactRange(1, nullptr, nullptr));
+  dbi->TEST_FlushMemTable();
+  dbi->TEST_CompactRange(0, nullptr, nullptr);
+  dbi->TEST_CompactRange(1, nullptr, nullptr);
 
   Corrupt(kTableFile, 100, 1);
   Check(99, 99);
@@ -322,9 +311,9 @@ TEST_F(CorruptionTest, VerifyChecksumReadahead) {
 
   Build(10000);
   DBImpl* dbi = static_cast_with_check<DBImpl>(db_);
-  ASSERT_OK(dbi->TEST_FlushMemTable());
-  ASSERT_OK(dbi->TEST_CompactRange(0, nullptr, nullptr));
-  ASSERT_OK(dbi->TEST_CompactRange(1, nullptr, nullptr));
+  dbi->TEST_FlushMemTable();
+  dbi->TEST_CompactRange(0, nullptr, nullptr);
+  dbi->TEST_CompactRange(1, nullptr, nullptr);
 
   senv.count_random_reads_ = true;
   senv.random_read_counter_.Reset();
@@ -369,7 +358,7 @@ TEST_F(CorruptionTest, TableFileIndexData) {
   // build 2 tables, flush at 5000
   Build(10000, 5000);
   DBImpl* dbi = static_cast_with_check<DBImpl>(db_);
-  ASSERT_OK(dbi->TEST_FlushMemTable());
+  dbi->TEST_FlushMemTable();
 
   // corrupt an index block of an entire file
   Corrupt(kTableFile, -2000, 500);
@@ -416,8 +405,8 @@ TEST_F(CorruptionTest, SequenceNumberRecovery) {
 TEST_F(CorruptionTest, CorruptedDescriptor) {
   ASSERT_OK(db_->Put(WriteOptions(), "foo", "hello"));
   DBImpl* dbi = static_cast_with_check<DBImpl>(db_);
-  ASSERT_OK(dbi->TEST_FlushMemTable());
-  ASSERT_OK(dbi->TEST_CompactRange(0, nullptr, nullptr));
+  dbi->TEST_FlushMemTable();
+  dbi->TEST_CompactRange(0, nullptr, nullptr);
 
   Corrupt(kDescriptorFile, 0, 1000);
   Status s = TryReopen();
@@ -435,9 +424,9 @@ TEST_F(CorruptionTest, CompactionInputError) {
   Reopen(&options);
   Build(10);
   DBImpl* dbi = static_cast_with_check<DBImpl>(db_);
-  ASSERT_OK(dbi->TEST_FlushMemTable());
-  ASSERT_OK(dbi->TEST_CompactRange(0, nullptr, nullptr));
-  ASSERT_OK(dbi->TEST_CompactRange(1, nullptr, nullptr));
+  dbi->TEST_FlushMemTable();
+  dbi->TEST_CompactRange(0, nullptr, nullptr);
+  dbi->TEST_CompactRange(1, nullptr, nullptr);
   ASSERT_EQ(1, Property("rocksdb.num-files-at-level2"));
 
   Corrupt(kTableFile, 100, 1);
@@ -460,12 +449,12 @@ TEST_F(CorruptionTest, CompactionInputErrorParanoid) {
 
   // Fill levels >= 1
   for (int level = 1; level < dbi->NumberLevels(); level++) {
-    ASSERT_OK(dbi->Put(WriteOptions(), "", "begin"));
-    ASSERT_OK(dbi->Put(WriteOptions(), "~", "end"));
-    ASSERT_OK(dbi->TEST_FlushMemTable());
+    dbi->Put(WriteOptions(), "", "begin");
+    dbi->Put(WriteOptions(), "~", "end");
+    dbi->TEST_FlushMemTable();
     for (int comp_level = 0; comp_level < dbi->NumberLevels() - level;
          ++comp_level) {
-      ASSERT_OK(dbi->TEST_CompactRange(comp_level, nullptr, nullptr));
+      dbi->TEST_CompactRange(comp_level, nullptr, nullptr);
     }
   }
 
@@ -473,8 +462,8 @@ TEST_F(CorruptionTest, CompactionInputErrorParanoid) {
 
   dbi = static_cast_with_check<DBImpl>(db_);
   Build(10);
-  ASSERT_OK(dbi->TEST_FlushMemTable());
-  ASSERT_OK(dbi->TEST_WaitForCompact());
+  dbi->TEST_FlushMemTable();
+  dbi->TEST_WaitForCompact();
   ASSERT_EQ(1, Property("rocksdb.num-files-at-level0"));
 
   CorruptTableFileAtLevel(0, 100, 1);
@@ -499,7 +488,7 @@ TEST_F(CorruptionTest, CompactionInputErrorParanoid) {
 TEST_F(CorruptionTest, UnrelatedKeys) {
   Build(10);
   DBImpl* dbi = static_cast_with_check<DBImpl>(db_);
-  ASSERT_OK(dbi->TEST_FlushMemTable());
+  dbi->TEST_FlushMemTable();
   Corrupt(kTableFile, 100, 1);
   ASSERT_NOK(dbi->VerifyChecksum());
 
@@ -508,7 +497,7 @@ TEST_F(CorruptionTest, UnrelatedKeys) {
   std::string v;
   ASSERT_OK(db_->Get(ReadOptions(), Key(1000, &tmp1), &v));
   ASSERT_EQ(Value(1000, &tmp2).ToString(), v);
-  ASSERT_OK(dbi->TEST_FlushMemTable());
+  dbi->TEST_FlushMemTable();
   ASSERT_OK(db_->Get(ReadOptions(), Key(1000, &tmp1), &v));
   ASSERT_EQ(Value(1000, &tmp2).ToString(), v);
 }
@@ -537,8 +526,7 @@ TEST_F(CorruptionTest, RangeDeletionCorrupted) {
       ImmutableCFOptions(options_), kRangeDelBlock, &range_del_handle));
 
   ASSERT_OK(TryReopen());
-  ASSERT_OK(test::CorruptFile(&env_, filename,
-                              static_cast<int>(range_del_handle.offset()), 1));
+  test::CorruptFile(filename, static_cast<int>(range_del_handle.offset()), 1);
   ASSERT_TRUE(TryReopen().IsCorruption());
 }
 
@@ -553,7 +541,7 @@ TEST_F(CorruptionTest, FileSystemStateCorrupted) {
     DBImpl* dbi = static_cast_with_check<DBImpl>(db_);
     std::vector<LiveFileMetaData> metadata;
     dbi->GetLiveFilesMetaData(&metadata);
-    ASSERT_GT(metadata.size(), 0);
+    ASSERT_GT(metadata.size(), size_t(0));
     std::string filename = dbname_ + metadata[0].name;
 
     delete db_;
@@ -562,28 +550,26 @@ TEST_F(CorruptionTest, FileSystemStateCorrupted) {
     if (iter == 0) {  // corrupt file size
       std::unique_ptr<WritableFile> file;
       env_.NewWritableFile(filename, &file, EnvOptions());
-      ASSERT_OK(file->Append(Slice("corrupted sst")));
+      file->Append(Slice("corrupted sst"));
       file.reset();
       Status x = TryReopen(&options);
       ASSERT_TRUE(x.IsCorruption());
     } else {  // delete the file
-      ASSERT_OK(env_.DeleteFile(filename));
+      env_.DeleteFile(filename);
       Status x = TryReopen(&options);
-      ASSERT_TRUE(x.IsCorruption());
+      ASSERT_TRUE(x.IsPathNotFound());
     }
 
-    ASSERT_OK(DestroyDB(dbname_, options_));
+    DestroyDB(dbname_, options_);
   }
 }
 
-static const auto& corruption_modes = {
-    mock::MockTableFactory::kCorruptNone, mock::MockTableFactory::kCorruptKey,
-    mock::MockTableFactory::kCorruptValue,
-    mock::MockTableFactory::kCorruptReorderKey};
+static const auto& corruption_modes = {mock::MockTableFactory::kCorruptNone,
+                                       mock::MockTableFactory::kCorruptKey,
+                                       mock::MockTableFactory::kCorruptValue};
 
 TEST_F(CorruptionTest, ParanoidFileChecksOnFlush) {
   Options options;
-  options.check_flush_compaction_key_order = false;
   options.paranoid_file_checks = true;
   options.create_if_missing = true;
   Status s;
@@ -591,7 +577,6 @@ TEST_F(CorruptionTest, ParanoidFileChecksOnFlush) {
     delete db_;
     db_ = nullptr;
     s = DestroyDB(dbname_, options);
-    ASSERT_OK(s);
     std::shared_ptr<mock::MockTableFactory> mock =
         std::make_shared<mock::MockTableFactory>();
     options.table_factory = mock;
@@ -612,7 +597,6 @@ TEST_F(CorruptionTest, ParanoidFileChecksOnCompact) {
   Options options;
   options.paranoid_file_checks = true;
   options.create_if_missing = true;
-  options.check_flush_compaction_key_order = false;
   Status s;
   for (const auto& mode : corruption_modes) {
     delete db_;
@@ -639,7 +623,6 @@ TEST_F(CorruptionTest, ParanoidFileChecksOnCompact) {
 
 TEST_F(CorruptionTest, ParanoidFileChecksWithDeleteRangeFirst) {
   Options options;
-  options.check_flush_compaction_key_order = false;
   options.paranoid_file_checks = true;
   options.create_if_missing = true;
   for (bool do_flush : {true, false}) {
@@ -671,7 +654,6 @@ TEST_F(CorruptionTest, ParanoidFileChecksWithDeleteRangeFirst) {
 
 TEST_F(CorruptionTest, ParanoidFileChecksWithDeleteRange) {
   Options options;
-  options.check_flush_compaction_key_order = false;
   options.paranoid_file_checks = true;
   options.create_if_missing = true;
   for (bool do_flush : {true, false}) {
@@ -706,7 +688,6 @@ TEST_F(CorruptionTest, ParanoidFileChecksWithDeleteRange) {
 
 TEST_F(CorruptionTest, ParanoidFileChecksWithDeleteRangeLast) {
   Options options;
-  options.check_flush_compaction_key_order = false;
   options.paranoid_file_checks = true;
   options.create_if_missing = true;
   for (bool do_flush : {true, false}) {
@@ -736,138 +717,6 @@ TEST_F(CorruptionTest, ParanoidFileChecksWithDeleteRangeLast) {
   }
 }
 
-TEST_F(CorruptionTest, LogCorruptionErrorsInCompactionIterator) {
-  Options options;
-  options.create_if_missing = true;
-  options.allow_data_in_errors = true;
-  auto mode = mock::MockTableFactory::kCorruptKey;
-  delete db_;
-  db_ = nullptr;
-  ASSERT_OK(DestroyDB(dbname_, options));
-
-  std::shared_ptr<mock::MockTableFactory> mock =
-      std::make_shared<mock::MockTableFactory>();
-  mock->SetCorruptionMode(mode);
-  options.table_factory = mock;
-
-  ASSERT_OK(DB::Open(options, dbname_, &db_));
-  assert(db_ != nullptr);
-  Build(100, 2);
-
-  DBImpl* dbi = static_cast_with_check<DBImpl>(db_);
-  ASSERT_OK(dbi->TEST_FlushMemTable());
-  Status s = dbi->TEST_CompactRange(0, nullptr, nullptr, nullptr, true);
-  ASSERT_NOK(s);
-  ASSERT_TRUE(s.IsCorruption());
-}
-
-TEST_F(CorruptionTest, CompactionKeyOrderCheck) {
-  Options options;
-  options.paranoid_file_checks = false;
-  options.create_if_missing = true;
-  options.check_flush_compaction_key_order = false;
-  delete db_;
-  db_ = nullptr;
-  ASSERT_OK(DestroyDB(dbname_, options));
-  std::shared_ptr<mock::MockTableFactory> mock =
-      std::make_shared<mock::MockTableFactory>();
-  options.table_factory = mock;
-  ASSERT_OK(DB::Open(options, dbname_, &db_));
-  assert(db_ != nullptr);
-  mock->SetCorruptionMode(mock::MockTableFactory::kCorruptReorderKey);
-  Build(100, 2);
-  DBImpl* dbi = static_cast_with_check<DBImpl>(db_);
-  ASSERT_OK(dbi->TEST_FlushMemTable());
-
-  mock->SetCorruptionMode(mock::MockTableFactory::kCorruptNone);
-  ASSERT_OK(db_->SetOptions({{"check_flush_compaction_key_order", "true"}}));
-  ASSERT_NOK(dbi->TEST_CompactRange(0, nullptr, nullptr, nullptr, true));
-}
-
-TEST_F(CorruptionTest, FlushKeyOrderCheck) {
-  Options options;
-  options.paranoid_file_checks = false;
-  options.create_if_missing = true;
-  ASSERT_OK(db_->SetOptions({{"check_flush_compaction_key_order", "true"}}));
-
-  ASSERT_OK(db_->Put(WriteOptions(), "foo1", "v1"));
-  ASSERT_OK(db_->Put(WriteOptions(), "foo2", "v1"));
-  ASSERT_OK(db_->Put(WriteOptions(), "foo3", "v1"));
-  ASSERT_OK(db_->Put(WriteOptions(), "foo4", "v1"));
-
-  int cnt = 0;
-  // Generate some out of order keys from the memtable
-  SyncPoint::GetInstance()->SetCallBack(
-      "MemTableIterator::Next:0", [&](void* arg) {
-        MemTableRep::Iterator* mem_iter =
-            static_cast<MemTableRep::Iterator*>(arg);
-        if (++cnt == 3) {
-          mem_iter->Prev();
-          mem_iter->Prev();
-        }
-      });
-  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->EnableProcessing();
-  Status s = static_cast_with_check<DBImpl>(db_)->TEST_FlushMemTable();
-  ASSERT_NOK(s);
-  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->DisableProcessing();
-  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->ClearAllCallBacks();
-}
-
-TEST_F(CorruptionTest, DisableKeyOrderCheck) {
-  Options options;
-  ASSERT_OK(db_->SetOptions({{"check_flush_compaction_key_order", "false"}}));
-  DBImpl* dbi = static_cast_with_check<DBImpl>(db_);
-
-  SyncPoint::GetInstance()->SetCallBack(
-      "OutputValidator::Add:order_check",
-      [&](void* /*arg*/) { ASSERT_TRUE(false); });
-  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->EnableProcessing();
-  ASSERT_OK(db_->Put(WriteOptions(), "foo1", "v1"));
-  ASSERT_OK(db_->Put(WriteOptions(), "foo3", "v1"));
-  ASSERT_OK(dbi->TEST_FlushMemTable());
-  ASSERT_OK(db_->Put(WriteOptions(), "foo2", "v1"));
-  ASSERT_OK(db_->Put(WriteOptions(), "foo4", "v1"));
-  ASSERT_OK(dbi->TEST_FlushMemTable());
-  ASSERT_OK(dbi->TEST_CompactRange(0, nullptr, nullptr, nullptr, true));
-  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->DisableProcessing();
-  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->ClearAllCallBacks();
-}
-
-TEST_F(CorruptionTest, VerifyWholeTableChecksum) {
-  CloseDb();
-  Options options;
-  options.env = &env_;
-  ASSERT_OK(DestroyDB(dbname_, options));
-  options.create_if_missing = true;
-  options.file_checksum_gen_factory =
-      ROCKSDB_NAMESPACE::GetFileChecksumGenCrc32cFactory();
-  Reopen(&options);
-
-  Build(10, 5);
-
-  ASSERT_OK(db_->VerifyFileChecksums(ReadOptions()));
-  CloseDb();
-
-  // Corrupt the first byte of each table file, this must be data block.
-  Corrupt(kTableFile, 0, 1);
-
-  ASSERT_OK(TryReopen(&options));
-
-  SyncPoint::GetInstance()->DisableProcessing();
-  SyncPoint::GetInstance()->ClearAllCallBacks();
-  int count{0};
-  SyncPoint::GetInstance()->SetCallBack(
-      "DBImpl::VerifySstFileChecksum:mismatch", [&](void* arg) {
-        auto* s = reinterpret_cast<Status*>(arg);
-        assert(s);
-        ++count;
-        ASSERT_NOK(*s);
-      });
-  SyncPoint::GetInstance()->EnableProcessing();
-  ASSERT_TRUE(db_->VerifyFileChecksums(ReadOptions()).IsCorruption());
-  ASSERT_EQ(1, count);
-}
-
 }  // namespace ROCKSDB_NAMESPACE
 
 int main(int argc, char** argv) {

db/cuckoo_table_db_test.cc

@@ -63,15 +63,6 @@ class CuckooTableDBTest : public testing::Test {
     ASSERT_OK(DB::Open(opts, dbname_, &db_));
   }
 
-  void DestroyAndReopen(Options* options) {
-    assert(options);
-    ASSERT_OK(db_->Close());
-    delete db_;
-    db_ = nullptr;
-    ASSERT_OK(DestroyDB(dbname_, *options));
-    Reopen(options);
-  }
-
   Status Put(const Slice& k, const Slice& v) {
     return db_->Put(WriteOptions(), k, v);
   }
@@ -214,7 +205,7 @@ static std::string Uint64Key(uint64_t i) {
 TEST_F(CuckooTableDBTest, Uint64Comparator) {
   Options options = CurrentOptions();
   options.comparator = test::Uint64Comparator();
-  DestroyAndReopen(&options);
+  Reopen(&options);
 
   ASSERT_OK(Put(Uint64Key(1), "v1"));
   ASSERT_OK(Put(Uint64Key(2), "v2"));

db/db_basic_test.cc

@@ -12,7 +12,6 @@
 
 #include "db/db_test_util.h"
 #include "port/stack_trace.h"
-#include "rocksdb/flush_block_policy.h"
 #include "rocksdb/merge_operator.h"
 #include "rocksdb/perf_context.h"
 #include "rocksdb/utilities/debug.h"
@@ -30,15 +29,15 @@ namespace ROCKSDB_NAMESPACE {
 
 class DBBasicTest : public DBTestBase {
  public:
-  DBBasicTest() : DBTestBase("/db_basic_test", /*env_do_fsync=*/false) {}
+  DBBasicTest() : DBTestBase("/db_basic_test", /*env_do_fsync=*/true) {}
 };
 
 TEST_F(DBBasicTest, OpenWhenOpen) {
   Options options = CurrentOptions();
   options.env = env_;
-  DB* db2 = nullptr;
-  Status s = DB::Open(options, dbname_, &db2);
-  ASSERT_NOK(s);
+  ROCKSDB_NAMESPACE::DB* db2 = nullptr;
+  ROCKSDB_NAMESPACE::Status s = DB::Open(options, dbname_, &db2);
+
   ASSERT_EQ(Status::Code::kIOError, s.code());
   ASSERT_EQ(Status::SubCode::kNone, s.subcode());
   ASSERT_TRUE(strstr(s.getState(), "lock ") != nullptr);
@@ -50,13 +49,13 @@ TEST_F(DBBasicTest, UniqueSession) {
   Options options = CurrentOptions();
   std::string sid1, sid2, sid3, sid4;
 
-  ASSERT_OK(db_->GetDbSessionId(sid1));
+  db_->GetDbSessionId(sid1);
   Reopen(options);
-  ASSERT_OK(db_->GetDbSessionId(sid2));
+  db_->GetDbSessionId(sid2);
   ASSERT_OK(Put("foo", "v1"));
-  ASSERT_OK(db_->GetDbSessionId(sid4));
+  db_->GetDbSessionId(sid4);
   Reopen(options);
-  ASSERT_OK(db_->GetDbSessionId(sid3));
+  db_->GetDbSessionId(sid3);
 
   ASSERT_NE(sid1, sid2);
   ASSERT_NE(sid1, sid3);
@@ -74,14 +73,14 @@ TEST_F(DBBasicTest, UniqueSession) {
 #ifndef ROCKSDB_LITE
   Close();
   ASSERT_OK(ReadOnlyReopen(options));
-  ASSERT_OK(db_->GetDbSessionId(sid1));
+  db_->GetDbSessionId(sid1);
   // Test uniqueness between readonly open (sid1) and regular open (sid3)
   ASSERT_NE(sid1, sid3);
   Close();
   ASSERT_OK(ReadOnlyReopen(options));
-  ASSERT_OK(db_->GetDbSessionId(sid2));
+  db_->GetDbSessionId(sid2);
   ASSERT_EQ("v1", Get("foo"));
-  ASSERT_OK(db_->GetDbSessionId(sid3));
+  db_->GetDbSessionId(sid3);
 
   ASSERT_NE(sid1, sid2);
 
@@ -89,13 +88,13 @@ TEST_F(DBBasicTest, UniqueSession) {
 #endif  // ROCKSDB_LITE
 
   CreateAndReopenWithCF({"goku"}, options);
-  ASSERT_OK(db_->GetDbSessionId(sid1));
+  db_->GetDbSessionId(sid1);
   ASSERT_OK(Put("bar", "e1"));
-  ASSERT_OK(db_->GetDbSessionId(sid2));
+  db_->GetDbSessionId(sid2);
   ASSERT_EQ("e1", Get("bar"));
-  ASSERT_OK(db_->GetDbSessionId(sid3));
+  db_->GetDbSessionId(sid3);
   ReopenWithColumnFamilies({"default", "goku"}, options);
-  ASSERT_OK(db_->GetDbSessionId(sid4));
+  db_->GetDbSessionId(sid4);
 
   ASSERT_EQ(sid1, sid2);
   ASSERT_EQ(sid2, sid3);
@@ -164,7 +163,7 @@ TEST_F(DBBasicTest, ReadOnlyDBWithWriteDBIdToManifestSet) {
   assert(options.env == env_);
   ASSERT_OK(ReadOnlyReopen(options));
   std::string db_id1;
-  ASSERT_OK(db_->GetDbIdentity(db_id1));
+  db_->GetDbIdentity(db_id1);
   ASSERT_EQ("v3", Get("foo"));
   ASSERT_EQ("v2", Get("bar"));
   Iterator* iter = db_->NewIterator(ReadOptions());
@@ -187,7 +186,7 @@ TEST_F(DBBasicTest, ReadOnlyDBWithWriteDBIdToManifestSet) {
   ASSERT_EQ("v2", Get("bar"));
   ASSERT_TRUE(db_->SyncWAL().IsNotSupported());
   std::string db_id2;
-  ASSERT_OK(db_->GetDbIdentity(db_id2));
+  db_->GetDbIdentity(db_id2);
   ASSERT_EQ(db_id1, db_id2);
 }
 
@@ -242,7 +241,7 @@ TEST_F(DBBasicTest, CompactedDB) {
   ASSERT_OK(Put("hhh", DummyString(kFileSize / 2, 'h')));
   ASSERT_OK(Put("iii", DummyString(kFileSize / 2, 'i')));
   ASSERT_OK(Put("jjj", DummyString(kFileSize / 2, 'j')));
-  ASSERT_OK(db_->CompactRange(CompactRangeOptions(), nullptr, nullptr));
+  db_->CompactRange(CompactRangeOptions(), nullptr, nullptr);
   ASSERT_EQ(3, NumTableFilesAtLevel(1));
   Close();
 
@@ -300,8 +299,8 @@ TEST_F(DBBasicTest, LevelLimitReopen) {
   int i = 0;
   while (NumTableFilesAtLevel(2, 1) == 0) {
     ASSERT_OK(Put(1, Key(i++), value));
-    ASSERT_OK(dbfull()->TEST_WaitForFlushMemTable());
-    ASSERT_OK(dbfull()->TEST_WaitForCompact());
+    dbfull()->TEST_WaitForFlushMemTable();
+    dbfull()->TEST_WaitForCompact();
   }
 
   options.num_levels = 1;
@@ -355,8 +354,8 @@ TEST_F(DBBasicTest, EmptyFlush) {
     options.disable_auto_compactions = true;
     CreateAndReopenWithCF({"pikachu"}, options);
 
-    ASSERT_OK(Put(1, "a", Slice()));
-    ASSERT_OK(SingleDelete(1, "a"));
+    Put(1, "a", Slice());
+    SingleDelete(1, "a");
     ASSERT_OK(Flush(1));
 
     ASSERT_EQ("[ ]", AllEntriesFor("a", 1));
@@ -410,7 +409,8 @@ TEST_F(DBBasicTest, CheckLock) {
     Status s = DB::Open(options, dbname_, &localdb);
     ASSERT_NOK(s);
 #ifdef OS_LINUX
-    ASSERT_TRUE(s.ToString().find("lock ") != std::string::npos);
+    ASSERT_TRUE(s.ToString().find("lock hold by current process") !=
+                std::string::npos);
 #endif  // OS_LINUX
   } while (ChangeCompactOptions());
 }
@@ -605,16 +605,16 @@ TEST_F(DBBasicTest, Snapshot) {
   options_override.skip_policy = kSkipNoSnapshot;
   do {
     CreateAndReopenWithCF({"pikachu"}, CurrentOptions(options_override));
-    ASSERT_OK(Put(0, "foo", "0v1"));
-    ASSERT_OK(Put(1, "foo", "1v1"));
+    Put(0, "foo", "0v1");
+    Put(1, "foo", "1v1");
 
     const Snapshot* s1 = db_->GetSnapshot();
     ASSERT_EQ(1U, GetNumSnapshots());
     uint64_t time_snap1 = GetTimeOldestSnapshots();
     ASSERT_GT(time_snap1, 0U);
     ASSERT_EQ(GetSequenceOldestSnapshots(), s1->GetSequenceNumber());
-    ASSERT_OK(Put(0, "foo", "0v2"));
-    ASSERT_OK(Put(1, "foo", "1v2"));
+    Put(0, "foo", "0v2");
+    Put(1, "foo", "1v2");
 
     env_->MockSleepForSeconds(1);
 
@@ -622,8 +622,8 @@ TEST_F(DBBasicTest, Snapshot) {
     ASSERT_EQ(2U, GetNumSnapshots());
     ASSERT_EQ(time_snap1, GetTimeOldestSnapshots());
     ASSERT_EQ(GetSequenceOldestSnapshots(), s1->GetSequenceNumber());
-    ASSERT_OK(Put(0, "foo", "0v3"));
-    ASSERT_OK(Put(1, "foo", "1v3"));
+    Put(0, "foo", "0v3");
+    Put(1, "foo", "1v3");
 
     {
       ManagedSnapshot s3(db_);
@@ -631,8 +631,8 @@ TEST_F(DBBasicTest, Snapshot) {
       ASSERT_EQ(time_snap1, GetTimeOldestSnapshots());
       ASSERT_EQ(GetSequenceOldestSnapshots(), s1->GetSequenceNumber());
 
-      ASSERT_OK(Put(0, "foo", "0v4"));
-      ASSERT_OK(Put(1, "foo", "1v4"));
+      Put(0, "foo", "0v4");
+      Put(1, "foo", "1v4");
       ASSERT_EQ("0v1", Get(0, "foo", s1));
       ASSERT_EQ("1v1", Get(1, "foo", s1));
       ASSERT_EQ("0v2", Get(0, "foo", s2));
@@ -698,14 +698,14 @@ TEST_P(DBBasicMultiConfigs, CompactBetweenSnapshots) {
   Random rnd(301);
   FillLevels("a", "z", 1);
 
-  ASSERT_OK(Put(1, "foo", "first"));
+  Put(1, "foo", "first");
   const Snapshot* snapshot1 = db_->GetSnapshot();
-  ASSERT_OK(Put(1, "foo", "second"));
-  ASSERT_OK(Put(1, "foo", "third"));
-  ASSERT_OK(Put(1, "foo", "fourth"));
+  Put(1, "foo", "second");
+  Put(1, "foo", "third");
+  Put(1, "foo", "fourth");
   const Snapshot* snapshot2 = db_->GetSnapshot();
-  ASSERT_OK(Put(1, "foo", "fifth"));
-  ASSERT_OK(Put(1, "foo", "sixth"));
+  Put(1, "foo", "fifth");
+  Put(1, "foo", "sixth");
 
   // All entries (including duplicates) exist
   // before any compaction or flush is triggered.
@@ -723,8 +723,7 @@ TEST_P(DBBasicMultiConfigs, CompactBetweenSnapshots) {
   // after we release the snapshot1, only two values left
   db_->ReleaseSnapshot(snapshot1);
   FillLevels("a", "z", 1);
-  ASSERT_OK(dbfull()->CompactRange(CompactRangeOptions(), handles_[1], nullptr,
-                                   nullptr));
+  dbfull()->CompactRange(CompactRangeOptions(), handles_[1], nullptr, nullptr);
 
   // We have only one valid snapshot snapshot2. Since snapshot1 is
   // not valid anymore, "first" should be removed by a compaction.
@@ -735,8 +734,7 @@ TEST_P(DBBasicMultiConfigs, CompactBetweenSnapshots) {
   // after we release the snapshot2, only one value should be left
   db_->ReleaseSnapshot(snapshot2);
   FillLevels("a", "z", 1);
-  ASSERT_OK(dbfull()->CompactRange(CompactRangeOptions(), handles_[1], nullptr,
-                                   nullptr));
+  dbfull()->CompactRange(CompactRangeOptions(), handles_[1], nullptr, nullptr);
   ASSERT_EQ("sixth", Get(1, "foo"));
   ASSERT_EQ(AllEntriesFor("foo", 1), "[ sixth ]");
 }
@@ -792,18 +790,18 @@ TEST_F(DBBasicTest, CompactOnFlush) {
     options.disable_auto_compactions = true;
     CreateAndReopenWithCF({"pikachu"}, options);
 
-    ASSERT_OK(Put(1, "foo", "v1"));
+    Put(1, "foo", "v1");
     ASSERT_OK(Flush(1));
     ASSERT_EQ(AllEntriesFor("foo", 1), "[ v1 ]");
 
     // Write two new keys
-    ASSERT_OK(Put(1, "a", "begin"));
-    ASSERT_OK(Put(1, "z", "end"));
-    ASSERT_OK(Flush(1));
+    Put(1, "a", "begin");
+    Put(1, "z", "end");
+    Flush(1);
 
     // Case1: Delete followed by a put
-    ASSERT_OK(Delete(1, "foo"));
-    ASSERT_OK(Put(1, "foo", "v2"));
+    Delete(1, "foo");
+    Put(1, "foo", "v2");
     ASSERT_EQ(AllEntriesFor("foo", 1), "[ v2, DEL, v1 ]");
 
     // After the current memtable is flushed, the DEL should
@@ -811,66 +809,66 @@ TEST_F(DBBasicTest, CompactOnFlush) {
     ASSERT_OK(Flush(1));
     ASSERT_EQ(AllEntriesFor("foo", 1), "[ v2, v1 ]");
 
-    ASSERT_OK(dbfull()->CompactRange(CompactRangeOptions(), handles_[1],
-                                     nullptr, nullptr));
+    dbfull()->CompactRange(CompactRangeOptions(), handles_[1], nullptr,
+                           nullptr);
     ASSERT_EQ(AllEntriesFor("foo", 1), "[ v2 ]");
 
     // Case 2: Delete followed by another delete
-    ASSERT_OK(Delete(1, "foo"));
-    ASSERT_OK(Delete(1, "foo"));
+    Delete(1, "foo");
+    Delete(1, "foo");
     ASSERT_EQ(AllEntriesFor("foo", 1), "[ DEL, DEL, v2 ]");
     ASSERT_OK(Flush(1));
     ASSERT_EQ(AllEntriesFor("foo", 1), "[ DEL, v2 ]");
-    ASSERT_OK(dbfull()->CompactRange(CompactRangeOptions(), handles_[1],
-                                     nullptr, nullptr));
+    dbfull()->CompactRange(CompactRangeOptions(), handles_[1], nullptr,
+                           nullptr);
     ASSERT_EQ(AllEntriesFor("foo", 1), "[ ]");
 
     // Case 3: Put followed by a delete
-    ASSERT_OK(Put(1, "foo", "v3"));
-    ASSERT_OK(Delete(1, "foo"));
+    Put(1, "foo", "v3");
+    Delete(1, "foo");
     ASSERT_EQ(AllEntriesFor("foo", 1), "[ DEL, v3 ]");
     ASSERT_OK(Flush(1));
     ASSERT_EQ(AllEntriesFor("foo", 1), "[ DEL ]");
-    ASSERT_OK(dbfull()->CompactRange(CompactRangeOptions(), handles_[1],
-                                     nullptr, nullptr));
+    dbfull()->CompactRange(CompactRangeOptions(), handles_[1], nullptr,
+                           nullptr);
     ASSERT_EQ(AllEntriesFor("foo", 1), "[ ]");
 
     // Case 4: Put followed by another Put
-    ASSERT_OK(Put(1, "foo", "v4"));
-    ASSERT_OK(Put(1, "foo", "v5"));
+    Put(1, "foo", "v4");
+    Put(1, "foo", "v5");
     ASSERT_EQ(AllEntriesFor("foo", 1), "[ v5, v4 ]");
     ASSERT_OK(Flush(1));
     ASSERT_EQ(AllEntriesFor("foo", 1), "[ v5 ]");
-    ASSERT_OK(dbfull()->CompactRange(CompactRangeOptions(), handles_[1],
-                                     nullptr, nullptr));
+    dbfull()->CompactRange(CompactRangeOptions(), handles_[1], nullptr,
+                           nullptr);
     ASSERT_EQ(AllEntriesFor("foo", 1), "[ v5 ]");
 
     // clear database
-    ASSERT_OK(Delete(1, "foo"));
-    ASSERT_OK(dbfull()->CompactRange(CompactRangeOptions(), handles_[1],
-                                     nullptr, nullptr));
+    Delete(1, "foo");
+    dbfull()->CompactRange(CompactRangeOptions(), handles_[1], nullptr,
+                           nullptr);
     ASSERT_EQ(AllEntriesFor("foo", 1), "[ ]");
 
     // Case 5: Put followed by snapshot followed by another Put
     // Both puts should remain.
-    ASSERT_OK(Put(1, "foo", "v6"));
+    Put(1, "foo", "v6");
     const Snapshot* snapshot = db_->GetSnapshot();
-    ASSERT_OK(Put(1, "foo", "v7"));
+    Put(1, "foo", "v7");
     ASSERT_OK(Flush(1));
     ASSERT_EQ(AllEntriesFor("foo", 1), "[ v7, v6 ]");
     db_->ReleaseSnapshot(snapshot);
 
     // clear database
-    ASSERT_OK(Delete(1, "foo"));
-    ASSERT_OK(dbfull()->CompactRange(CompactRangeOptions(), handles_[1],
-                                     nullptr, nullptr));
+    Delete(1, "foo");
+    dbfull()->CompactRange(CompactRangeOptions(), handles_[1], nullptr,
+                           nullptr);
     ASSERT_EQ(AllEntriesFor("foo", 1), "[ ]");
 
     // Case 5: snapshot followed by a put followed by another Put
     // Only the last put should remain.
     const Snapshot* snapshot1 = db_->GetSnapshot();
-    ASSERT_OK(Put(1, "foo", "v8"));
-    ASSERT_OK(Put(1, "foo", "v9"));
+    Put(1, "foo", "v8");
+    Put(1, "foo", "v9");
     ASSERT_OK(Flush(1));
     ASSERT_EQ(AllEntriesFor("foo", 1), "[ v9 ]");
     db_->ReleaseSnapshot(snapshot1);
@@ -893,7 +891,7 @@ TEST_F(DBBasicTest, FlushOneColumnFamily) {
   ASSERT_OK(Put(7, "popovich", "popovich"));
 
   for (int i = 0; i < 8; ++i) {
-    ASSERT_OK(Flush(i));
+    Flush(i);
     auto tables = ListTableFiles(env_, dbname_);
     ASSERT_EQ(tables.size(), i + 1U);
   }
@@ -1035,7 +1033,7 @@ class TestEnv : public EnvWrapper {
     explicit TestLogger(TestEnv* env_ptr) : Logger() { env = env_ptr; }
     ~TestLogger() override {
       if (!closed_) {
-        CloseHelper().PermitUncheckedError();
+        CloseHelper();
       }
     }
     void Logv(const char* /*format*/, va_list /*ap*/) override {}
@@ -1871,96 +1869,6 @@ TEST_F(DBBasicTest, MultiGetBatchedValueSizeMultiLevelMerge) {
   }
 }
 
-TEST_F(DBBasicTest, MultiGetStats) {
-  Options options;
-  options.create_if_missing = true;
-  options.disable_auto_compactions = true;
-  options.env = env_;
-  options.statistics = ROCKSDB_NAMESPACE::CreateDBStatistics();
-  BlockBasedTableOptions table_options;
-  table_options.block_size = 1;
-  table_options.index_type =
-      BlockBasedTableOptions::IndexType::kTwoLevelIndexSearch;
-  table_options.partition_filters = true;
-  table_options.no_block_cache = true;
-  table_options.cache_index_and_filter_blocks = false;
-  table_options.filter_policy.reset(NewBloomFilterPolicy(10, false));
-  options.table_factory.reset(NewBlockBasedTableFactory(table_options));
-  CreateAndReopenWithCF({"pikachu"}, options);
-
-  int total_keys = 2000;
-  std::vector<std::string> keys_str(total_keys);
-  std::vector<Slice> keys(total_keys);
-  std::vector<PinnableSlice> values(total_keys);
-  std::vector<Status> s(total_keys);
-  ReadOptions read_opts;
-
-  Random rnd(309);
-  // Create Multiple SST files at multiple levels.
-  for (int i = 0; i < 500; ++i) {
-    keys_str[i] = "k" + std::to_string(i);
-    keys[i] = Slice(keys_str[i]);
-    ASSERT_OK(Put(1, "k" + std::to_string(i), rnd.RandomString(1000)));
-    if (i % 100 == 0) {
-      Flush(1);
-    }
-  }
-  Flush(1);
-  MoveFilesToLevel(2, 1);
-
-  for (int i = 501; i < 1000; ++i) {
-    keys_str[i] = "k" + std::to_string(i);
-    keys[i] = Slice(keys_str[i]);
-    ASSERT_OK(Put(1, "k" + std::to_string(i), rnd.RandomString(1000)));
-    if (i % 100 == 0) {
-      Flush(1);
-    }
-  }
-
-  Flush(1);
-  MoveFilesToLevel(2, 1);
-
-  for (int i = 1001; i < total_keys; ++i) {
-    keys_str[i] = "k" + std::to_string(i);
-    keys[i] = Slice(keys_str[i]);
-    ASSERT_OK(Put(1, "k" + std::to_string(i), rnd.RandomString(1000)));
-    if (i % 100 == 0) {
-      Flush(1);
-    }
-  }
-  Flush(1);
-  Close();
-
-  ReopenWithColumnFamilies({"default", "pikachu"}, options);
-  ASSERT_OK(options.statistics->Reset());
-
-  db_->MultiGet(read_opts, handles_[1], total_keys, keys.data(), values.data(),
-                s.data(), false);
-
-  ASSERT_EQ(values.size(), total_keys);
-  HistogramData hist_data_blocks;
-  HistogramData hist_index_and_filter_blocks;
-  HistogramData hist_sst;
-
-  options.statistics->histogramData(NUM_DATA_BLOCKS_READ_PER_LEVEL,
-                                    &hist_data_blocks);
-  options.statistics->histogramData(NUM_INDEX_AND_FILTER_BLOCKS_READ_PER_LEVEL,
-                                    &hist_index_and_filter_blocks);
-  options.statistics->histogramData(NUM_SST_READ_PER_LEVEL, &hist_sst);
-
-  // Maximum number of blocks read from a file system in a level.
-  ASSERT_GT(hist_data_blocks.max, 0);
-  ASSERT_GT(hist_index_and_filter_blocks.max, 0);
-  // Maximum number of sst files read from file system in a level.
-  ASSERT_GT(hist_sst.max, 0);
-
-  // Minimun number of blocks read in a level.
-  ASSERT_EQ(hist_data_blocks.min, 0);
-  ASSERT_GT(hist_index_and_filter_blocks.min, 0);
-  // Minimun number of sst files read in a level.
-  ASSERT_GT(hist_sst.max, 0);
-}
-
 // Test class for batched MultiGet with prefix extractor
 // Param bool - If true, use partitioned filters
 //              If false, use full filter block
@@ -2169,7 +2077,7 @@ TEST_F(DBBasicTest, MultiGetIOBufferOverrun) {
   table_options.block_size = 16 * 1024;
   ASSERT_TRUE(table_options.block_size >
             BlockBasedTable::kMultiGetReadStackBufSize);
-  options.table_factory.reset(NewBlockBasedTableFactory(table_options));
+  options.table_factory.reset(new BlockBasedTableFactory(table_options));
   Reopen(options);
 
   std::string zero_str(128, '\0');
@@ -2279,43 +2187,6 @@ class TableFileListener : public EventListener {
 };
 }  // namespace
 
-TEST_F(DBBasicTest, LastSstFileNotInManifest) {
-  // If the last sst file is not tracked in MANIFEST,
-  // or the VersionEdit for the last sst file is not synced,
-  // on recovery, the last sst file should be deleted,
-  // and new sst files shouldn't reuse its file number.
-  Options options = CurrentOptions();
-  DestroyAndReopen(options);
-  Close();
-
-  // Manually add a sst file.
-  constexpr uint64_t kSstFileNumber = 100;
-  const std::string kSstFile = MakeTableFileName(dbname_, kSstFileNumber);
-  ASSERT_OK(WriteStringToFile(env_, /* data = */ "bad sst file content",
-                              /* fname = */ kSstFile,
-                              /* should_sync = */ true));
-  ASSERT_OK(env_->FileExists(kSstFile));
-
-  TableFileListener* listener = new TableFileListener();
-  options.listeners.emplace_back(listener);
-  Reopen(options);
-  // kSstFile should already be deleted.
-  ASSERT_TRUE(env_->FileExists(kSstFile).IsNotFound());
-
-  ASSERT_OK(Put("k", "v"));
-  ASSERT_OK(Flush());
-  // New sst file should have file number > kSstFileNumber.
-  std::vector<std::string>& files =
-      listener->GetFiles(kDefaultColumnFamilyName);
-  ASSERT_EQ(files.size(), 1);
-  const std::string fname = files[0].erase(0, (dbname_ + "/").size());
-  uint64_t number = 0;
-  FileType type = kTableFile;
-  ASSERT_TRUE(ParseFileName(fname, &number, &type));
-  ASSERT_EQ(type, kTableFile);
-  ASSERT_GT(number, kSstFileNumber);
-}
-
 TEST_F(DBBasicTest, RecoverWithMissingFiles) {
   Options options = CurrentOptions();
   DestroyAndReopen(options);
@@ -2360,14 +2231,12 @@ TEST_F(DBBasicTest, RecoverWithMissingFiles) {
     std::unique_ptr<Iterator> iter(db_->NewIterator(read_opts, handles_[0]));
     iter->SeekToFirst();
     ASSERT_FALSE(iter->Valid());
-    ASSERT_OK(iter->status());
     iter.reset(db_->NewIterator(read_opts, handles_[1]));
     iter->SeekToFirst();
     ASSERT_TRUE(iter->Valid());
     ASSERT_EQ("a", iter->key());
     iter->Next();
     ASSERT_FALSE(iter->Valid());
-    ASSERT_OK(iter->status());
     iter.reset(db_->NewIterator(read_opts, handles_[2]));
     iter->SeekToFirst();
     ASSERT_TRUE(iter->Valid());
@@ -2377,7 +2246,6 @@ TEST_F(DBBasicTest, RecoverWithMissingFiles) {
     ASSERT_EQ("b", iter->key());
     iter->Next();
     ASSERT_FALSE(iter->Valid());
-    ASSERT_OK(iter->status());
   }
 }
 
@@ -2443,7 +2311,7 @@ TEST_F(DBBasicTest, RecoverWithNoManifest) {
     ASSERT_OK(env_->GetChildren(dbname_, &files));
     for (const auto& file : files) {
       uint64_t number = 0;
-      FileType type = kWalFile;
+      FileType type = kLogFile;
       if (ParseFileName(file, &number, &type) && type == kDescriptorFile) {
         ASSERT_OK(env_->DeleteFile(dbname_ + "/" + file));
       }
@@ -2490,14 +2358,12 @@ TEST_F(DBBasicTest, SkipWALIfMissingTableFiles) {
   std::unique_ptr<Iterator> iter(db_->NewIterator(read_opts, handles_[0]));
   iter->SeekToFirst();
   ASSERT_FALSE(iter->Valid());
-  ASSERT_OK(iter->status());
   iter.reset(db_->NewIterator(read_opts, handles_[1]));
   iter->SeekToFirst();
   ASSERT_TRUE(iter->Valid());
   ASSERT_EQ("a", iter->key());
   iter->Next();
   ASSERT_FALSE(iter->Valid());
-  ASSERT_OK(iter->status());
 }
 #endif  // !ROCKSDB_LITE
 
@@ -2533,7 +2399,7 @@ class DBBasicTestMultiGet : public DBTestBase {
   DBBasicTestMultiGet(std::string test_dir, int num_cfs, bool compressed_cache,
                       bool uncompressed_cache, bool _compression_enabled,
                       bool _fill_cache, uint32_t compression_parallel_threads)
-      : DBTestBase(test_dir, /*env_do_fsync=*/false) {
+      : DBTestBase(test_dir, /*env_do_fsync=*/true) {
     compression_enabled_ = _compression_enabled;
     fill_cache_ = _fill_cache;
 
@@ -2587,13 +2453,12 @@ class DBBasicTestMultiGet : public DBTestBase {
     table_options.block_cache_compressed = compressed_cache_;
     table_options.flush_block_policy_factory.reset(
         new MyFlushBlockPolicyFactory());
-    options.table_factory.reset(NewBlockBasedTableFactory(table_options));
+    options.table_factory.reset(new BlockBasedTableFactory(table_options));
     if (!compression_enabled_) {
       options.compression = kNoCompression;
     } else {
       options.compression_opts.parallel_threads = compression_parallel_threads;
     }
-    options_ = options;
     Reopen(options);
 
     if (num_cfs > 1) {
@@ -2663,7 +2528,6 @@ class DBBasicTestMultiGet : public DBTestBase {
   bool compression_enabled() { return compression_enabled_; }
   bool has_compressed_cache() { return compressed_cache_ != nullptr; }
   bool has_uncompressed_cache() { return uncompressed_cache_ != nullptr; }
-  Options get_options() { return options_; }
 
   static void SetUpTestCase() {}
   static void TearDownTestCase() {}
@@ -2749,7 +2613,6 @@ class DBBasicTestMultiGet : public DBTestBase {
 
   std::shared_ptr<MyBlockCache> compressed_cache_;
   std::shared_ptr<MyBlockCache> uncompressed_cache_;
-  Options options_;
   bool compression_enabled_;
   std::vector<std::string> values_;
   std::vector<std::string> uncompressable_values_;
@@ -2892,123 +2755,6 @@ TEST_P(DBBasicTestWithParallelIO, MultiGet) {
   }
 }
 
-#ifndef ROCKSDB_LITE
-TEST_P(DBBasicTestWithParallelIO, MultiGetDirectIO) {
-  class FakeDirectIOEnv : public EnvWrapper {
-    class FakeDirectIOSequentialFile;
-    class FakeDirectIORandomAccessFile;
-
-   public:
-    FakeDirectIOEnv(Env* env) : EnvWrapper(env) {}
-
-    Status NewRandomAccessFile(const std::string& fname,
-                               std::unique_ptr<RandomAccessFile>* result,
-                               const EnvOptions& options) override {
-      std::unique_ptr<RandomAccessFile> file;
-      assert(options.use_direct_reads);
-      EnvOptions opts = options;
-      opts.use_direct_reads = false;
-      Status s = target()->NewRandomAccessFile(fname, &file, opts);
-      if (!s.ok()) {
-        return s;
-      }
-      result->reset(new FakeDirectIORandomAccessFile(std::move(file)));
-      return s;
-    }
-
-   private:
-    class FakeDirectIOSequentialFile : public SequentialFileWrapper {
-     public:
-      FakeDirectIOSequentialFile(std::unique_ptr<SequentialFile>&& file)
-          : SequentialFileWrapper(file.get()), file_(std::move(file)) {}
-      ~FakeDirectIOSequentialFile() {}
-
-      bool use_direct_io() const override { return true; }
-      size_t GetRequiredBufferAlignment() const override { return 1; }
-
-     private:
-      std::unique_ptr<SequentialFile> file_;
-    };
-
-    class FakeDirectIORandomAccessFile : public RandomAccessFileWrapper {
-     public:
-      FakeDirectIORandomAccessFile(std::unique_ptr<RandomAccessFile>&& file)
-          : RandomAccessFileWrapper(file.get()), file_(std::move(file)) {}
-      ~FakeDirectIORandomAccessFile() {}
-
-      bool use_direct_io() const override { return true; }
-      size_t GetRequiredBufferAlignment() const override { return 1; }
-
-     private:
-      std::unique_ptr<RandomAccessFile> file_;
-    };
-  };
-
-  std::unique_ptr<FakeDirectIOEnv> env(new FakeDirectIOEnv(env_));
-  Options opts = get_options();
-  opts.env = env.get();
-  opts.use_direct_reads = true;
-  Reopen(opts);
-
-  std::vector<std::string> key_data(10);
-  std::vector<Slice> keys;
-  // We cannot resize a PinnableSlice vector, so just set initial size to
-  // largest we think we will need
-  std::vector<PinnableSlice> values(10);
-  std::vector<Status> statuses;
-  ReadOptions ro;
-  ro.fill_cache = fill_cache();
-
-  // Warm up the cache first
-  key_data.emplace_back(Key(0));
-  keys.emplace_back(Slice(key_data.back()));
-  key_data.emplace_back(Key(50));
-  keys.emplace_back(Slice(key_data.back()));
-  statuses.resize(keys.size());
-
-  dbfull()->MultiGet(ro, dbfull()->DefaultColumnFamily(), keys.size(),
-                     keys.data(), values.data(), statuses.data(), true);
-  ASSERT_TRUE(CheckValue(0, values[0].ToString()));
-  ASSERT_TRUE(CheckValue(50, values[1].ToString()));
-
-  int random_reads = env_->random_read_counter_.Read();
-  key_data[0] = Key(1);
-  key_data[1] = Key(51);
-  keys[0] = Slice(key_data[0]);
-  keys[1] = Slice(key_data[1]);
-  values[0].Reset();
-  values[1].Reset();
-  if (uncompressed_cache_) {
-    uncompressed_cache_->SetCapacity(0);
-    uncompressed_cache_->SetCapacity(1048576);
-  }
-  dbfull()->MultiGet(ro, dbfull()->DefaultColumnFamily(), keys.size(),
-                     keys.data(), values.data(), statuses.data(), true);
-  ASSERT_TRUE(CheckValue(1, values[0].ToString()));
-  ASSERT_TRUE(CheckValue(51, values[1].ToString()));
-
-  bool read_from_cache = false;
-  if (fill_cache()) {
-    if (has_uncompressed_cache()) {
-      read_from_cache = true;
-    } else if (has_compressed_cache() && compression_enabled()) {
-      read_from_cache = true;
-    }
-  }
-
-  int expected_reads = random_reads;
-  if (!compression_enabled() || !has_compressed_cache()) {
-    expected_reads += 2;
-  } else {
-    expected_reads += (read_from_cache ? 0 : 2);
-  }
-  if (env_->random_read_counter_.Read() != expected_reads) {
-    ASSERT_EQ(env_->random_read_counter_.Read(), expected_reads);
-  }
-  Close();
-}
-#endif  // ROCKSDB_LITE
-
 TEST_P(DBBasicTestWithParallelIO, MultiGetWithChecksumMismatch) {
   std::vector<std::string> key_data(10);
   std::vector<Slice> keys;
@@ -3134,7 +2880,7 @@ class DeadlineFS : public FileSystemWrapper {
   // or to simply delay but return success anyway. The latter mimics the
   // behavior of PosixFileSystem, which does not enforce any timeout
   explicit DeadlineFS(SpecialEnv* env, bool error_on_delay)
-      : FileSystemWrapper(env->GetFileSystem()),
+      : FileSystemWrapper(FileSystem::Default()),
         deadline_(std::chrono::microseconds::zero()),
         io_timeout_(std::chrono::microseconds::zero()),
         env_(env),
@@ -3147,8 +2893,9 @@ class DeadlineFS : public FileSystemWrapper {
                                std::unique_ptr<FSRandomAccessFile>* result,
                                IODebugContext* dbg) override {
     std::unique_ptr<FSRandomAccessFile> file;
-    IOStatus s = target()->NewRandomAccessFile(fname, opts, &file, dbg);
-    EXPECT_OK(s);
+    IOStatus s;
+
+    s = target()->NewRandomAccessFile(fname, opts, &file, dbg);
     result->reset(new DeadlineRandomAccessFile(*this, file));
 
     const std::chrono::microseconds deadline = GetDeadline();
@@ -3309,7 +3056,7 @@ TEST_F(DBBasicTestMultiGetDeadline, MultiGetDeadlineExceeded) {
   std::shared_ptr<Cache> cache = NewLRUCache(1048576);
   BlockBasedTableOptions table_options;
   table_options.block_cache = cache;
-  options.table_factory.reset(NewBlockBasedTableFactory(table_options));
+  options.table_factory.reset(new BlockBasedTableFactory(table_options));
   options.env = env.get();
   SetTimeElapseOnlySleepOnReopen(&options);
   ReopenWithColumnFamilies(GetCFNames(), options);
@@ -3461,28 +3208,6 @@ TEST_F(DBBasicTest, ManifestWriteFailure) {
   Reopen(options);
 }
 
-#ifndef ROCKSDB_LITE
-TEST_F(DBBasicTest, VerifyFileChecksums) {
-  Options options = GetDefaultOptions();
-  options.create_if_missing = true;
-  options.env = env_;
-  DestroyAndReopen(options);
-  ASSERT_OK(Put("a", "value"));
-  ASSERT_OK(Flush());
-  ASSERT_TRUE(db_->VerifyFileChecksums(ReadOptions()).IsInvalidArgument());
-
-  options.file_checksum_gen_factory = GetFileChecksumGenCrc32cFactory();
-  Reopen(options);
-  ASSERT_OK(db_->VerifyFileChecksums(ReadOptions()));
-
-  // Write an L0 with checksum computed.
-  ASSERT_OK(Put("b", "value"));
-  ASSERT_OK(Flush());
-
-  ASSERT_OK(db_->VerifyFileChecksums(ReadOptions()));
-}
-#endif  // !ROCKSDB_LITE
-
 // A test class for intercepting random reads and injecting artificial
 // delays. Used for testing the deadline/timeout feature
 class DBBasicTestDeadline
@@ -3533,15 +3258,18 @@ TEST_P(DBBasicTestDeadline, PointLookupDeadline) {
     SetTimeElapseOnlySleepOnReopen(&options);
     Reopen(options);
 
-    if (options.table_factory) {
-      block_cache = options.table_factory->GetOptions<Cache>(
-          TableFactory::kBlockCacheOpts());
+    if (options.table_factory &&
+        !strcmp(options.table_factory->Name(),
+                BlockBasedTableFactory::kName.c_str())) {
+      BlockBasedTableFactory* bbtf =
+          static_cast<BlockBasedTableFactory*>(options.table_factory.get());
+      block_cache = bbtf->table_options().block_cache.get();
     }
 
     Random rnd(301);
     for (int i = 0; i < 400; ++i) {
       std::string key = "k" + ToString(i);
-      ASSERT_OK(Put(key, rnd.RandomString(100)));
+      Put(key, rnd.RandomString(100));
     }
     Flush();
 
@@ -3616,17 +3344,20 @@ TEST_P(DBBasicTestDeadline, IteratorDeadline) {
     SetTimeElapseOnlySleepOnReopen(&options);
     Reopen(options);
 
-    if (options.table_factory) {
-      block_cache = options.table_factory->GetOptions<Cache>(
-          TableFactory::kBlockCacheOpts());
+    if (options.table_factory &&
+        !strcmp(options.table_factory->Name(),
+                BlockBasedTableFactory::kName.c_str())) {
+      BlockBasedTableFactory* bbtf =
+          static_cast<BlockBasedTableFactory*>(options.table_factory.get());
+      block_cache = bbtf->table_options().block_cache.get();
     }
 
     Random rnd(301);
     for (int i = 0; i < 400; ++i) {
       std::string key = "k" + ToString(i);
-      ASSERT_OK(Put(key, rnd.RandomString(100)));
+      Put(key, rnd.RandomString(100));
     }
-    ASSERT_OK(Flush());
+    Flush();
 
     bool timedout = true;
     // A timeout will be forced when the IO counter reaches this value

db/db_block_cache_test.cc

@@ -50,7 +50,7 @@ class DBBlockCacheTest : public DBTestBase {
     options.avoid_flush_during_recovery = false;
     // options.compression = kNoCompression;
     options.statistics = ROCKSDB_NAMESPACE::CreateDBStatistics();
-    options.table_factory.reset(NewBlockBasedTableFactory(table_options));
+    options.table_factory.reset(new BlockBasedTableFactory(table_options));
     return options;
   }
 
@@ -158,7 +158,7 @@ TEST_F(DBBlockCacheTest, IteratorBlockCacheUsage) {
 
   std::shared_ptr<Cache> cache = NewLRUCache(0, 0, false);
   table_options.block_cache = cache;
-  options.table_factory.reset(NewBlockBasedTableFactory(table_options));
+  options.table_factory.reset(new BlockBasedTableFactory(table_options));
   Reopen(options);
   RecordCacheCounters(options);
 
@@ -182,7 +182,7 @@ TEST_F(DBBlockCacheTest, TestWithoutCompressedBlockCache) {
 
   std::shared_ptr<Cache> cache = NewLRUCache(0, 0, false);
   table_options.block_cache = cache;
-  options.table_factory.reset(NewBlockBasedTableFactory(table_options));
+  options.table_factory.reset(new BlockBasedTableFactory(table_options));
   Reopen(options);
   RecordCacheCounters(options);
 
@@ -238,7 +238,7 @@ TEST_F(DBBlockCacheTest, TestWithCompressedBlockCache) {
   std::shared_ptr<Cache> compressed_cache = NewLRUCache(1 << 25, 0, false);
   table_options.block_cache = cache;
   table_options.block_cache_compressed = compressed_cache;
-  options.table_factory.reset(NewBlockBasedTableFactory(table_options));
+  options.table_factory.reset(new BlockBasedTableFactory(table_options));
   Reopen(options);
   RecordCacheCounters(options);
 
@@ -299,7 +299,7 @@ TEST_F(DBBlockCacheTest, IndexAndFilterBlocksOfNewTableAddedToCache) {
   BlockBasedTableOptions table_options;
   table_options.cache_index_and_filter_blocks = true;
   table_options.filter_policy.reset(NewBloomFilterPolicy(20));
-  options.table_factory.reset(NewBlockBasedTableFactory(table_options));
+  options.table_factory.reset(new BlockBasedTableFactory(table_options));
   CreateAndReopenWithCF({"pikachu"}, options);
 
   ASSERT_OK(Put(1, "key", "val"));
@@ -355,7 +355,7 @@ TEST_F(DBBlockCacheTest, FillCacheAndIterateDB) {
 
   std::shared_ptr<Cache> cache = NewLRUCache(10, 0, true);
   table_options.block_cache = cache;
-  options.table_factory.reset(NewBlockBasedTableFactory(table_options));
+  options.table_factory.reset(new BlockBasedTableFactory(table_options));
   Reopen(options);
   ASSERT_OK(Put("key1", "val1"));
   ASSERT_OK(Put("key2", "val2"));
@@ -393,7 +393,7 @@ TEST_F(DBBlockCacheTest, IndexAndFilterBlocksStats) {
   std::shared_ptr<Cache> cache = NewLRUCache(co);
   table_options.block_cache = cache;
   table_options.filter_policy.reset(NewBloomFilterPolicy(20, true));
-  options.table_factory.reset(NewBlockBasedTableFactory(table_options));
+  options.table_factory.reset(new BlockBasedTableFactory(table_options));
   CreateAndReopenWithCF({"pikachu"}, options);
 
   ASSERT_OK(Put(1, "longer_key", "val"));
@@ -474,7 +474,7 @@ TEST_F(DBBlockCacheTest, IndexAndFilterBlocksCachePriority) {
     table_options.filter_policy.reset(NewBloomFilterPolicy(20));
     table_options.cache_index_and_filter_blocks_with_high_priority =
         priority == Cache::Priority::HIGH ? true : false;
-    options.table_factory.reset(NewBlockBasedTableFactory(table_options));
+    options.table_factory.reset(new BlockBasedTableFactory(table_options));
     DestroyAndReopen(options);
 
     MockCache::high_pri_insert_count = 0;
@@ -573,7 +573,7 @@ TEST_F(DBBlockCacheTest, AddRedundantStats) {
     table_options.cache_index_and_filter_blocks = true;
     table_options.block_cache = cache;
     table_options.filter_policy.reset(NewBloomFilterPolicy(50));
-    options.table_factory.reset(NewBlockBasedTableFactory(table_options));
+    options.table_factory.reset(new BlockBasedTableFactory(table_options));
     DestroyAndReopen(options);
 
     // Create a new table.
@@ -662,7 +662,7 @@ TEST_F(DBBlockCacheTest, ParanoidFileChecks) {
   BlockBasedTableOptions table_options;
   table_options.cache_index_and_filter_blocks = false;
   table_options.filter_policy.reset(NewBloomFilterPolicy(20));
-  options.table_factory.reset(NewBlockBasedTableFactory(table_options));
+  options.table_factory.reset(new BlockBasedTableFactory(table_options));
   CreateAndReopenWithCF({"pikachu"}, options);
 
   ASSERT_OK(Put(1, "1_key", "val"));
@@ -837,9 +837,8 @@ TEST_F(DBBlockCacheTest, CacheCompressionDict) {
   Random rnd(301);
   for (auto compression_type : compression_types) {
     Options options = CurrentOptions();
-    options.bottommost_compression = compression_type;
-    options.bottommost_compression_opts.max_dict_bytes = 4096;
-    options.bottommost_compression_opts.enabled = true;
+    options.compression = compression_type;
+    options.compression_opts.max_dict_bytes = 4096;
     options.create_if_missing = true;
     options.num_levels = 2;
     options.statistics = ROCKSDB_NAMESPACE::CreateDBStatistics();
@@ -847,7 +846,7 @@ TEST_F(DBBlockCacheTest, CacheCompressionDict) {
     BlockBasedTableOptions table_options;
     table_options.cache_index_and_filter_blocks = true;
     table_options.block_cache.reset(new MockCache());
-    options.table_factory.reset(NewBlockBasedTableFactory(table_options));
+    options.table_factory.reset(new BlockBasedTableFactory(table_options));
     DestroyAndReopen(options);
 
     RecordCacheCountersForCompressionDict(options);
@@ -889,166 +888,6 @@ TEST_F(DBBlockCacheTest, CacheCompressionDict) {
 
 #endif  // ROCKSDB_LITE
 
-class DBBlockCachePinningTest
-    : public DBTestBase,
-      public testing::WithParamInterface<
-          std::tuple<bool, PinningTier, PinningTier, PinningTier>> {
- public:
-  DBBlockCachePinningTest()
-      : DBTestBase("/db_block_cache_test", /*env_do_fsync=*/false) {}
-
-  void SetUp() override {
-    partition_index_and_filters_ = std::get<0>(GetParam());
-    top_level_index_pinning_ = std::get<1>(GetParam());
-    partition_pinning_ = std::get<2>(GetParam());
-    unpartitioned_pinning_ = std::get<3>(GetParam());
-  }
-
-  bool partition_index_and_filters_;
-  PinningTier top_level_index_pinning_;
-  PinningTier partition_pinning_;
-  PinningTier unpartitioned_pinning_;
-};
-
-TEST_P(DBBlockCachePinningTest, TwoLevelDB) {
-  // Creates one file in L0 and one file in L1. Both files have enough data that
-  // their index and filter blocks are partitioned. The L1 file will also have
-  // a compression dictionary (those are trained only during compaction), which
-  // must be unpartitioned.
-  const int kKeySize = 32;
-  const int kBlockSize = 128;
-  const int kNumBlocksPerFile = 128;
-  const int kNumKeysPerFile = kBlockSize * kNumBlocksPerFile / kKeySize;
-
-  Options options = CurrentOptions();
-  // `kNoCompression` makes the unit test more portable. But it relies on the
-  // current behavior of persisting/accessing dictionary even when there's no
-  // (de)compression happening, which seems fairly likely to change over time.
-  options.compression = kNoCompression;
-  options.compression_opts.max_dict_bytes = 4 << 10;
-  options.statistics = ROCKSDB_NAMESPACE::CreateDBStatistics();
-  BlockBasedTableOptions table_options;
-  table_options.block_cache = NewLRUCache(1 << 20 /* capacity */);
-  table_options.block_size = kBlockSize;
-  table_options.metadata_block_size = kBlockSize;
-  table_options.cache_index_and_filter_blocks = true;
-  table_options.metadata_cache_options.top_level_index_pinning =
-      top_level_index_pinning_;
-  table_options.metadata_cache_options.partition_pinning = partition_pinning_;
-  table_options.metadata_cache_options.unpartitioned_pinning =
-      unpartitioned_pinning_;
-  table_options.filter_policy.reset(
-      NewBloomFilterPolicy(10 /* bits_per_key */));
-  if (partition_index_and_filters_) {
-    table_options.index_type =
-        BlockBasedTableOptions::IndexType::kTwoLevelIndexSearch;
-    table_options.partition_filters = true;
-  }
-  options.table_factory.reset(NewBlockBasedTableFactory(table_options));
-  Reopen(options);
-
-  Random rnd(301);
-  for (int i = 0; i < 2; ++i) {
-    for (int j = 0; j < kNumKeysPerFile; ++j) {
-      ASSERT_OK(Put(Key(i * kNumKeysPerFile + j), rnd.RandomString(kKeySize)));
-    }
-    ASSERT_OK(Flush());
-    if (i == 0) {
-      // Prevent trivial move so file will be rewritten with dictionary and
-      // reopened with L1's pinning settings.
-      CompactRangeOptions cro;
-      cro.bottommost_level_compaction = BottommostLevelCompaction::kForce;
-      ASSERT_OK(db_->CompactRange(cro, nullptr, nullptr));
-    }
-  }
-
-  // Clear all unpinned blocks so unpinned blocks will show up as cache misses
-  // when reading a key from a file.
-  table_options.block_cache->EraseUnRefEntries();
-
-  // Get base cache values
-  uint64_t filter_misses = TestGetTickerCount(options, BLOCK_CACHE_FILTER_MISS);
-  uint64_t index_misses = TestGetTickerCount(options, BLOCK_CACHE_INDEX_MISS);
-  uint64_t compression_dict_misses =
-      TestGetTickerCount(options, BLOCK_CACHE_COMPRESSION_DICT_MISS);
-
-  // Read a key from the L0 file
-  Get(Key(kNumKeysPerFile));
-  uint64_t expected_filter_misses = filter_misses;
-  uint64_t expected_index_misses = index_misses;
-  uint64_t expected_compression_dict_misses = compression_dict_misses;
-  if (partition_index_and_filters_) {
-    if (top_level_index_pinning_ == PinningTier::kNone) {
-      ++expected_filter_misses;
-      ++expected_index_misses;
-    }
-    if (partition_pinning_ == PinningTier::kNone) {
-      ++expected_filter_misses;
-      ++expected_index_misses;
-    }
-  } else {
-    if (unpartitioned_pinning_ == PinningTier::kNone) {
-      ++expected_filter_misses;
-      ++expected_index_misses;
-    }
-  }
-  if (unpartitioned_pinning_ == PinningTier::kNone) {
-    ++expected_compression_dict_misses;
-  }
-  ASSERT_EQ(expected_filter_misses,
-            TestGetTickerCount(options, BLOCK_CACHE_FILTER_MISS));
-  ASSERT_EQ(expected_index_misses,
-            TestGetTickerCount(options, BLOCK_CACHE_INDEX_MISS));
-  ASSERT_EQ(expected_compression_dict_misses,
-            TestGetTickerCount(options, BLOCK_CACHE_COMPRESSION_DICT_MISS));
-
-  // Clear all unpinned blocks so unpinned blocks will show up as cache misses
-  // when reading a key from a file.
-  table_options.block_cache->EraseUnRefEntries();
-
-  // Read a key from the L1 file
-  Get(Key(0));
-  if (partition_index_and_filters_) {
-    if (top_level_index_pinning_ == PinningTier::kNone ||
-        top_level_index_pinning_ == PinningTier::kFlushedAndSimilar) {
-      ++expected_filter_misses;
-      ++expected_index_misses;
-    }
-    if (partition_pinning_ == PinningTier::kNone ||
-        partition_pinning_ == PinningTier::kFlushedAndSimilar) {
-      ++expected_filter_misses;
-      ++expected_index_misses;
-    }
-  } else {
-    if (unpartitioned_pinning_ == PinningTier::kNone ||
-        unpartitioned_pinning_ == PinningTier::kFlushedAndSimilar) {
-      ++expected_filter_misses;
-      ++expected_index_misses;
-    }
-  }
-  if (unpartitioned_pinning_ == PinningTier::kNone ||
-      unpartitioned_pinning_ == PinningTier::kFlushedAndSimilar) {
-    ++expected_compression_dict_misses;
-  }
-  ASSERT_EQ(expected_filter_misses,
-            TestGetTickerCount(options, BLOCK_CACHE_FILTER_MISS));
-  ASSERT_EQ(expected_index_misses,
-            TestGetTickerCount(options, BLOCK_CACHE_INDEX_MISS));
-  ASSERT_EQ(expected_compression_dict_misses,
-            TestGetTickerCount(options, BLOCK_CACHE_COMPRESSION_DICT_MISS));
-}
-
-INSTANTIATE_TEST_CASE_P(
-    DBBlockCachePinningTest, DBBlockCachePinningTest,
-    ::testing::Combine(
-        ::testing::Bool(),
-        ::testing::Values(PinningTier::kNone, PinningTier::kFlushedAndSimilar,
-                          PinningTier::kAll),
-        ::testing::Values(PinningTier::kNone, PinningTier::kFlushedAndSimilar,
-                          PinningTier::kAll),
-        ::testing::Values(PinningTier::kNone, PinningTier::kFlushedAndSimilar,
-                          PinningTier::kAll)));
-
 }  // namespace ROCKSDB_NAMESPACE
 
 int main(int argc, char** argv) {

db/db_bloom_filter_test.cc

@@ -83,16 +83,13 @@ TEST_P(DBBloomFilterTestDefFormatVersion, KeyMayExist) {
     options_override.partition_filters = partition_filters_;
     options_override.metadata_block_size = 32;
     Options options = CurrentOptions(options_override);
-    if (partition_filters_) {
-      auto* table_options =
-          options.table_factory->GetOptions<BlockBasedTableOptions>();
-      if (table_options != nullptr &&
-          table_options->index_type !=
-              BlockBasedTableOptions::kTwoLevelIndexSearch) {
-        // In the current implementation partitioned filters depend on
-        // partitioned indexes
-        continue;
-      }
+    if (partition_filters_ &&
+        static_cast<BlockBasedTableOptions*>(
+            options.table_factory->GetOptions())
+                ->index_type != BlockBasedTableOptions::kTwoLevelIndexSearch) {
+      // In the current implementation partitioned filters depend on partitioned
+      // indexes
+      continue;
     }
     options.statistics = ROCKSDB_NAMESPACE::CreateDBStatistics();
     CreateAndReopenWithCF({"pikachu"}, options);
@@ -514,24 +511,24 @@ INSTANTIATE_TEST_CASE_P(
     ::testing::Values(
         std::make_tuple(BFP::kDeprecatedBlock, false,
                         test::kDefaultFormatVersion),
-        std::make_tuple(BFP::kAutoBloom, true, test::kDefaultFormatVersion),
-        std::make_tuple(BFP::kAutoBloom, false, test::kDefaultFormatVersion)));
+        std::make_tuple(BFP::kAuto, true, test::kDefaultFormatVersion),
+        std::make_tuple(BFP::kAuto, false, test::kDefaultFormatVersion)));
 
 INSTANTIATE_TEST_CASE_P(
     FormatDef, DBBloomFilterTestWithParam,
     ::testing::Values(
         std::make_tuple(BFP::kDeprecatedBlock, false,
                         test::kDefaultFormatVersion),
-        std::make_tuple(BFP::kAutoBloom, true, test::kDefaultFormatVersion),
-        std::make_tuple(BFP::kAutoBloom, false, test::kDefaultFormatVersion)));
+        std::make_tuple(BFP::kAuto, true, test::kDefaultFormatVersion),
+        std::make_tuple(BFP::kAuto, false, test::kDefaultFormatVersion)));
 
 INSTANTIATE_TEST_CASE_P(
     FormatLatest, DBBloomFilterTestWithParam,
     ::testing::Values(
         std::make_tuple(BFP::kDeprecatedBlock, false,
                         test::kLatestFormatVersion),
-        std::make_tuple(BFP::kAutoBloom, true, test::kLatestFormatVersion),
-        std::make_tuple(BFP::kAutoBloom, false, test::kLatestFormatVersion)));
+        std::make_tuple(BFP::kAuto, true, test::kLatestFormatVersion),
+        std::make_tuple(BFP::kAuto, false, test::kLatestFormatVersion)));
 #endif  // ROCKSDB_VALGRIND_RUN
 
 TEST_F(DBBloomFilterTest, BloomFilterRate) {
@@ -1730,7 +1727,6 @@ TEST_F(DBBloomFilterTest, DynamicBloomFilterUpperBound) {
     int using_full_builder = bfp_impl != BFP::kDeprecatedBlock;
     Options options;
     options.create_if_missing = true;
-    options.env = CurrentOptions().env;
     options.prefix_extractor.reset(NewCappedPrefixTransform(4));
     options.disable_auto_compactions = true;
     options.statistics = CreateDBStatistics();
@@ -1861,7 +1857,6 @@ TEST_F(DBBloomFilterTest, DynamicBloomFilterMultipleSST) {
   for (auto bfp_impl : BFP::kAllFixedImpls) {
     int using_full_builder = bfp_impl != BFP::kDeprecatedBlock;
     Options options;
-    options.env = CurrentOptions().env;
     options.create_if_missing = true;
     options.prefix_extractor.reset(NewFixedPrefixTransform(1));
     options.disable_auto_compactions = true;
@@ -2054,7 +2049,6 @@ TEST_F(DBBloomFilterTest, DynamicBloomFilterNewColumnFamily) {
 TEST_F(DBBloomFilterTest, DynamicBloomFilterOptions) {
   for (auto bfp_impl : BFP::kAllFixedImpls) {
     Options options;
-    options.env = CurrentOptions().env;
     options.create_if_missing = true;
     options.prefix_extractor.reset(NewFixedPrefixTransform(1));
     options.disable_auto_compactions = true;

db/db_compaction_filter_test.cc

@@ -314,7 +314,7 @@ TEST_F(DBTestCompactionFilter, CompactionFilter) {
     ASSERT_OK(iter->status());
     while (iter->Valid()) {
       ParsedInternalKey ikey(Slice(), 0, kTypeValue);
-      ASSERT_OK(ParseInternalKey(iter->key(), &ikey, true /* log_err_key */));
+      ASSERT_EQ(ParseInternalKey(iter->key(), &ikey), true);
       total++;
       if (ikey.sequence != 0) {
         count++;
@@ -405,7 +405,7 @@ TEST_F(DBTestCompactionFilter, CompactionFilter) {
     ASSERT_OK(iter->status());
     while (iter->Valid()) {
       ParsedInternalKey ikey(Slice(), 0, kTypeValue);
-      ASSERT_OK(ParseInternalKey(iter->key(), &ikey, true /* log_err_key */));
+      ASSERT_EQ(ParseInternalKey(iter->key(), &ikey), true);
       ASSERT_NE(ikey.sequence, (unsigned)0);
       count++;
       iter->Next();
@@ -624,7 +624,7 @@ TEST_F(DBTestCompactionFilter, CompactionFilterContextManual) {
     ASSERT_OK(iter->status());
     while (iter->Valid()) {
       ParsedInternalKey ikey(Slice(), 0, kTypeValue);
-      ASSERT_OK(ParseInternalKey(iter->key(), &ikey, true /* log_err_key */));
+      ASSERT_EQ(ParseInternalKey(iter->key(), &ikey), true);
       total++;
       if (ikey.sequence != 0) {
         count++;

db/db_compaction_test.cc

@@ -48,18 +48,6 @@ class DBCompactionTestWithParam
   bool exclusive_manual_compaction_;
 };
 
-class DBCompactionTestWithBottommostParam
-    : public DBTestBase,
-      public testing::WithParamInterface<BottommostLevelCompaction> {
- public:
-  DBCompactionTestWithBottommostParam()
-      : DBTestBase("/db_compaction_test", /*env_do_fsync=*/true) {
-    bottommost_level_compaction_ = GetParam();
-  }
-
-  BottommostLevelCompaction bottommost_level_compaction_;
-};
-
 class DBCompactionDirectIOTest : public DBCompactionTest,
                                  public ::testing::WithParamInterface<bool> {
  public:
@@ -3270,7 +3258,7 @@ TEST_P(DBCompactionTestWithParam, IntraL0Compaction) {
   table_options.block_cache = NewLRUCache(64 << 20);  // 64MB
   table_options.cache_index_and_filter_blocks = true;
   table_options.pin_l0_filter_and_index_blocks_in_cache = true;
-  options.table_factory.reset(NewBlockBasedTableFactory(table_options));
+  options.table_factory.reset(new BlockBasedTableFactory(table_options));
 
   DestroyAndReopen(options);
 
@@ -3278,13 +3266,8 @@ TEST_P(DBCompactionTestWithParam, IntraL0Compaction) {
   Random rnd(301);
   std::string value(rnd.RandomString(kValueSize));
 
-  // The L0->L1 must be picked before we begin flushing files to trigger
-  // intra-L0 compaction, and must not finish until after an intra-L0
-  // compaction has been picked.
   ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->LoadDependency(
-      {{"LevelCompactionPicker::PickCompaction:Return",
-        "DBCompactionTest::IntraL0Compaction:L0ToL1Ready"},
-       {"LevelCompactionPicker::PickCompactionBySize:0",
+      {{"LevelCompactionPicker::PickCompactionBySize:0",
         "CompactionJob::Run():Start"}});
   ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->EnableProcessing();
 
@@ -3302,7 +3285,6 @@ TEST_P(DBCompactionTestWithParam, IntraL0Compaction) {
   for (int i = 0; i < 10; ++i) {
     ASSERT_OK(Put(Key(0), ""));  // prevents trivial move
     if (i == 5) {
-      TEST_SYNC_POINT("DBCompactionTest::IntraL0Compaction:L0ToL1Ready");
       ASSERT_OK(Put(Key(i + 1), value + value));
     } else {
       ASSERT_OK(Put(Key(i + 1), value));
@@ -3348,14 +3330,8 @@ TEST_P(DBCompactionTestWithParam, IntraL0CompactionDoesNotObsoleteDeletions) {
   Random rnd(301);
   std::string value(rnd.RandomString(kValueSize));
 
-  // The L0->L1 must be picked before we begin flushing files to trigger
-  // intra-L0 compaction, and must not finish until after an intra-L0
-  // compaction has been picked.
   ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->LoadDependency(
-      {{"LevelCompactionPicker::PickCompaction:Return",
-        "DBCompactionTest::IntraL0CompactionDoesNotObsoleteDeletions:"
-        "L0ToL1Ready"},
-       {"LevelCompactionPicker::PickCompactionBySize:0",
+      {{"LevelCompactionPicker::PickCompactionBySize:0",
         "CompactionJob::Run():Start"}});
   ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->EnableProcessing();
 
@@ -3379,11 +3355,6 @@ TEST_P(DBCompactionTestWithParam, IntraL0CompactionDoesNotObsoleteDeletions) {
     } else {
       ASSERT_OK(Delete(Key(0)));
     }
-    if (i == 5) {
-      TEST_SYNC_POINT(
-          "DBCompactionTest::IntraL0CompactionDoesNotObsoleteDeletions:"
-          "L0ToL1Ready");
-    }
     ASSERT_OK(Put(Key(i + 1), value));
     ASSERT_OK(Flush());
   }
@@ -5023,7 +4994,7 @@ TEST_F(DBCompactionTest, ManualCompactionFailsInReadOnlyMode) {
   // is in read-only mode. Verify it now at least returns, despite failing.
   const int kNumL0Files = 4;
   std::unique_ptr<FaultInjectionTestEnv> mock_env(
-      new FaultInjectionTestEnv(env_));
+      new FaultInjectionTestEnv(Env::Default()));
   Options opts = CurrentOptions();
   opts.disable_auto_compactions = true;
   opts.env = mock_env.get();
@@ -5250,7 +5221,7 @@ TEST_F(DBCompactionTest, ConsistencyFailTest2) {
   options.level0_file_num_compaction_trigger = 2;
   BlockBasedTableOptions bbto;
   bbto.block_size = 400;  // small block size
-  options.table_factory.reset(NewBlockBasedTableFactory(bbto));
+  options.table_factory.reset(new BlockBasedTableFactory(bbto));
   DestroyAndReopen(options);
 
   ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->SetCallBack(
@@ -5316,14 +5287,8 @@ TEST_P(DBCompactionTestWithParam,
   std::atomic<int> pick_intra_l0_count(0);
   std::string value(rnd.RandomString(kValueSize));
 
-  // The L0->L1 must be picked before we begin ingesting files to trigger
-  // intra-L0 compaction, and must not finish until after an intra-L0
-  // compaction has been picked.
   ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->LoadDependency(
-      {{"LevelCompactionPicker::PickCompaction:Return",
-        "DBCompactionTestWithParam::"
-        "FlushAfterIntraL0CompactionCheckConsistencyFail:L0ToL1Ready"},
-       {"LevelCompactionPicker::PickCompactionBySize:0",
+      {{"DBCompactionTestWithParam::FlushAfterIntraL0:1",
         "CompactionJob::Run():Start"}});
   ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->SetCallBack(
       "FindIntraL0Compaction",
@@ -5351,16 +5316,14 @@ TEST_P(DBCompactionTestWithParam,
   ASSERT_OK(Put(Key(0), "a"));
 
   ASSERT_EQ(5, NumTableFilesAtLevel(0));
-  TEST_SYNC_POINT(
-      "DBCompactionTestWithParam::"
-      "FlushAfterIntraL0CompactionCheckConsistencyFail:L0ToL1Ready");
 
   // Ingest 5 L0 sst. And this files would trigger PickIntraL0Compaction.
   for (int i = 5; i < 10; i++) {
-    ASSERT_EQ(i, NumTableFilesAtLevel(0));
     IngestOneKeyValue(dbfull(), Key(i), value, options);
+    ASSERT_EQ(i + 1, NumTableFilesAtLevel(0));
   }
 
+  TEST_SYNC_POINT("DBCompactionTestWithParam::FlushAfterIntraL0:1");
   // Put one key, to make biggest log sequence number in this memtable is bigger
   // than sst which would be ingested in next step.
   ASSERT_OK(Put(Key(2), "b"));
@@ -5402,14 +5365,8 @@ TEST_P(DBCompactionTestWithParam,
   ASSERT_EQ(0, NumTableFilesAtLevel(0));
 
   std::atomic<int> pick_intra_l0_count(0);
-  // The L0->L1 must be picked before we begin ingesting files to trigger
-  // intra-L0 compaction, and must not finish until after an intra-L0
-  // compaction has been picked.
   ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->LoadDependency(
-      {{"LevelCompactionPicker::PickCompaction:Return",
-        "DBCompactionTestWithParam::"
-        "IntraL0CompactionAfterFlushCheckConsistencyFail:L0ToL1Ready"},
-       {"LevelCompactionPicker::PickCompactionBySize:0",
+      {{"DBCompactionTestWithParam::IntraL0CompactionAfterFlush:1",
         "CompactionJob::Run():Start"}});
   ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->SetCallBack(
       "FindIntraL0Compaction",
@@ -5440,18 +5397,17 @@ TEST_P(DBCompactionTestWithParam,
   }
 
   ASSERT_EQ(6, NumTableFilesAtLevel(0));
-  TEST_SYNC_POINT(
-      "DBCompactionTestWithParam::"
-      "IntraL0CompactionAfterFlushCheckConsistencyFail:L0ToL1Ready");
   // ingest file to trigger IntraL0Compaction
   for (int i = 6; i < 10; ++i) {
     ASSERT_EQ(i, NumTableFilesAtLevel(0));
     IngestOneKeyValue(dbfull(), Key(i), value2, options);
   }
+  ASSERT_EQ(10, NumTableFilesAtLevel(0));
 
   // Wake up flush job
   sleeping_tasks.WakeUp();
   sleeping_tasks.WaitUntilDone();
+  TEST_SYNC_POINT("DBCompactionTestWithParam::IntraL0CompactionAfterFlush:1");
   dbfull()->TEST_WaitForCompact();
   ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->DisableProcessing();
 
@@ -5467,47 +5423,6 @@ TEST_P(DBCompactionTestWithParam,
   }
 }
 
-TEST_P(DBCompactionTestWithBottommostParam, SequenceKeysManualCompaction) {
-  constexpr int kSstNum = 10;
-  Options options = CurrentOptions();
-  options.disable_auto_compactions = true;
-  DestroyAndReopen(options);
-
-  // Generate some sst files on level 0 with sequence keys (no overlap)
-  for (int i = 0; i < kSstNum; i++) {
-    for (int j = 1; j < UCHAR_MAX; j++) {
-      auto key = std::string(kSstNum, '\0');
-      key[kSstNum - i] += static_cast<char>(j);
-      Put(key, std::string(i % 1000, 'A'));
-    }
-    ASSERT_OK(Flush());
-  }
-  ASSERT_OK(dbfull()->TEST_WaitForFlushMemTable());
-
-  ASSERT_EQ(ToString(kSstNum), FilesPerLevel(0));
-
-  auto cro = CompactRangeOptions();
-  cro.bottommost_level_compaction = bottommost_level_compaction_;
-  db_->CompactRange(cro, nullptr, nullptr);
-  if (bottommost_level_compaction_ == BottommostLevelCompaction::kForce ||
-      bottommost_level_compaction_ ==
-          BottommostLevelCompaction::kForceOptimized) {
-    // Real compaction to compact all sst files from level 0 to 1 file on level
-    // 1
-    ASSERT_EQ("0,1", FilesPerLevel(0));
-  } else {
-    // Just trivial move from level 0 -> 1
-    ASSERT_EQ("0," + ToString(kSstNum), FilesPerLevel(0));
-  }
-}
-
-INSTANTIATE_TEST_CASE_P(
-    DBCompactionTestWithBottommostParam, DBCompactionTestWithBottommostParam,
-    ::testing::Values(BottommostLevelCompaction::kSkip,
-                      BottommostLevelCompaction::kIfHaveCompactionFilter,
-                      BottommostLevelCompaction::kForce,
-                      BottommostLevelCompaction::kForceOptimized));
-
 TEST_F(DBCompactionTest, UpdateLevelSubCompactionTest) {
   Options options = CurrentOptions();
   options.max_subcompactions = 10;
@@ -5707,6 +5622,7 @@ TEST_F(DBCompactionTest, ChangeLevelCompactRangeConflictsWithManual) {
 
   GenerateNewFile(&rnd, &key_idx);
   GenerateNewFile(&rnd, &key_idx);
+  ASSERT_OK(dbfull()->TEST_WaitForCompact());
   ASSERT_EQ("1,1,2", FilesPerLevel(0));
 
   // The background thread will refit L2->L1 while the
@@ -5770,256 +5686,6 @@ TEST_F(DBCompactionTest, ChangeLevelCompactRangeConflictsWithManual) {
   refit_level_thread.join();
 }
 
-TEST_F(DBCompactionTest, ChangeLevelErrorPathTest) {
-  // This test is added to ensure that RefitLevel() error paths are clearing
-  // internal flags and to test that subsequent valid RefitLevel() calls
-  // succeeds
-  Options options = CurrentOptions();
-  options.memtable_factory.reset(
-      new SpecialSkipListFactory(KNumKeysByGenerateNewFile - 1));
-  options.level0_file_num_compaction_trigger = 2;
-  options.num_levels = 3;
-  Reopen(options);
-
-  ASSERT_EQ("", FilesPerLevel(0));
-
-  // Setup an LSM with three levels populated.
-  Random rnd(301);
-  int key_idx = 0;
-  GenerateNewFile(&rnd, &key_idx);
-  ASSERT_EQ("1", FilesPerLevel(0));
-  {
-    CompactRangeOptions cro;
-    cro.change_level = true;
-    cro.target_level = 2;
-    ASSERT_OK(dbfull()->CompactRange(cro, nullptr, nullptr));
-  }
-  ASSERT_EQ("0,0,2", FilesPerLevel(0));
-
-  auto start_idx = key_idx;
-  GenerateNewFile(&rnd, &key_idx);
-  GenerateNewFile(&rnd, &key_idx);
-  auto end_idx = key_idx - 1;
-  ASSERT_EQ("1,1,2", FilesPerLevel(0));
-
-  // Next two CompactRange() calls are used to test exercise error paths within
-  // RefitLevel() before triggering a valid RefitLevel() call
-
-  // Trigger a refit to L1 first
-  {
-    std::string begin_string = Key(start_idx);
-    std::string end_string = Key(end_idx);
-    Slice begin(begin_string);
-    Slice end(end_string);
-
-    CompactRangeOptions cro;
-    cro.change_level = true;
-    cro.target_level = 1;
-    ASSERT_OK(dbfull()->CompactRange(cro, &begin, &end));
-  }
-  ASSERT_EQ("0,3,2", FilesPerLevel(0));
-
-  // Try a refit from L2->L1 - this should fail and exercise error paths in
-  // RefitLevel()
-  {
-    // Select key range that matches the bottom most level (L2)
-    std::string begin_string = Key(0);
-    std::string end_string = Key(start_idx - 1);
-    Slice begin(begin_string);
-    Slice end(end_string);
-
-    CompactRangeOptions cro;
-    cro.change_level = true;
-    cro.target_level = 1;
-    ASSERT_NOK(dbfull()->CompactRange(cro, &begin, &end));
-  }
-  ASSERT_EQ("0,3,2", FilesPerLevel(0));
-
-  // Try a valid Refit request to ensure, the path is still working
-  {
-    CompactRangeOptions cro;
-    cro.change_level = true;
-    cro.target_level = 1;
-    ASSERT_OK(dbfull()->CompactRange(cro, nullptr, nullptr));
-  }
-  ASSERT_EQ("0,5", FilesPerLevel(0));
-}
-
-TEST_F(DBCompactionTest, CompactionWithBlob) {
-  Options options;
-  options.env = env_;
-  options.disable_auto_compactions = true;
-
-  Reopen(options);
-
-  constexpr char first_key[] = "first_key";
-  constexpr char second_key[] = "second_key";
-  constexpr char first_value[] = "first_value";
-  constexpr char second_value[] = "second_value";
-  constexpr char third_value[] = "third_value";
-
-  ASSERT_OK(Put(first_key, first_value));
-  ASSERT_OK(Put(second_key, first_value));
-  ASSERT_OK(Flush());
-
-  ASSERT_OK(Put(first_key, second_value));
-  ASSERT_OK(Put(second_key, second_value));
-  ASSERT_OK(Flush());
-
-  ASSERT_OK(Put(first_key, third_value));
-  ASSERT_OK(Put(second_key, third_value));
-  ASSERT_OK(Flush());
-
-  options.enable_blob_files = true;
-
-  Reopen(options);
-
-  constexpr Slice* begin = nullptr;
-  constexpr Slice* end = nullptr;
-
-  ASSERT_OK(db_->CompactRange(CompactRangeOptions(), begin, end));
-
-  ASSERT_EQ(Get(first_key), third_value);
-  ASSERT_EQ(Get(second_key), third_value);
-
-  VersionSet* const versions = dbfull()->TEST_GetVersionSet();
-  assert(versions);
-
-  ColumnFamilyData* const cfd = versions->GetColumnFamilySet()->GetDefault();
-  assert(cfd);
-
-  Version* const current = cfd->current();
-  assert(current);
-
-  const VersionStorageInfo* const storage_info = current->storage_info();
-  assert(storage_info);
-
-  const auto& l1_files = storage_info->LevelFiles(1);
-  ASSERT_EQ(l1_files.size(), 1);
-
-  const FileMetaData* const table_file = l1_files[0];
-  assert(table_file);
-
-  const auto& blob_files = storage_info->GetBlobFiles();
-  ASSERT_EQ(blob_files.size(), 1);
-
-  const auto& blob_file = blob_files.begin()->second;
-  assert(blob_file);
-
-  ASSERT_EQ(table_file->smallest.user_key(), first_key);
-  ASSERT_EQ(table_file->largest.user_key(), second_key);
-  ASSERT_EQ(table_file->oldest_blob_file_number,
-            blob_file->GetBlobFileNumber());
-
-  ASSERT_EQ(blob_file->GetTotalBlobCount(), 2);
-
-  const InternalStats* const internal_stats = cfd->internal_stats();
-  assert(internal_stats);
-
-  const uint64_t expected_bytes =
-      table_file->fd.GetFileSize() + blob_file->GetTotalBlobBytes();
-
-  const auto& compaction_stats = internal_stats->TEST_GetCompactionStats();
-  ASSERT_GE(compaction_stats.size(), 2);
-  ASSERT_EQ(compaction_stats[1].bytes_written, expected_bytes);
-  ASSERT_EQ(compaction_stats[1].num_output_files, 2);
-}
-
-class DBCompactionTestBlobError
-    : public DBCompactionTest,
-      public testing::WithParamInterface<std::string> {
- public:
-  DBCompactionTestBlobError()
-      : fault_injection_env_(env_), sync_point_(GetParam()) {}
-  ~DBCompactionTestBlobError() { Close(); }
-
-  FaultInjectionTestEnv fault_injection_env_;
-  std::string sync_point_;
-};
-
-INSTANTIATE_TEST_CASE_P(DBCompactionTestBlobError, DBCompactionTestBlobError,
-                        ::testing::ValuesIn(std::vector<std::string>{
-                            "BlobFileBuilder::WriteBlobToFile:AddRecord",
-                            "BlobFileBuilder::WriteBlobToFile:AppendFooter"}));
-
-TEST_P(DBCompactionTestBlobError, CompactionError) {
-  Options options;
-  options.disable_auto_compactions = true;
-  options.env = env_;
-
-  Reopen(options);
-
-  constexpr char first_key[] = "first_key";
-  constexpr char second_key[] = "second_key";
-  constexpr char first_value[] = "first_value";
-  constexpr char second_value[] = "second_value";
-  constexpr char third_value[] = "third_value";
-
-  ASSERT_OK(Put(first_key, first_value));
-  ASSERT_OK(Put(second_key, first_value));
-  ASSERT_OK(Flush());
-
-  ASSERT_OK(Put(first_key, second_value));
-  ASSERT_OK(Put(second_key, second_value));
-  ASSERT_OK(Flush());
-
-  ASSERT_OK(Put(first_key, third_value));
-  ASSERT_OK(Put(second_key, third_value));
-  ASSERT_OK(Flush());
-
-  options.enable_blob_files = true;
-  options.env = &fault_injection_env_;
-
-  Reopen(options);
-
-  SyncPoint::GetInstance()->SetCallBack(sync_point_, [this](void* /* arg */) {
-    fault_injection_env_.SetFilesystemActive(false,
-                                             Status::IOError(sync_point_));
-  });
-  SyncPoint::GetInstance()->EnableProcessing();
-
-  constexpr Slice* begin = nullptr;
-  constexpr Slice* end = nullptr;
-
-  ASSERT_TRUE(db_->CompactRange(CompactRangeOptions(), begin, end).IsIOError());
-
-  SyncPoint::GetInstance()->DisableProcessing();
-  SyncPoint::GetInstance()->ClearAllCallBacks();
-
-  VersionSet* const versions = dbfull()->TEST_GetVersionSet();
-  assert(versions);
-
-  ColumnFamilyData* const cfd = versions->GetColumnFamilySet()->GetDefault();
-  assert(cfd);
-
-  Version* const current = cfd->current();
-  assert(current);
-
-  const VersionStorageInfo* const storage_info = current->storage_info();
-  assert(storage_info);
-
-  const auto& l1_files = storage_info->LevelFiles(1);
-  ASSERT_TRUE(l1_files.empty());
-
-  const auto& blob_files = storage_info->GetBlobFiles();
-  ASSERT_TRUE(blob_files.empty());
-
-  const InternalStats* const internal_stats = cfd->internal_stats();
-  assert(internal_stats);
-
-  const auto& compaction_stats = internal_stats->TEST_GetCompactionStats();
-  ASSERT_GE(compaction_stats.size(), 2);
-
-  if (sync_point_ == "BlobFileBuilder::WriteBlobToFile:AddRecord") {
-    ASSERT_EQ(compaction_stats[1].bytes_written, 0);
-    ASSERT_EQ(compaction_stats[1].num_output_files, 0);
-  } else {
-    // SST file writing succeeded; blob file writing failed (during Finish)
-    ASSERT_GT(compaction_stats[1].bytes_written, 0);
-    ASSERT_EQ(compaction_stats[1].num_output_files, 1);
-  }
-}
-
 #endif  // !defined(ROCKSDB_LITE)
 
 }  // namespace ROCKSDB_NAMESPACE

db/db_dynamic_level_test.cc

@@ -141,7 +141,6 @@ TEST_F(DBTestDynamicLevel, DynamicLevelMaxBytesBase2) {
   options.max_background_compactions = 2;
   options.num_levels = 5;
   options.max_compaction_bytes = 0;  // Force not expanding in compactions
-  options.db_host_id = "";  // Setting this messes up the file size calculation
   BlockBasedTableOptions table_options;
   table_options.block_size = 1024;
   options.table_factory.reset(NewBlockBasedTableFactory(table_options));

db/db_encryption_test.cc

@@ -18,13 +18,6 @@ class DBEncryptionTest : public DBTestBase {
  public:
   DBEncryptionTest()
       : DBTestBase("/db_encryption_test", /*env_do_fsync=*/true) {}
-  Env* GetTargetEnv() {
-    if (encrypted_env_ != nullptr) {
-      return (static_cast<EnvWrapper*>(encrypted_env_))->target();
-    } else {
-      return env_;
-    }
-  }
 };
 
 #ifndef ROCKSDB_LITE
@@ -41,20 +34,20 @@ TEST_F(DBEncryptionTest, CheckEncrypted) {
   auto status = env_->GetChildren(dbname_, &fileNames);
   ASSERT_OK(status);
 
-  Env* target = GetTargetEnv();
+  auto defaultEnv = Env::Default();
   int hits = 0;
   for (auto it = fileNames.begin() ; it != fileNames.end(); ++it) {
-    if ((*it == "..") || (*it == ".") || (*it == "LOCK")) {
+    if ((*it == "..") || (*it == ".")) {
       continue;
     }
     auto filePath = dbname_ + "/" + *it;
     std::unique_ptr<SequentialFile> seqFile;
     auto envOptions = EnvOptions(CurrentOptions());
-    status = target->NewSequentialFile(filePath, &seqFile, envOptions);
+    status = defaultEnv->NewSequentialFile(filePath, &seqFile, envOptions);
     ASSERT_OK(status);
 
     uint64_t fileSize;
-    status = target->GetFileSize(filePath, &fileSize);
+    status = defaultEnv->GetFileSize(filePath, &fileSize);
     ASSERT_OK(status);
 
     std::string scratch;
@@ -92,7 +85,7 @@ TEST_F(DBEncryptionTest, CheckEncrypted) {
 }
 
 TEST_F(DBEncryptionTest, ReadEmptyFile) {
-  auto defaultEnv = GetTargetEnv();
+  auto defaultEnv = Env::Default();
 
   // create empty file for reading it back in later
   auto envOptions = EnvOptions(CurrentOptions());

db/db_flush_test.cc

@@ -11,7 +11,6 @@
 
 #include "db/db_impl/db_impl.h"
 #include "db/db_test_util.h"
-#include "file/filename.h"
 #include "port/port.h"
 #include "port/stack_trace.h"
 #include "test_util/sync_point.h"
@@ -63,7 +62,7 @@ TEST_F(DBFlushTest, FlushWhileWritingManifest) {
   ASSERT_OK(Put("bar", "v"));
   ASSERT_OK(dbfull()->Flush(no_wait));
   // If the issue is hit we will wait here forever.
-  ASSERT_OK(dbfull()->TEST_WaitForFlushMemTable());
+  dbfull()->TEST_WaitForFlushMemTable();
 #ifndef ROCKSDB_LITE
   ASSERT_EQ(2, TotalTableFiles());
 #endif  // ROCKSDB_LITE
@@ -88,7 +87,7 @@ TEST_F(DBFlushTest, SyncFail) {
   SyncPoint::GetInstance()->EnableProcessing();
 
   CreateAndReopenWithCF({"pikachu"}, options);
-  ASSERT_OK(Put("key", "value"));
+  Put("key", "value");
   auto* cfd =
       static_cast_with_check<ColumnFamilyHandleImpl>(db_->DefaultColumnFamily())
           ->cfd();
@@ -107,8 +106,7 @@ TEST_F(DBFlushTest, SyncFail) {
   TEST_SYNC_POINT("DBFlushTest::SyncFail:2");
   fault_injection_env->SetFilesystemActive(true);
   // Now the background job will do the flush; wait for it.
-  // Returns the IO error happend during flush.
-  ASSERT_NOK(dbfull()->TEST_WaitForFlushMemTable());
+  dbfull()->TEST_WaitForFlushMemTable();
 #ifndef ROCKSDB_LITE
   ASSERT_EQ("", FilesPerLevel());  // flush failed.
 #endif                             // ROCKSDB_LITE
@@ -127,7 +125,7 @@ TEST_F(DBFlushTest, SyncSkip) {
   SyncPoint::GetInstance()->EnableProcessing();
 
   Reopen(options);
-  ASSERT_OK(Put("key", "value"));
+  Put("key", "value");
 
   FlushOptions flush_options;
   flush_options.wait = false;
@@ -137,7 +135,7 @@ TEST_F(DBFlushTest, SyncSkip) {
   TEST_SYNC_POINT("DBFlushTest::SyncSkip:2");
 
   // Now the background job will do the flush; wait for it.
-  ASSERT_OK(dbfull()->TEST_WaitForFlushMemTable());
+  dbfull()->TEST_WaitForFlushMemTable();
 
   Destroy(options);
 }
@@ -172,9 +170,9 @@ TEST_F(DBFlushTest, FlushInLowPriThreadPool) {
   ASSERT_OK(Put("key", "val"));
   for (int i = 0; i < 4; ++i) {
     ASSERT_OK(Put("key", "val"));
-    ASSERT_OK(dbfull()->TEST_WaitForFlushMemTable());
+    dbfull()->TEST_WaitForFlushMemTable();
   }
-  ASSERT_OK(dbfull()->TEST_WaitForCompact());
+  dbfull()->TEST_WaitForCompact();
   ASSERT_EQ(4, num_flushes);
   ASSERT_EQ(1, num_compactions);
 }
@@ -307,8 +305,7 @@ TEST_F(DBFlushTest, ManualFlushFailsInReadOnlyMode) {
   // mode.
   fault_injection_env->SetFilesystemActive(false);
   ASSERT_OK(db_->ContinueBackgroundWork());
-  // We ingested the error to env, so the returned status is not OK.
-  ASSERT_NOK(dbfull()->TEST_WaitForFlushMemTable());
+  dbfull()->TEST_WaitForFlushMemTable();
 #ifndef ROCKSDB_LITE
   uint64_t num_bg_errors;
   ASSERT_TRUE(db_->GetIntProperty(DB::Properties::kBackgroundErrors,
@@ -446,180 +443,6 @@ TEST_F(DBFlushTest, FireOnFlushCompletedAfterCommittedResult) {
 }
 #endif  // !ROCKSDB_LITE
 
-TEST_F(DBFlushTest, FlushWithBlob) {
-  constexpr uint64_t min_blob_size = 10;
-
-  Options options;
-  options.env = CurrentOptions().env;
-  options.enable_blob_files = true;
-  options.min_blob_size = min_blob_size;
-  options.disable_auto_compactions = true;
-  options.env = env_;
-
-  Reopen(options);
-
-  constexpr char short_value[] = "short";
-  static_assert(sizeof(short_value) - 1 < min_blob_size,
-                "short_value too long");
-
-  constexpr char long_value[] = "long_value";
-  static_assert(sizeof(long_value) - 1 >= min_blob_size,
-                "long_value too short");
-
-  ASSERT_OK(Put("key1", short_value));
-  ASSERT_OK(Put("key2", long_value));
-
-  ASSERT_OK(Flush());
-
-  ASSERT_EQ(Get("key1"), short_value);
-  ASSERT_EQ(Get("key2"), long_value);
-
-  VersionSet* const versions = dbfull()->TEST_GetVersionSet();
-  assert(versions);
-
-  ColumnFamilyData* const cfd = versions->GetColumnFamilySet()->GetDefault();
-  assert(cfd);
-
-  Version* const current = cfd->current();
-  assert(current);
-
-  const VersionStorageInfo* const storage_info = current->storage_info();
-  assert(storage_info);
-
-  const auto& l0_files = storage_info->LevelFiles(0);
-  ASSERT_EQ(l0_files.size(), 1);
-
-  const FileMetaData* const table_file = l0_files[0];
-  assert(table_file);
-
-  const auto& blob_files = storage_info->GetBlobFiles();
-  ASSERT_EQ(blob_files.size(), 1);
-
-  const auto& blob_file = blob_files.begin()->second;
-  assert(blob_file);
-
-  ASSERT_EQ(table_file->smallest.user_key(), "key1");
-  ASSERT_EQ(table_file->largest.user_key(), "key2");
-  ASSERT_EQ(table_file->fd.smallest_seqno, 1);
-  ASSERT_EQ(table_file->fd.largest_seqno, 2);
-  ASSERT_EQ(table_file->oldest_blob_file_number,
-            blob_file->GetBlobFileNumber());
-
-  ASSERT_EQ(blob_file->GetTotalBlobCount(), 1);
-
-#ifndef ROCKSDB_LITE
-  const InternalStats* const internal_stats = cfd->internal_stats();
-  assert(internal_stats);
-
-  const uint64_t expected_bytes =
-      table_file->fd.GetFileSize() + blob_file->GetTotalBlobBytes();
-
-  const auto& compaction_stats = internal_stats->TEST_GetCompactionStats();
-  ASSERT_FALSE(compaction_stats.empty());
-  ASSERT_EQ(compaction_stats[0].bytes_written, expected_bytes);
-  ASSERT_EQ(compaction_stats[0].num_output_files, 2);
-
-  const uint64_t* const cf_stats_value = internal_stats->TEST_GetCFStatsValue();
-  ASSERT_EQ(cf_stats_value[InternalStats::BYTES_FLUSHED], expected_bytes);
-#endif  // ROCKSDB_LITE
-}
-
-class DBFlushTestBlobError : public DBFlushTest,
-                             public testing::WithParamInterface<std::string> {
- public:
-  DBFlushTestBlobError()
-      : fault_injection_env_(env_), sync_point_(GetParam()) {}
-  ~DBFlushTestBlobError() { Close(); }
-
-  FaultInjectionTestEnv fault_injection_env_;
-  std::string sync_point_;
-};
-
-INSTANTIATE_TEST_CASE_P(DBFlushTestBlobError, DBFlushTestBlobError,
-                        ::testing::ValuesIn(std::vector<std::string>{
-                            "BlobFileBuilder::WriteBlobToFile:AddRecord",
-                            "BlobFileBuilder::WriteBlobToFile:AppendFooter"}));
-
-TEST_P(DBFlushTestBlobError, FlushError) {
-  Options options;
-  options.enable_blob_files = true;
-  options.disable_auto_compactions = true;
-  options.env = &fault_injection_env_;
-
-  Reopen(options);
-
-  ASSERT_OK(Put("key", "blob"));
-
-  SyncPoint::GetInstance()->SetCallBack(sync_point_, [this](void* /* arg */) {
-    fault_injection_env_.SetFilesystemActive(false,
-                                             Status::IOError(sync_point_));
-  });
-  SyncPoint::GetInstance()->SetCallBack(
-      "BuildTable:BeforeDeleteFile", [this](void* /* arg */) {
-        fault_injection_env_.SetFilesystemActive(true);
-      });
-  SyncPoint::GetInstance()->EnableProcessing();
-
-  ASSERT_NOK(Flush());
-
-  SyncPoint::GetInstance()->DisableProcessing();
-  SyncPoint::GetInstance()->ClearAllCallBacks();
-
-  VersionSet* const versions = dbfull()->TEST_GetVersionSet();
-  assert(versions);
-
-  ColumnFamilyData* const cfd = versions->GetColumnFamilySet()->GetDefault();
-  assert(cfd);
-
-  Version* const current = cfd->current();
-  assert(current);
-
-  const VersionStorageInfo* const storage_info = current->storage_info();
-  assert(storage_info);
-
-  const auto& l0_files = storage_info->LevelFiles(0);
-  ASSERT_TRUE(l0_files.empty());
-
-  const auto& blob_files = storage_info->GetBlobFiles();
-  ASSERT_TRUE(blob_files.empty());
-
-  // Make sure the files generated by the failed job have been deleted
-  std::vector<std::string> files;
-  ASSERT_OK(env_->GetChildren(dbname_, &files));
-  for (const auto& file : files) {
-    uint64_t number = 0;
-    FileType type = kTableFile;
-
-    if (!ParseFileName(file, &number, &type)) {
-      continue;
-    }
-
-    ASSERT_NE(type, kTableFile);
-    ASSERT_NE(type, kBlobFile);
-  }
-
-#ifndef ROCKSDB_LITE
-  const InternalStats* const internal_stats = cfd->internal_stats();
-  assert(internal_stats);
-
-  const auto& compaction_stats = internal_stats->TEST_GetCompactionStats();
-  ASSERT_FALSE(compaction_stats.empty());
-
-  if (sync_point_ == "BlobFileBuilder::WriteBlobToFile:AddRecord") {
-    ASSERT_EQ(compaction_stats[0].bytes_written, 0);
-    ASSERT_EQ(compaction_stats[0].num_output_files, 0);
-  } else {
-    // SST file writing succeeded; blob file writing failed (during Finish)
-    ASSERT_GT(compaction_stats[0].bytes_written, 0);
-    ASSERT_EQ(compaction_stats[0].num_output_files, 1);
-  }
-
-  const uint64_t* const cf_stats_value = internal_stats->TEST_GetCFStatsValue();
-  ASSERT_EQ(cf_stats_value[InternalStats::BYTES_FLUSHED],
-            compaction_stats[0].bytes_written);
-#endif  // ROCKSDB_LITE
-}
-
 TEST_P(DBAtomicFlushTest, ManualAtomicFlush) {
   Options options = CurrentOptions();
   options.create_if_missing = true;
@@ -726,8 +549,7 @@ TEST_P(DBAtomicFlushTest, AtomicFlushRollbackSomeJobs) {
   fault_injection_env->SetFilesystemActive(false);
   TEST_SYNC_POINT("DBAtomicFlushTest::AtomicFlushRollbackSomeJobs:2");
   for (auto* cfh : handles_) {
-    // Returns the IO error happend during flush.
-    ASSERT_NOK(dbfull()->TEST_WaitForFlushMemTable(cfh));
+    dbfull()->TEST_WaitForFlushMemTable(cfh);
   }
   for (size_t i = 0; i != num_cfs; ++i) {
     auto cfh = static_cast<ColumnFamilyHandleImpl*>(handles_[i]);

db/db_impl/db_impl.cc

@@ -18,7 +18,6 @@
 #include <cstdio>
 #include <map>
 #include <set>
-#include <sstream>
 #include <stdexcept>
 #include <string>
 #include <unordered_map>
@@ -45,7 +44,6 @@
 #include "db/memtable_list.h"
 #include "db/merge_context.h"
 #include "db/merge_helper.h"
-#include "db/periodic_work_scheduler.h"
 #include "db/range_tombstone_fragmenter.h"
 #include "db/table_cache.h"
 #include "db/table_properties_collector.h"
@@ -67,6 +65,7 @@
 #include "monitoring/iostats_context_imp.h"
 #include "monitoring/perf_context_imp.h"
 #include "monitoring/persistent_stats_history.h"
+#include "monitoring/stats_dump_scheduler.h"
 #include "monitoring/thread_status_updater.h"
 #include "monitoring/thread_status_util.h"
 #include "options/cf_options.h"
@@ -208,7 +207,7 @@ DBImpl::DBImpl(const DBOptions& options, const std::string& dbname,
       refitting_level_(false),
       opened_successfully_(false),
 #ifndef ROCKSDB_LITE
-      periodic_work_scheduler_(nullptr),
+      stats_dump_scheduler_(nullptr),
 #endif  // ROCKSDB_LITE
       two_write_queues_(options.two_write_queues),
       manual_wal_flush_(options.manual_wal_flush),
@@ -408,7 +407,7 @@ Status DBImpl::ResumeImpl(DBRecoverContext context) {
     // during previous error handling.
     if (file_deletion_disabled) {
       // Always return ok
-      s = EnableFileDeletions(/*force=*/true);
+      EnableFileDeletions(/*force=*/true);
     }
     ROCKS_LOG_INFO(immutable_db_options_.info_log, "Successfully resumed DB");
   }
@@ -447,8 +446,8 @@ void DBImpl::CancelAllBackgroundWork(bool wait) {
                  "Shutdown: canceling all background work");
 
 #ifndef ROCKSDB_LITE
-  if (periodic_work_scheduler_ != nullptr) {
-    periodic_work_scheduler_->Unregister(this);
+  if (stats_dump_scheduler_ != nullptr) {
+    stats_dump_scheduler_->Unregister(this);
   }
 #endif  // !ROCKSDB_LITE
 
@@ -460,17 +459,14 @@ void DBImpl::CancelAllBackgroundWork(bool wait) {
       autovector<ColumnFamilyData*> cfds;
       SelectColumnFamiliesForAtomicFlush(&cfds);
       mutex_.Unlock();
-      Status s =
-          AtomicFlushMemTables(cfds, FlushOptions(), FlushReason::kShutDown);
-      s.PermitUncheckedError();  //**TODO: What to do on error?
+      AtomicFlushMemTables(cfds, FlushOptions(), FlushReason::kShutDown);
       mutex_.Lock();
     } else {
       for (auto cfd : *versions_->GetColumnFamilySet()) {
         if (!cfd->IsDropped() && cfd->initialized() && !cfd->mem()->IsEmpty()) {
           cfd->Ref();
           mutex_.Unlock();
-          Status s = FlushMemTable(cfd, FlushOptions(), FlushReason::kShutDown);
-          s.PermitUncheckedError();  //**TODO: What to do on error?
+          FlushMemTable(cfd, FlushOptions(), FlushReason::kShutDown);
           mutex_.Lock();
           cfd->UnrefAndTryDelete();
         }
@@ -638,7 +634,7 @@ Status DBImpl::CloseHelper() {
 
   if (immutable_db_options_.info_log && own_info_log_) {
     Status s = immutable_db_options_.info_log->Close();
-    if (!s.ok() && !s.IsNotSupported() && ret.ok()) {
+    if (!s.ok() && ret.ok()) {
       ret = s;
     }
   }
@@ -688,18 +684,18 @@ void DBImpl::PrintStatistics() {
   }
 }
 
-void DBImpl::StartPeriodicWorkScheduler() {
+void DBImpl::StartStatsDumpScheduler() {
 #ifndef ROCKSDB_LITE
   {
     InstrumentedMutexLock l(&mutex_);
-    periodic_work_scheduler_ = PeriodicWorkScheduler::Default();
-    TEST_SYNC_POINT_CALLBACK("DBImpl::StartPeriodicWorkScheduler:Init",
-                             &periodic_work_scheduler_);
+    stats_dump_scheduler_ = StatsDumpScheduler::Default();
+    TEST_SYNC_POINT_CALLBACK("DBImpl::StartStatsDumpScheduler:Init",
+                             &stats_dump_scheduler_);
   }
 
-  periodic_work_scheduler_->Register(
-      this, mutable_db_options_.stats_dump_period_sec,
-      mutable_db_options_.stats_persist_period_sec);
+  stats_dump_scheduler_->Register(this,
+                                  mutable_db_options_.stats_dump_period_sec,
+                                  mutable_db_options_.stats_persist_period_sec);
 #endif  // !ROCKSDB_LITE
 }
 
@@ -748,34 +744,29 @@ void DBImpl::PersistStats() {
 
   if (immutable_db_options_.persist_stats_to_disk) {
     WriteBatch batch;
-    Status s = Status::OK();
     if (stats_slice_initialized_) {
       ROCKS_LOG_INFO(immutable_db_options_.info_log,
                      "Reading %" ROCKSDB_PRIszt " stats from statistics\n",
                      stats_slice_.size());
       for (const auto& stat : stats_map) {
-        if (s.ok()) {
-          char key[100];
-          int length =
-              EncodePersistentStatsKey(now_seconds, stat.first, 100, key);
-          // calculate the delta from last time
-          if (stats_slice_.find(stat.first) != stats_slice_.end()) {
-            uint64_t delta = stat.second - stats_slice_[stat.first];
-            s = batch.Put(persist_stats_cf_handle_,
-                          Slice(key, std::min(100, length)), ToString(delta));
-          }
+        char key[100];
+        int length =
+            EncodePersistentStatsKey(now_seconds, stat.first, 100, key);
+        // calculate the delta from last time
+        if (stats_slice_.find(stat.first) != stats_slice_.end()) {
+          uint64_t delta = stat.second - stats_slice_[stat.first];
+          batch.Put(persist_stats_cf_handle_, Slice(key, std::min(100, length)),
+                    ToString(delta));
         }
       }
     }
     stats_slice_initialized_ = true;
     std::swap(stats_slice_, stats_map);
-    if (s.ok()) {
-      WriteOptions wo;
-      wo.low_pri = true;
-      wo.no_slowdown = true;
-      wo.sync = false;
-      s = Write(wo, &batch);
-    }
+    WriteOptions wo;
+    wo.low_pri = true;
+    wo.no_slowdown = true;
+    wo.sync = false;
+    Status s = Write(wo, &batch);
     if (!s.ok()) {
       ROCKS_LOG_INFO(immutable_db_options_.info_log,
                      "Writing to persistent stats CF failed -- %s",
@@ -915,14 +906,6 @@ void DBImpl::DumpStats() {
   PrintStatistics();
 }
 
-void DBImpl::FlushInfoLog() {
-  if (shutdown_initiated_) {
-    return;
-  }
-  TEST_SYNC_POINT("DBImpl::FlushInfoLog:StartRunning");
-  LogFlush(immutable_db_options_.info_log);
-}
-
 Status DBImpl::TablesRangeTombstoneSummary(ColumnFamilyHandle* column_family,
                                            int max_entries_to_print,
                                            std::string* out_str) {
@@ -977,7 +960,6 @@ Status DBImpl::SetOptions(
   MutableCFOptions new_options;
   Status s;
   Status persist_options_status;
-  persist_options_status.PermitUncheckedError();  // Allow uninitialized access
   SuperVersionContext sv_context(/* create_superversion */ true);
   {
     auto db_options = GetDBOptions();
@@ -987,8 +969,8 @@ Status DBImpl::SetOptions(
       new_options = *cfd->GetLatestMutableCFOptions();
       // Append new version to recompute compaction score.
       VersionEdit dummy_edit;
-      s = versions_->LogAndApply(cfd, new_options, &dummy_edit, &mutex_,
-                                 directories_.GetDbDir());
+      versions_->LogAndApply(cfd, new_options, &dummy_edit, &mutex_,
+                             directories_.GetDbDir());
       // Trigger possible flush/compactions. This has to be before we persist
       // options to file, otherwise there will be a deadlock with writer
       // thread.
@@ -1038,7 +1020,7 @@ Status DBImpl::SetDBOptions(
 
   MutableDBOptions new_options;
   Status s;
-  Status persist_options_status = Status::OK();
+  Status persist_options_status;
   bool wal_changed = false;
   WriteContext write_context;
   {
@@ -1099,12 +1081,19 @@ Status DBImpl::SetDBOptions(
               mutable_db_options_.stats_dump_period_sec ||
           new_options.stats_persist_period_sec !=
               mutable_db_options_.stats_persist_period_sec) {
-        mutex_.Unlock();
-        periodic_work_scheduler_->Unregister(this);
-        periodic_work_scheduler_->Register(
-            this, new_options.stats_dump_period_sec,
-            new_options.stats_persist_period_sec);
-        mutex_.Lock();
+        if (stats_dump_scheduler_) {
+          mutex_.Unlock();
+          stats_dump_scheduler_->Unregister(this);
+          mutex_.Lock();
+        }
+        if (new_options.stats_dump_period_sec > 0 ||
+            new_options.stats_persist_period_sec > 0) {
+          mutex_.Unlock();
+          stats_dump_scheduler_->Register(this,
+                                          new_options.stats_dump_period_sec,
+                                          new_options.stats_persist_period_sec);
+          mutex_.Lock();
+        }
       }
       write_controller_.set_max_delayed_write_rate(
           new_options.delayed_write_rate);
@@ -1136,10 +1125,6 @@ Status DBImpl::SetDBOptions(
       persist_options_status = WriteOptionsFile(
           false /*need_mutex_lock*/, false /*need_enter_write_thread*/);
       write_thread_.ExitUnbatched(&w);
-    } else {
-      // To get here, we must have had invalid options and will not attempt to
-      // persist the options, which means the status is "OK/Uninitialized.
-      persist_options_status.PermitUncheckedError();
     }
   }
   ROCKS_LOG_INFO(immutable_db_options_.info_log, "SetDBOptions(), inputs:");
@@ -1283,11 +1268,7 @@ Status DBImpl::SyncWAL() {
   TEST_SYNC_POINT("DBImpl::SyncWAL:BeforeMarkLogsSynced:1");
   {
     InstrumentedMutexLock l(&mutex_);
-    if (status.ok()) {
-      status = MarkLogsSynced(current_log_number, need_log_dir_sync);
-    } else {
-      MarkLogsNotSynced(current_log_number);
-    }
+    MarkLogsSynced(current_log_number, need_log_dir_sync, status);
   }
   TEST_SYNC_POINT("DBImpl::SyncWAL:BeforeMarkLogsSynced:2");
 
@@ -1313,53 +1294,27 @@ Status DBImpl::UnlockWAL() {
   return Status::OK();
 }
 
-Status DBImpl::MarkLogsSynced(uint64_t up_to, bool synced_dir) {
+void DBImpl::MarkLogsSynced(uint64_t up_to, bool synced_dir,
+                            const Status& status) {
   mutex_.AssertHeld();
-  if (synced_dir && logfile_number_ == up_to) {
+  if (synced_dir && logfile_number_ == up_to && status.ok()) {
     log_dir_synced_ = true;
   }
-  VersionEdit synced_wals;
   for (auto it = logs_.begin(); it != logs_.end() && it->number <= up_to;) {
-    auto& wal = *it;
-    assert(wal.getting_synced);
-    if (logs_.size() > 1) {
-      if (immutable_db_options_.track_and_verify_wals_in_manifest) {
-        synced_wals.AddWal(wal.number,
-                           WalMetadata(wal.writer->file()->GetFileSize()));
-      }
-      logs_to_free_.push_back(wal.ReleaseWriter());
+    auto& log = *it;
+    assert(log.getting_synced);
+    if (status.ok() && logs_.size() > 1) {
+      logs_to_free_.push_back(log.ReleaseWriter());
       // To modify logs_ both mutex_ and log_write_mutex_ must be held
       InstrumentedMutexLock l(&log_write_mutex_);
       it = logs_.erase(it);
     } else {
-      wal.getting_synced = false;
+      log.getting_synced = false;
       ++it;
     }
   }
-  assert(logs_.empty() || logs_[0].number > up_to ||
+  assert(!status.ok() || logs_.empty() || logs_[0].number > up_to ||
          (logs_.size() == 1 && !logs_[0].getting_synced));
-
-  Status s;
-  if (synced_wals.IsWalAddition()) {
-    // not empty, write to MANIFEST.
-    s = versions_->LogAndApplyToDefaultColumnFamily(&synced_wals, &mutex_);
-    if (!s.ok() && versions_->io_status().IsIOError()) {
-      s = error_handler_.SetBGError(versions_->io_status(),
-                                    BackgroundErrorReason::kManifestWrite);
-    }
-  }
-  log_sync_cv_.SignalAll();
-  return s;
-}
-
-void DBImpl::MarkLogsNotSynced(uint64_t up_to) {
-  mutex_.AssertHeld();
-  for (auto it = logs_.begin(); it != logs_.end() && it->number <= up_to;
-       ++it) {
-    auto& wal = *it;
-    assert(wal.getting_synced);
-    wal.getting_synced = false;
-  }
   log_sync_cv_.SignalAll();
 }
 
@@ -1640,8 +1595,7 @@ Status DBImpl::GetImpl(const ReadOptions& read_options, const Slice& key,
     // tracing is enabled.
     InstrumentedMutexLock lock(&trace_mutex_);
     if (tracer_) {
-      // TODO: maybe handle the tracing status?
-      tracer_->Get(get_impl_options.column_family, key).PermitUncheckedError();
+      tracer_->Get(get_impl_options.column_family, key);
     }
   }
 
@@ -1666,11 +1620,9 @@ Status DBImpl::GetImpl(const ReadOptions& read_options, const Slice& key,
     // data for the snapshot, so the reader would see neither data that was be
     // visible to the snapshot before compaction nor the newer data inserted
     // afterwards.
-    if (last_seq_same_as_publish_seq_) {
-      snapshot = versions_->LastSequence();
-    } else {
-      snapshot = versions_->LastPublishedSequence();
-    }
+    snapshot = last_seq_same_as_publish_seq_
+                   ? versions_->LastSequence()
+                   : versions_->LastPublishedSequence();
     if (get_impl_options.callback) {
       // The unprep_seqs are not published for write unprepared, so it could be
       // that max_visible_seq is larger. Seek to the std::max of the two.
@@ -1858,9 +1810,6 @@ std::vector<Status> DBImpl::MultiGet(
           read_options, nullptr, iter_deref_lambda, &multiget_cf_data,
           &consistent_seqnum);
 
-  TEST_SYNC_POINT("DBImpl::MultiGet:AfterGetSeqNum1");
-  TEST_SYNC_POINT("DBImpl::MultiGet:AfterGetSeqNum2");
-
   // Contain a list of merge operations if merge occurs.
   MergeContext merge_context;
 
@@ -1883,14 +1832,6 @@ std::vector<Status> DBImpl::MultiGet(
   size_t num_found = 0;
   size_t keys_read;
   uint64_t curr_value_size = 0;
-
-  GetWithTimestampReadCallback timestamp_read_callback(0);
-  ReadCallback* read_callback = nullptr;
-  if (read_options.timestamp && read_options.timestamp->size() > 0) {
-    timestamp_read_callback.Refresh(consistent_seqnum);
-    read_callback = &timestamp_read_callback;
-  }
-
   for (keys_read = 0; keys_read < num_keys; ++keys_read) {
     merge_context.Clear();
     Status& s = stat_list[keys_read];
@@ -1911,14 +1852,12 @@ std::vector<Status> DBImpl::MultiGet(
     bool done = false;
     if (!skip_memtable) {
       if (super_version->mem->Get(lkey, value, timestamp, &s, &merge_context,
-                                  &max_covering_tombstone_seq, read_options,
-                                  read_callback)) {
+                                  &max_covering_tombstone_seq, read_options)) {
         done = true;
         RecordTick(stats_, MEMTABLE_HIT);
-      } else if (super_version->imm->Get(lkey, value, timestamp, &s,
-                                         &merge_context,
-                                         &max_covering_tombstone_seq,
-                                         read_options, read_callback)) {
+      } else if (super_version->imm->Get(
+                     lkey, value, timestamp, &s, &merge_context,
+                     &max_covering_tombstone_seq, read_options)) {
         done = true;
         RecordTick(stats_, MEMTABLE_HIT);
       }
@@ -1926,11 +1865,9 @@ std::vector<Status> DBImpl::MultiGet(
     if (!done) {
       PinnableSlice pinnable_val;
       PERF_TIMER_GUARD(get_from_output_files_time);
-      super_version->current->Get(
-          read_options, lkey, &pinnable_val, timestamp, &s, &merge_context,
-          &max_covering_tombstone_seq, /*value_found=*/nullptr,
-          /*key_exists=*/nullptr,
-          /*seq=*/nullptr, read_callback);
+      super_version->current->Get(read_options, lkey, &pinnable_val, timestamp,
+                                  &s, &merge_context,
+                                  &max_covering_tombstone_seq);
       value->assign(pinnable_val.data(), pinnable_val.size());
       RecordTick(stats_, MEMTABLE_MISS);
     }
@@ -2027,11 +1964,9 @@ bool DBImpl::MultiCFSnapshot(
       // version because a flush happening in between may compact away data for
       // the snapshot, but the snapshot is earlier than the data overwriting it,
       // so users may see wrong results.
-      if (last_seq_same_as_publish_seq_) {
-        *snapshot = versions_->LastSequence();
-      } else {
-        *snapshot = versions_->LastPublishedSequence();
-      }
+      *snapshot = last_seq_same_as_publish_seq_
+                      ? versions_->LastSequence()
+                      : versions_->LastPublishedSequence();
     }
   } else {
     // If we end up with the same issue of memtable geting sealed during 2
@@ -2062,11 +1997,9 @@ bool DBImpl::MultiCFSnapshot(
           // acquire the lock so we're sure to succeed
           mutex_.Lock();
         }
-        if (last_seq_same_as_publish_seq_) {
-          *snapshot = versions_->LastSequence();
-        } else {
-          *snapshot = versions_->LastPublishedSequence();
-        }
+        *snapshot = last_seq_same_as_publish_seq_
+                        ? versions_->LastSequence()
+                        : versions_->LastPublishedSequence();
       } else {
         *snapshot = reinterpret_cast<const SnapshotImpl*>(read_options.snapshot)
                         ->number_;
@@ -2192,19 +2125,12 @@ void DBImpl::MultiGet(const ReadOptions& read_options, const size_t num_keys,
       read_options, nullptr, iter_deref_lambda, &multiget_cf_data,
       &consistent_seqnum);
 
-  GetWithTimestampReadCallback timestamp_read_callback(0);
-  ReadCallback* read_callback = nullptr;
-  if (read_options.timestamp && read_options.timestamp->size() > 0) {
-    timestamp_read_callback.Refresh(consistent_seqnum);
-    read_callback = &timestamp_read_callback;
-  }
-
   Status s;
   auto cf_iter = multiget_cf_data.begin();
   for (; cf_iter != multiget_cf_data.end(); ++cf_iter) {
     s = MultiGetImpl(read_options, cf_iter->start, cf_iter->num_keys,
                      &sorted_keys, cf_iter->super_version, consistent_seqnum,
-                     read_callback, nullptr);
+                     nullptr, nullptr);
     if (!s.ok()) {
       break;
     }
@@ -2367,16 +2293,9 @@ void DBImpl::MultiGetWithCallback(
     consistent_seqnum = callback->max_visible_seq();
   }
 
-  GetWithTimestampReadCallback timestamp_read_callback(0);
-  ReadCallback* read_callback = nullptr;
-  if (read_options.timestamp && read_options.timestamp->size() > 0) {
-    timestamp_read_callback.Refresh(consistent_seqnum);
-    read_callback = &timestamp_read_callback;
-  }
-
   Status s = MultiGetImpl(read_options, 0, num_keys, sorted_keys,
                           multiget_cf_data[0].super_version, consistent_seqnum,
-                          read_callback, nullptr);
+                          nullptr, nullptr);
   assert(s.ok() || s.IsTimedOut() || s.IsAborted());
   ReturnAndCleanupSuperVersion(multiget_cf_data[0].cfd,
                                multiget_cf_data[0].super_version);
@@ -2561,6 +2480,7 @@ Status DBImpl::CreateColumnFamilyImpl(const ColumnFamilyOptions& cf_options,
                                       const std::string& column_family_name,
                                       ColumnFamilyHandle** handle) {
   Status s;
+  Status persist_options_status;
   *handle = nullptr;
 
   DBOptions db_options =
@@ -2964,7 +2884,7 @@ const Snapshot* DBImpl::GetSnapshotForWriteConflictBoundary() {
 SnapshotImpl* DBImpl::GetSnapshotImpl(bool is_write_conflict_boundary,
                                       bool lock) {
   int64_t unix_time = 0;
-  env_->GetCurrentTime(&unix_time).PermitUncheckedError();  // Ignore error
+  env_->GetCurrentTime(&unix_time);  // Ignore error
   SnapshotImpl* s = new SnapshotImpl;
 
   if (lock) {
@@ -3008,11 +2928,9 @@ void DBImpl::ReleaseSnapshot(const Snapshot* s) {
     snapshots_.Delete(casted_s);
     uint64_t oldest_snapshot;
     if (snapshots_.empty()) {
-      if (last_seq_same_as_publish_seq_) {
-        oldest_snapshot = versions_->LastSequence();
-      } else {
-        oldest_snapshot = versions_->LastPublishedSequence();
-      }
+      oldest_snapshot = last_seq_same_as_publish_seq_
+                            ? versions_->LastSequence()
+                            : versions_->LastPublishedSequence();
     } else {
       oldest_snapshot = snapshots_.oldest()->number_;
     }
@@ -3113,7 +3031,6 @@ FileSystem* DBImpl::GetFileSystem() const {
 
 Status DBImpl::StartIOTrace(Env* env, const TraceOptions& trace_options,
                             std::unique_ptr<TraceWriter>&& trace_writer) {
-  assert(trace_writer != nullptr);
   return io_tracer_->StartIOTrace(env, trace_options, std::move(trace_writer));
 }
 
@@ -3214,17 +3131,17 @@ bool DBImpl::GetIntPropertyInternal(ColumnFamilyData* cfd,
     }
   } else {
     SuperVersion* sv = nullptr;
-    if (is_locked) {
-      mutex_.Unlock();
+    if (!is_locked) {
+      sv = GetAndRefSuperVersion(cfd);
+    } else {
+      sv = cfd->GetSuperVersion();
     }
-    sv = GetAndRefSuperVersion(cfd);
 
     bool ret = cfd->internal_stats()->GetIntPropertyOutOfMutex(
         property_info, sv->current, value);
 
-    ReturnAndCleanupSuperVersion(cfd, sv);
-    if (is_locked) {
-      mutex_.Lock();
+    if (!is_locked) {
+      ReturnAndCleanupSuperVersion(cfd, sv);
     }
 
     return ret;
@@ -3261,7 +3178,6 @@ bool DBImpl::GetAggregatedIntProperty(const Slice& property,
   }
 
   uint64_t sum = 0;
-  bool ret = true;
   {
     // Needs mutex to protect the list of column families.
     InstrumentedMutexLock l(&mutex_);
@@ -3270,21 +3186,15 @@ bool DBImpl::GetAggregatedIntProperty(const Slice& property,
       if (!cfd->initialized()) {
         continue;
       }
-      cfd->Ref();
-      ret = GetIntPropertyInternal(cfd, *property_info, true, &value);
-      // GetIntPropertyInternal may release db mutex and re-acquire it.
-      mutex_.AssertHeld();
-      cfd->UnrefAndTryDelete();
-      if (ret) {
+      if (GetIntPropertyInternal(cfd, *property_info, true, &value)) {
         sum += value;
       } else {
-        ret = false;
-        break;
+        return false;
       }
     }
   }
   *aggregated_value = sum;
-  return ret;
+  return true;
 }
 
 SuperVersion* DBImpl::GetAndRefSuperVersion(ColumnFamilyData* cfd) {
@@ -3461,14 +3371,14 @@ Status DBImpl::DeleteFile(std::string name) {
   FileType type;
   WalFileType log_type;
   if (!ParseFileName(name, &number, &type, &log_type) ||
-      (type != kTableFile && type != kWalFile)) {
+      (type != kTableFile && type != kLogFile)) {
     ROCKS_LOG_ERROR(immutable_db_options_.info_log, "DeleteFile %s failed.\n",
                     name.c_str());
     return Status::InvalidArgument("Invalid file name");
   }
 
   Status status;
-  if (type == kWalFile) {
+  if (type == kLogFile) {
     // Only allow deleting archived log files
     if (log_type != kArchivedLogFile) {
       ROCKS_LOG_ERROR(immutable_db_options_.info_log,
@@ -3893,7 +3803,7 @@ Status DestroyDB(const std::string& dbname, const Options& options,
         std::string path_to_delete = dbname + "/" + fname;
         if (type == kMetaDatabase) {
           del = DestroyDB(path_to_delete, options);
-        } else if (type == kTableFile || type == kWalFile) {
+        } else if (type == kTableFile || type == kLogFile) {
           del = DeleteDBFile(&soptions, path_to_delete, dbname,
                              /*force_bg=*/false, /*force_fg=*/!wal_in_db_path);
         } else {
@@ -3947,7 +3857,7 @@ Status DestroyDB(const std::string& dbname, const Options& options,
     if (env->GetChildren(archivedir, &archiveFiles).ok()) {
       // Delete archival files.
       for (const auto& file : archiveFiles) {
-        if (ParseFileName(file, &number, &type) && type == kWalFile) {
+        if (ParseFileName(file, &number, &type) && type == kLogFile) {
           Status del =
               DeleteDBFile(&soptions, archivedir + "/" + file, archivedir,
                            /*force_bg=*/false, /*force_fg=*/!wal_in_db_path);
@@ -3963,7 +3873,7 @@ Status DestroyDB(const std::string& dbname, const Options& options,
     // Delete log files in the WAL dir
     if (wal_dir_exists) {
       for (const auto& file : walDirFiles) {
-        if (ParseFileName(file, &number, &type) && type == kWalFile) {
+        if (ParseFileName(file, &number, &type) && type == kLogFile) {
           Status del =
               DeleteDBFile(&soptions, LogFileName(soptions.wal_dir, number),
                            soptions.wal_dir, /*force_bg=*/false,
@@ -4587,9 +4497,7 @@ Status DBImpl::IngestExternalFiles(
       // be pessimistic and try write to a new MANIFEST.
       // TODO: distinguish between MANIFEST write and CURRENT renaming
       const IOStatus& io_s = versions_->io_status();
-      // Should handle return error?
-      error_handler_.SetBGError(io_s, BackgroundErrorReason::kManifestWrite)
-          .PermitUncheckedError();
+      error_handler_.SetBGError(io_s, BackgroundErrorReason::kManifestWrite);
     }
 
     // Resume writes to the DB
@@ -4744,43 +4652,15 @@ Status DBImpl::CreateColumnFamilyWithImport(
 
   import_job.Cleanup(status);
   if (!status.ok()) {
-    Status temp_s = DropColumnFamily(*handle);
-    if (!temp_s.ok()) {
-      ROCKS_LOG_ERROR(immutable_db_options_.info_log,
-                      "DropColumnFamily failed with error %s",
-                      temp_s.ToString().c_str());
-    }
-    // Always returns Status::OK()
-    temp_s = DestroyColumnFamilyHandle(*handle);
-    assert(temp_s.ok());
+    DropColumnFamily(*handle);
+    DestroyColumnFamilyHandle(*handle);
     *handle = nullptr;
   }
   return status;
 }
 
-Status DBImpl::VerifyFileChecksums(const ReadOptions& read_options) {
-  return VerifyChecksumInternal(read_options, /*use_file_checksum=*/true);
-}
-
 Status DBImpl::VerifyChecksum(const ReadOptions& read_options) {
-  return VerifyChecksumInternal(read_options, /*use_file_checksum=*/false);
-}
-
-Status DBImpl::VerifyChecksumInternal(const ReadOptions& read_options,
-                                      bool use_file_checksum) {
   Status s;
-
-  if (use_file_checksum) {
-    FileChecksumGenFactory* const file_checksum_gen_factory =
-        immutable_db_options_.file_checksum_gen_factory.get();
-    if (!file_checksum_gen_factory) {
-      s = Status::InvalidArgument(
-          "Cannot verify file checksum if options.file_checksum_gen_factory is "
-          "null");
-      return s;
-    }
-  }
-
   std::vector<ColumnFamilyData*> cfd_list;
   {
     InstrumentedMutexLock l(&mutex_);
@@ -4795,12 +4675,11 @@ Status DBImpl::VerifyChecksumInternal(const ReadOptions& read_options,
   for (auto cfd : cfd_list) {
     sv_list.push_back(cfd->GetReferencedSuperVersion(this));
   }
-
   for (auto& sv : sv_list) {
     VersionStorageInfo* vstorage = sv->current->storage_info();
     ColumnFamilyData* cfd = sv->current->cfd();
     Options opts;
-    if (!use_file_checksum) {
+    {
       InstrumentedMutexLock l(&mutex_);
       opts = Options(BuildDBOptions(immutable_db_options_, mutable_db_options_),
                      cfd->GetLatestCFOptions());
@@ -4808,18 +4687,11 @@ Status DBImpl::VerifyChecksumInternal(const ReadOptions& read_options,
     for (int i = 0; i < vstorage->num_non_empty_levels() && s.ok(); i++) {
       for (size_t j = 0; j < vstorage->LevelFilesBrief(i).num_files && s.ok();
            j++) {
-        const auto& fd_with_krange = vstorage->LevelFilesBrief(i).files[j];
-        const auto& fd = fd_with_krange.fd;
-        const FileMetaData* fmeta = fd_with_krange.file_metadata;
-        assert(fmeta);
+        const auto& fd = vstorage->LevelFilesBrief(i).files[j].fd;
         std::string fname = TableFileName(cfd->ioptions()->cf_paths,
                                           fd.GetNumber(), fd.GetPathId());
-        if (use_file_checksum) {
-          s = VerifySstFileChecksum(*fmeta, fname, read_options);
-        } else {
-          s = ROCKSDB_NAMESPACE::VerifySstFileChecksum(opts, file_options_,
-                                                       read_options, fname);
-        }
+        s = ROCKSDB_NAMESPACE::VerifySstFileChecksum(opts, file_options_,
+                                                     read_options, fname);
       }
     }
     if (!s.ok()) {
@@ -4850,34 +4722,6 @@ Status DBImpl::VerifyChecksumInternal(const ReadOptions& read_options,
   return s;
 }
 
-Status DBImpl::VerifySstFileChecksum(const FileMetaData& fmeta,
-                                     const std::string& fname,
-                                     const ReadOptions& read_options) {
-  Status s;
-  if (fmeta.file_checksum == kUnknownFileChecksum) {
-    return s;
-  }
-  std::string file_checksum;
-  std::string func_name;
-  s = ROCKSDB_NAMESPACE::GenerateOneFileChecksum(
-      fs_.get(), fname, immutable_db_options_.file_checksum_gen_factory.get(),
-      fmeta.file_checksum_func_name, &file_checksum, &func_name,
-      read_options.readahead_size, immutable_db_options_.allow_mmap_reads,
-      io_tracer_);
-  if (s.ok()) {
-    assert(fmeta.file_checksum_func_name == func_name);
-    if (file_checksum != fmeta.file_checksum) {
-      std::ostringstream oss;
-      oss << fname << " file checksum mismatch, ";
-      oss << "expecting " << Slice(fmeta.file_checksum).ToString(/*hex=*/true);
-      oss << ", but actual " << Slice(file_checksum).ToString(/*hex=*/true);
-      s = Status::Corruption(oss.str());
-      TEST_SYNC_POINT_CALLBACK("DBImpl::VerifySstFileChecksum:mismatch", &s);
-    }
-  }
-  return s;
-}
-
 void DBImpl::NotifyOnExternalFileIngested(
     ColumnFamilyData* cfd, const ExternalSstFileIngestionJob& ingestion_job) {
   if (immutable_db_options_.listeners.empty()) {

db/db_impl/db_impl.h

@@ -70,9 +70,9 @@ class ArenaWrappedDBIter;
 class InMemoryStatsHistoryIterator;
 class MemTable;
 class PersistentStatsHistoryIterator;
-class PeriodicWorkScheduler;
+class StatsDumpScheduler;
 #ifndef NDEBUG
-class PeriodicWorkTestScheduler;
+class StatsDumpTestScheduler;
 #endif  // !NDEBUG
 class TableCache;
 class TaskLimiterToken;
@@ -431,28 +431,8 @@ class DBImpl : public DB {
       const ExportImportFilesMetaData& metadata,
       ColumnFamilyHandle** handle) override;
 
-  using DB::VerifyFileChecksums;
-  Status VerifyFileChecksums(const ReadOptions& read_options) override;
-
   using DB::VerifyChecksum;
   virtual Status VerifyChecksum(const ReadOptions& /*read_options*/) override;
-  // Verify the checksums of files in db. Currently only tables are checked.
-  //
-  // read_options: controls file I/O behavior, e.g. read ahead size while
-  //               reading all the live table files.
-  //
-  // use_file_checksum: if false, verify the block checksums of all live table
-  //                    in db. Otherwise, obtain the file checksums and compare
-  //                    with the MANIFEST. Currently, file checksums are
-  //                    recomputed by reading all table files.
-  //
-  // Returns: OK if there is no file whose file or block checksum mismatches.
-  Status VerifyChecksumInternal(const ReadOptions& read_options,
-                                bool use_file_checksum);
-
-  Status VerifySstFileChecksum(const FileMetaData& fmeta,
-                               const std::string& fpath,
-                               const ReadOptions& read_options);
 
   using DB::StartTrace;
   virtual Status StartTrace(
@@ -1022,7 +1002,7 @@ class DBImpl : public DB {
   }
 
 #ifndef ROCKSDB_LITE
-  PeriodicWorkTestScheduler* TEST_GetPeriodicWorkScheduler() const;
+  StatsDumpTestScheduler* TEST_GetStatsDumpScheduler() const;
 #endif  // !ROCKSDB_LITE
 
 #endif  // NDEBUG
@@ -1033,9 +1013,6 @@ class DBImpl : public DB {
   // dump rocksdb.stats to LOG
   void DumpStats();
 
-  // flush LOG out of application buffer
-  void FlushInfoLog();
-
  protected:
   const std::string dbname_;
   std::string db_id_;
@@ -1209,28 +1186,20 @@ class DBImpl : public DB {
   // skipped.
   virtual Status Recover(
       const std::vector<ColumnFamilyDescriptor>& column_families,
-      bool read_only = false, bool error_if_wal_file_exists = false,
-      bool error_if_data_exists_in_wals = false,
+      bool read_only = false, bool error_if_log_file_exist = false,
+      bool error_if_data_exists_in_logs = false,
       uint64_t* recovered_seq = nullptr);
 
   virtual bool OwnTablesAndLogs() const { return true; }
 
-  // Set DB identity file, and write DB ID to manifest if necessary.
-  Status SetDBId();
-
   // REQUIRES: db mutex held when calling this function, but the db mutex can
   // be released and re-acquired. Db mutex will be held when the function
   // returns.
-  // After recovery, there may be SST files in db/cf paths that are
-  // not referenced in the MANIFEST (e.g.
-  // 1. It's best effort recovery;
-  // 2. The VersionEdits referencing the SST files are appended to
-  // MANIFEST, DB crashes when syncing the MANIFEST, the VersionEdits are
-  // still not synced to MANIFEST during recovery.)
-  // We delete these SST files. In the
+  // After best-efforts recovery, there may be SST files in db/cf paths that are
+  // not referenced in the MANIFEST. We delete these SST files. In the
   // meantime, we find out the largest file number present in the paths, and
   // bump up the version set's next_file_number_ to be 1 + largest_file_number.
-  Status DeleteUnreferencedSstFiles();
+  Status FinishBestEffortsRecovery();
 
   // SetDbSessionId() should be called in the constuctor DBImpl()
   // to ensure that db_session_id_ gets updated every time the DB is opened
@@ -1683,7 +1652,7 @@ class DBImpl : public DB {
                               LogBuffer* log_buffer);
 
   // Schedule background tasks
-  void StartPeriodicWorkScheduler();
+  void StartStatsDumpScheduler();
 
   void PrintStatistics();
 
@@ -1710,9 +1679,7 @@ class DBImpl : public DB {
       std::unique_ptr<TaskLimiterToken>* token, LogBuffer* log_buffer);
 
   // helper function to call after some of the logs_ were synced
-  Status MarkLogsSynced(uint64_t up_to, bool synced_dir);
-  // WALs with log number up to up_to are not synced successfully.
-  void MarkLogsNotSynced(uint64_t up_to);
+  void MarkLogsSynced(uint64_t up_to, bool synced_dir, const Status& status);
 
   SnapshotImpl* GetSnapshotImpl(bool is_write_conflict_boundary,
                                 bool lock = true);
@@ -2144,11 +2111,10 @@ class DBImpl : public DB {
   std::unique_ptr<PreReleaseCallback> recoverable_state_pre_release_callback_;
 
 #ifndef ROCKSDB_LITE
-  // Scheduler to run DumpStats(), PersistStats(), and FlushInfoLog().
-  // Currently, it always use a global instance from
-  // PeriodicWorkScheduler::Default(). Only in unittest, it can be overrided by
-  // PeriodicWorkTestScheduler.
-  PeriodicWorkScheduler* periodic_work_scheduler_;
+  // Scheduler to run DumpStats() and PersistStats(). Currently, it always use
+  // a global instance from StatsDumpScheduler::Default(). Only in unittest, it
+  // can be overrided by StatsDumpTestSchduler.
+  StatsDumpScheduler* stats_dump_scheduler_;
 #endif
 
   // When set, we use a separate queue for writes that don't write to memtable.
@@ -2214,18 +2180,12 @@ extern CompressionType GetCompressionFlush(
 // `memtables_to_flush`) will be flushed and thus will not depend on any WAL
 // file.
 // The function is only applicable to 2pc mode.
-extern uint64_t PrecomputeMinLogNumberToKeep2PC(
+extern uint64_t PrecomputeMinLogNumberToKeep(
     VersionSet* vset, const ColumnFamilyData& cfd_to_flush,
-    const autovector<VersionEdit*>& edit_list,
+    autovector<VersionEdit*> edit_list,
     const autovector<MemTable*>& memtables_to_flush,
     LogsWithPrepTracker* prep_tracker);
 
-// In non-2PC mode, WALs with log number < the returned number can be
-// deleted after the cfd_to_flush column family is flushed successfully.
-extern uint64_t PrecomputeMinLogNumberToKeepNon2PC(
-    VersionSet* vset, const ColumnFamilyData& cfd_to_flush,
-    const autovector<VersionEdit*>& edit_list);
-
 // `cfd_to_flush` is the column family whose memtable will be flushed and thus
 // will not depend on any WAL file. nullptr means no memtable is being flushed.
 // The function is only applicable to 2pc mode.

db/db_impl/db_impl_compaction_flush.cc

@@ -123,19 +123,13 @@ IOStatus DBImpl::SyncClosedLogs(JobContext* job_context) {
 
     // "number <= current_log_number - 1" is equivalent to
     // "number < current_log_number".
-    if (io_s.ok()) {
-      io_s = status_to_io_status(MarkLogsSynced(current_log_number - 1, true));
-    } else {
-      MarkLogsNotSynced(current_log_number - 1);
-    }
+    MarkLogsSynced(current_log_number - 1, true, io_s);
     if (!io_s.ok()) {
       if (total_log_size_ > 0) {
-        error_handler_.SetBGError(io_s, BackgroundErrorReason::kFlush)
-            .PermitUncheckedError();
+        error_handler_.SetBGError(io_s, BackgroundErrorReason::kFlush);
       } else {
         // If the WAL is empty, we use different error reason
-        error_handler_.SetBGError(io_s, BackgroundErrorReason::kFlushNoWAL)
-            .PermitUncheckedError();
+        error_handler_.SetBGError(io_s, BackgroundErrorReason::kFlushNoWAL);
       }
       TEST_SYNC_POINT("DBImpl::SyncClosedLogs:Failed");
       return io_s;
@@ -153,7 +147,6 @@ Status DBImpl::FlushMemTableToOutputFile(
     SnapshotChecker* snapshot_checker, LogBuffer* log_buffer,
     Env::Priority thread_pri) {
   mutex_.AssertHeld();
-  assert(cfd);
   assert(cfd->imm()->NumNotFlushed() != 0);
   assert(cfd->imm()->IsFlushPending());
 
@@ -192,8 +185,7 @@ Status DBImpl::FlushMemTableToOutputFile(
     s = io_s;
     if (!io_s.ok() && !io_s.IsShutdownInProgress() &&
         !io_s.IsColumnFamilyDropped()) {
-      error_handler_.SetBGError(io_s, BackgroundErrorReason::kFlush)
-          .PermitUncheckedError();
+      error_handler_.SetBGError(io_s, BackgroundErrorReason::kFlush);
     }
   } else {
     TEST_SYNC_POINT("DBImpl::SyncClosedLogs:Skip");
@@ -220,28 +212,10 @@ Status DBImpl::FlushMemTableToOutputFile(
     if (made_progress) {
       *made_progress = true;
     }
-
-    const std::string& column_family_name = cfd->GetName();
-
-    Version* const current = cfd->current();
-    assert(current);
-
-    const VersionStorageInfo* const storage_info = current->storage_info();
-    assert(storage_info);
-
     VersionStorageInfo::LevelSummaryStorage tmp;
     ROCKS_LOG_BUFFER(log_buffer, "[%s] Level summary: %s\n",
-                     column_family_name.c_str(),
-                     storage_info->LevelSummary(&tmp));
-
-    const auto& blob_files = storage_info->GetBlobFiles();
-    if (!blob_files.empty()) {
-      ROCKS_LOG_BUFFER(log_buffer,
-                       "[%s] Blob file summary: head=%" PRIu64 ", tail=%" PRIu64
-                       "\n",
-                       column_family_name.c_str(), blob_files.begin()->first,
-                       blob_files.rbegin()->first);
-    }
+                     cfd->GetName().c_str(),
+                     cfd->current()->storage_info()->LevelSummary(&tmp));
   }
 
   if (!s.ok() && !s.IsShutdownInProgress() && !s.IsColumnFamilyDropped()) {
@@ -253,24 +227,16 @@ Status DBImpl::FlushMemTableToOutputFile(
       // be pessimistic and try write to a new MANIFEST.
       // TODO: distinguish between MANIFEST write and CURRENT renaming
       if (!versions_->io_status().ok()) {
-        // Should handle return error?
-        error_handler_.SetBGError(io_s, BackgroundErrorReason::kManifestWrite)
-            .PermitUncheckedError();
+        error_handler_.SetBGError(io_s, BackgroundErrorReason::kManifestWrite);
       } else if (total_log_size_ > 0) {
-        // Should handle return error?
-        error_handler_.SetBGError(io_s, BackgroundErrorReason::kFlush)
-            .PermitUncheckedError();
+        error_handler_.SetBGError(io_s, BackgroundErrorReason::kFlush);
       } else {
         // If the WAL is empty, we use different error reason
-        // Should handle return error?
-        error_handler_.SetBGError(io_s, BackgroundErrorReason::kFlushNoWAL)
-            .PermitUncheckedError();
+        error_handler_.SetBGError(io_s, BackgroundErrorReason::kFlushNoWAL);
       }
     } else {
       Status new_bg_error = s;
-      // Should handle return error?
-      error_handler_.SetBGError(new_bg_error, BackgroundErrorReason::kFlush)
-          .PermitUncheckedError();
+      error_handler_.SetBGError(new_bg_error, BackgroundErrorReason::kFlush);
     }
   } else {
     // If we got here, then we decided not to care about the i_os status (either
@@ -295,9 +261,7 @@ Status DBImpl::FlushMemTableToOutputFile(
         TEST_SYNC_POINT_CALLBACK(
             "DBImpl::FlushMemTableToOutputFile:MaxAllowedSpaceReached",
             &new_bg_error);
-        // Should handle this error?
-        error_handler_.SetBGError(new_bg_error, BackgroundErrorReason::kFlush)
-            .PermitUncheckedError();
+        error_handler_.SetBGError(new_bg_error, BackgroundErrorReason::kFlush);
       }
     }
 #endif  // ROCKSDB_LITE
@@ -593,36 +557,16 @@ Status DBImpl::AtomicFlushMemTablesToOutputFiles(
     assert(num_cfs ==
            static_cast<int>(job_context->superversion_contexts.size()));
     for (int i = 0; i != num_cfs; ++i) {
-      assert(cfds[i]);
-
       if (cfds[i]->IsDropped()) {
         continue;
       }
       InstallSuperVersionAndScheduleWork(cfds[i],
                                          &job_context->superversion_contexts[i],
                                          all_mutable_cf_options[i]);
-
-      const std::string& column_family_name = cfds[i]->GetName();
-
-      Version* const current = cfds[i]->current();
-      assert(current);
-
-      const VersionStorageInfo* const storage_info = current->storage_info();
-      assert(storage_info);
-
       VersionStorageInfo::LevelSummaryStorage tmp;
       ROCKS_LOG_BUFFER(log_buffer, "[%s] Level summary: %s\n",
-                       column_family_name.c_str(),
-                       storage_info->LevelSummary(&tmp));
-
-      const auto& blob_files = storage_info->GetBlobFiles();
-      if (!blob_files.empty()) {
-        ROCKS_LOG_BUFFER(log_buffer,
-                         "[%s] Blob file summary: head=%" PRIu64
-                         ", tail=%" PRIu64 "\n",
-                         column_family_name.c_str(), blob_files.begin()->first,
-                         blob_files.rbegin()->first);
-      }
+                       cfds[i]->GetName().c_str(),
+                       cfds[i]->current()->storage_info()->LevelSummary(&tmp));
     }
     if (made_progress) {
       *made_progress = true;
@@ -645,9 +589,8 @@ Status DBImpl::AtomicFlushMemTablesToOutputFiles(
             error_handler_.GetBGError().ok()) {
           Status new_bg_error =
               Status::SpaceLimit("Max allowed space was reached");
-          // Should Handle this error?
-          error_handler_.SetBGError(new_bg_error, BackgroundErrorReason::kFlush)
-              .PermitUncheckedError();
+          error_handler_.SetBGError(new_bg_error,
+                                    BackgroundErrorReason::kFlush);
         }
       }
     }
@@ -664,24 +607,16 @@ Status DBImpl::AtomicFlushMemTablesToOutputFiles(
       // be pessimistic and try write to a new MANIFEST.
       // TODO: distinguish between MANIFEST write and CURRENT renaming
       if (!versions_->io_status().ok()) {
-        // Should Handle this error?
-        error_handler_.SetBGError(io_s, BackgroundErrorReason::kManifestWrite)
-            .PermitUncheckedError();
+        error_handler_.SetBGError(io_s, BackgroundErrorReason::kManifestWrite);
       } else if (total_log_size_ > 0) {
-        // Should Handle this error?
-        error_handler_.SetBGError(io_s, BackgroundErrorReason::kFlush)
-            .PermitUncheckedError();
+        error_handler_.SetBGError(io_s, BackgroundErrorReason::kFlush);
       } else {
         // If the WAL is empty, we use different error reason
-        // Should Handle this error?
-        error_handler_.SetBGError(io_s, BackgroundErrorReason::kFlushNoWAL)
-            .PermitUncheckedError();
+        error_handler_.SetBGError(io_s, BackgroundErrorReason::kFlushNoWAL);
       }
     } else {
       Status new_bg_error = s;
-      // Should Handle this error?
-      error_handler_.SetBGError(new_bg_error, BackgroundErrorReason::kFlush)
-          .PermitUncheckedError();
+      error_handler_.SetBGError(new_bg_error, BackgroundErrorReason::kFlush);
     }
   }
 
@@ -796,9 +731,7 @@ Status DBImpl::CompactRange(const CompactRangeOptions& options,
     // changes to RangesOverlapWithMemtables.
     Range range(*begin, *end);
     SuperVersion* super_version = cfd->GetReferencedSuperVersion(this);
-    cfd->RangesOverlapWithMemtables({range}, super_version,
-                                    immutable_db_options_.allow_data_in_errors,
-                                    &flush_needed);
+    cfd->RangesOverlapWithMemtables({range}, super_version, &flush_needed);
     CleanupSuperVersion(super_version);
   }
 
@@ -879,7 +812,6 @@ Status DBImpl::CompactRange(const CompactRangeOptions& options,
       int output_level;
       for (int level = first_overlapped_level; level <= max_overlapped_level;
            level++) {
-        bool disallow_trivial_move = false;
         // in case the compaction is universal or if we're compacting the
         // bottom-most level, the output level will be the same as input one.
         // level 0 can never be the bottommost level (i.e. if all files are in
@@ -912,19 +844,9 @@ Status DBImpl::CompactRange(const CompactRangeOptions& options,
               level == 0) {
             output_level = ColumnFamilyData::kCompactToBaseLevel;
           }
-          // if it's a BottommostLevel compaction and `kForce*` compaction is
-          // set, disallow trivial move
-          if (level == max_overlapped_level &&
-              (options.bottommost_level_compaction ==
-                   BottommostLevelCompaction::kForce ||
-               options.bottommost_level_compaction ==
-                   BottommostLevelCompaction::kForceOptimized)) {
-            disallow_trivial_move = true;
-          }
         }
         s = RunManualCompaction(cfd, level, output_level, options, begin, end,
-                                exclusive, disallow_trivial_move,
-                                max_file_num_to_ignore);
+                                exclusive, false, max_file_num_to_ignore);
         if (!s.ok()) {
           break;
         }
@@ -955,9 +877,7 @@ Status DBImpl::CompactRange(const CompactRangeOptions& options,
       TEST_SYNC_POINT("DBImpl::CompactRange:PreRefitLevel");
       s = ReFitLevel(cfd, final_output_level, options.target_level);
       TEST_SYNC_POINT("DBImpl::CompactRange:PostRefitLevel");
-      // ContinueBackgroundWork always return Status::OK().
-      Status temp_s = ContinueBackgroundWork();
-      assert(temp_s.ok());
+      ContinueBackgroundWork();
     }
     EnableManualCompaction();
   }
@@ -1153,10 +1073,9 @@ Status DBImpl::CompactFilesImpl(
       job_context->job_id, c.get(), immutable_db_options_,
       file_options_for_compaction_, versions_.get(), &shutting_down_,
       preserve_deletes_seqnum_.load(), log_buffer, directories_.GetDbDir(),
-      GetDataDir(c->column_family_data(), c->output_path_id()),
-      GetDataDir(c->column_family_data(), 0), stats_, &mutex_, &error_handler_,
-      snapshot_seqs, earliest_write_conflict_snapshot, snapshot_checker,
-      table_cache_, &event_logger_,
+      GetDataDir(c->column_family_data(), c->output_path_id()), stats_, &mutex_,
+      &error_handler_, snapshot_seqs, earliest_write_conflict_snapshot,
+      snapshot_checker, table_cache_, &event_logger_,
       c->mutable_cf_options()->paranoid_file_checks,
       c->mutable_cf_options()->report_bg_io_stats, dbname_,
       &compaction_job_stats, Env::Priority::USER, io_tracer_,
@@ -1181,15 +1100,10 @@ Status DBImpl::CompactFilesImpl(
 
   Status status = compaction_job.Install(*c->mutable_cf_options());
   if (status.ok()) {
-    assert(compaction_job.io_status().ok());
     InstallSuperVersionAndScheduleWork(c->column_family_data(),
                                        &job_context->superversion_contexts[0],
                                        *c->mutable_cf_options());
   }
-  // status above captures any error during compaction_job.Install, so its ok
-  // not check compaction_job.io_status() explicitly if we're not calling
-  // SetBGError
-  compaction_job.io_status().PermitUncheckedError();
   c->ReleaseCompactionFiles(s);
 #ifndef ROCKSDB_LITE
   // Need to make sure SstFileManager does its bookkeeping
@@ -1224,11 +1138,9 @@ Status DBImpl::CompactFilesImpl(
                    job_context->job_id, status.ToString().c_str());
     IOStatus io_s = compaction_job.io_status();
     if (!io_s.ok()) {
-      error_handler_.SetBGError(io_s, BackgroundErrorReason::kCompaction)
-          .PermitUncheckedError();
+      error_handler_.SetBGError(io_s, BackgroundErrorReason::kCompaction);
     } else {
-      error_handler_.SetBGError(status, BackgroundErrorReason::kCompaction)
-          .PermitUncheckedError();
+      error_handler_.SetBGError(status, BackgroundErrorReason::kCompaction);
     }
   }
 
@@ -1309,7 +1221,6 @@ void DBImpl::NotifyOnCompactionBegin(ColumnFamilyData* cfd, Compaction* c,
     for (auto listener : immutable_db_options_.listeners) {
       listener->OnCompactionBegin(this, info);
     }
-    info.status.PermitUncheckedError();
   }
   mutex_.Lock();
   current->Unref();
@@ -1396,14 +1307,12 @@ Status DBImpl::ReFitLevel(ColumnFamilyData* cfd, int level, int target_level) {
   if (to_level != level) {
     if (to_level > level) {
       if (level == 0) {
-        refitting_level_ = false;
         return Status::NotSupported(
             "Cannot change from level 0 to other levels.");
       }
       // Check levels are empty for a trivial move
       for (int l = level + 1; l <= to_level; l++) {
         if (vstorage->NumLevelFiles(l) > 0) {
-          refitting_level_ = false;
           return Status::NotSupported(
               "Levels between source and target are not empty for a move.");
         }
@@ -1413,7 +1322,6 @@ Status DBImpl::ReFitLevel(ColumnFamilyData* cfd, int level, int target_level) {
       // Check levels are empty for a trivial move
       for (int l = to_level; l < level; l++) {
         if (vstorage->NumLevelFiles(l) > 0) {
-          refitting_level_ = false;
           return Status::NotSupported(
               "Levels between source and target are not empty for a move.");
         }
@@ -2961,11 +2869,10 @@ Status DBImpl::BackgroundCompaction(bool* made_progress,
         job_context->job_id, c.get(), immutable_db_options_,
         file_options_for_compaction_, versions_.get(), &shutting_down_,
         preserve_deletes_seqnum_.load(), log_buffer, directories_.GetDbDir(),
-        GetDataDir(c->column_family_data(), c->output_path_id()),
-        GetDataDir(c->column_family_data(), 0), stats_, &mutex_,
-        &error_handler_, snapshot_seqs, earliest_write_conflict_snapshot,
-        snapshot_checker, table_cache_, &event_logger_,
-        c->mutable_cf_options()->paranoid_file_checks,
+        GetDataDir(c->column_family_data(), c->output_path_id()), stats_,
+        &mutex_, &error_handler_, snapshot_seqs,
+        earliest_write_conflict_snapshot, snapshot_checker, table_cache_,
+        &event_logger_, c->mutable_cf_options()->paranoid_file_checks,
         c->mutable_cf_options()->report_bg_io_stats, dbname_,
         &compaction_job_stats, thread_pri, io_tracer_,
         is_manual ? &manual_compaction_paused_ : nullptr, db_id_,
@@ -2974,11 +2881,11 @@ Status DBImpl::BackgroundCompaction(bool* made_progress,
 
     NotifyOnCompactionBegin(c->column_family_data(), c.get(), status,
                             compaction_job_stats, job_context->job_id);
+
     mutex_.Unlock();
     TEST_SYNC_POINT_CALLBACK(
         "DBImpl::BackgroundCompaction:NonTrivial:BeforeRun", nullptr);
-    // Should handle erorr?
-    compaction_job.Run().PermitUncheckedError();
+    compaction_job.Run();
     TEST_SYNC_POINT("DBImpl::BackgroundCompaction:NonTrivial:AfterRun");
     mutex_.Lock();
 
@@ -2996,8 +2903,6 @@ Status DBImpl::BackgroundCompaction(bool* made_progress,
 
   if (status.ok() && !io_s.ok()) {
     status = io_s;
-  } else {
-    io_s.PermitUncheckedError();
   }
 
   if (c != nullptr) {
@@ -3034,10 +2939,9 @@ Status DBImpl::BackgroundCompaction(bool* made_progress,
       auto err_reason = versions_->io_status().ok()
                             ? BackgroundErrorReason::kCompaction
                             : BackgroundErrorReason::kManifestWrite;
-      error_handler_.SetBGError(io_s, err_reason).PermitUncheckedError();
+      error_handler_.SetBGError(io_s, err_reason);
     } else {
-      error_handler_.SetBGError(status, BackgroundErrorReason::kCompaction)
-          .PermitUncheckedError();
+      error_handler_.SetBGError(status, BackgroundErrorReason::kCompaction);
     }
     if (c != nullptr && !is_manual && !error_handler_.IsBGWorkStopped()) {
       // Put this cfd back in the compaction queue so we can retry after some

db/db_impl/db_impl_debug.cc

@@ -12,7 +12,7 @@
 #include "db/column_family.h"
 #include "db/db_impl/db_impl.h"
 #include "db/error_handler.h"
-#include "db/periodic_work_scheduler.h"
+#include "monitoring/stats_dump_scheduler.h"
 #include "monitoring/thread_status_updater.h"
 #include "util/cast_util.h"
 
@@ -274,14 +274,14 @@ size_t DBImpl::TEST_GetWalPreallocateBlockSize(
 
 #ifndef ROCKSDB_LITE
 void DBImpl::TEST_WaitForStatsDumpRun(std::function<void()> callback) const {
-  if (periodic_work_scheduler_ != nullptr) {
-    static_cast<PeriodicWorkTestScheduler*>(periodic_work_scheduler_)
+  if (stats_dump_scheduler_ != nullptr) {
+    static_cast<StatsDumpTestScheduler*>(stats_dump_scheduler_)
         ->TEST_WaitForRun(callback);
   }
 }
 
-PeriodicWorkTestScheduler* DBImpl::TEST_GetPeriodicWorkScheduler() const {
-  return static_cast<PeriodicWorkTestScheduler*>(periodic_work_scheduler_);
+StatsDumpTestScheduler* DBImpl::TEST_GetStatsDumpScheduler() const {
+  return static_cast<StatsDumpTestScheduler*>(stats_dump_scheduler_);
 }
 #endif  // !ROCKSDB_LITE
 

db/db_impl/db_impl_files.cc

@@ -58,7 +58,7 @@ Status DBImpl::EnableFileDeletions(bool force) {
   // Job id == 0 means that this is not our background process, but rather
   // user thread
   JobContext job_context(0);
-  int saved_counter;  // initialize on all paths
+  bool file_deletion_enabled = false;
   {
     InstrumentedMutexLock l(&mutex_);
     if (force) {
@@ -67,13 +67,13 @@ Status DBImpl::EnableFileDeletions(bool force) {
     } else if (disable_delete_obsolete_files_ > 0) {
       --disable_delete_obsolete_files_;
     }
-    saved_counter = disable_delete_obsolete_files_;
-    if (saved_counter == 0) {
+    if (disable_delete_obsolete_files_ == 0) {
+      file_deletion_enabled = true;
       FindObsoleteFiles(&job_context, true);
       bg_cv_.SignalAll();
     }
   }
-  if (saved_counter == 0) {
+  if (file_deletion_enabled) {
     ROCKS_LOG_INFO(immutable_db_options_.info_log, "File Deletions Enabled");
     if (job_context.HaveSomethingToDelete()) {
       PurgeObsoleteFiles(job_context);
@@ -81,7 +81,7 @@ Status DBImpl::EnableFileDeletions(bool force) {
   } else {
     ROCKS_LOG_WARN(immutable_db_options_.info_log,
                    "File Deletions Enable, but not really enabled. Counter: %d",
-                   saved_counter);
+                   disable_delete_obsolete_files_);
   }
   job_context.Clean();
   LogFlush(immutable_db_options_.info_log);
@@ -215,8 +215,7 @@ void DBImpl::FindObsoleteFiles(JobContext* job_context, bool force,
     if (immutable_db_options_.wal_dir != dbname_) {
       std::vector<std::string> log_files;
       env_->GetChildren(immutable_db_options_.wal_dir,
-                        &log_files)
-          .PermitUncheckedError();  // Ignore errors
+                        &log_files);  // Ignore errors
       for (const std::string& log_file : log_files) {
         job_context->full_scan_candidate_files.emplace_back(
             log_file, immutable_db_options_.wal_dir);
@@ -227,8 +226,7 @@ void DBImpl::FindObsoleteFiles(JobContext* job_context, bool force,
         immutable_db_options_.db_log_dir != dbname_) {
       std::vector<std::string> info_log_files;
       // Ignore errors
-      env_->GetChildren(immutable_db_options_.db_log_dir, &info_log_files)
-          .PermitUncheckedError();
+      env_->GetChildren(immutable_db_options_.db_log_dir, &info_log_files);
       for (std::string& log_file : info_log_files) {
         job_context->full_scan_candidate_files.emplace_back(
             log_file, immutable_db_options_.db_log_dir);
@@ -319,7 +317,7 @@ void DBImpl::DeleteObsoleteFileImpl(int job_id, const std::string& fname,
                            const_cast<std::string*>(&fname));
 
   Status file_deletion_status;
-  if (type == kTableFile || type == kBlobFile || type == kWalFile) {
+  if (type == kTableFile || type == kBlobFile || type == kLogFile) {
     file_deletion_status =
         DeleteDBFile(&immutable_db_options_, fname, path_to_sync,
                      /*force_bg=*/false, /*force_fg=*/!wal_in_db_path_);
@@ -466,7 +464,7 @@ void DBImpl::PurgeObsoleteFiles(JobContext& state, bool schedule_only) {
 
     bool keep = true;
     switch (type) {
-      case kWalFile:
+      case kLogFile:
         keep = ((number >= state.log_number) ||
                 (number == state.prev_log_number) ||
                 (log_recycle_files_set.find(number) !=
@@ -546,7 +544,7 @@ void DBImpl::PurgeObsoleteFiles(JobContext& state, bool schedule_only) {
       dir_to_sync = candidate_file.file_path;
     } else {
       dir_to_sync =
-          (type == kWalFile) ? immutable_db_options_.wal_dir : dbname_;
+          (type == kLogFile) ? immutable_db_options_.wal_dir : dbname_;
       fname = dir_to_sync +
               ((!dir_to_sync.empty() && dir_to_sync.back() == '/') ||
                        (!to_delete.empty() && to_delete.front() == '/')
@@ -556,7 +554,7 @@ void DBImpl::PurgeObsoleteFiles(JobContext& state, bool schedule_only) {
     }
 
 #ifndef ROCKSDB_LITE
-    if (type == kWalFile && (immutable_db_options_.wal_ttl_seconds > 0 ||
+    if (type == kLogFile && (immutable_db_options_.wal_ttl_seconds > 0 ||
                              immutable_db_options_.wal_size_limit_mb > 0)) {
       wal_manager_.ArchiveWALFile(fname, number);
       continue;
@@ -680,10 +678,16 @@ uint64_t FindMinPrepLogReferencedByMemTable(
   return min_log;
 }
 
-uint64_t PrecomputeMinLogNumberToKeepNon2PC(
+uint64_t PrecomputeMinLogNumberToKeep(
     VersionSet* vset, const ColumnFamilyData& cfd_to_flush,
-    const autovector<VersionEdit*>& edit_list) {
+    autovector<VersionEdit*> edit_list,
+    const autovector<MemTable*>& memtables_to_flush,
+    LogsWithPrepTracker* prep_tracker) {
   assert(vset != nullptr);
+  assert(prep_tracker != nullptr);
+  // Calculate updated min_log_number_to_keep
+  // Since the function should only be called in 2pc mode, log number in
+  // the version edit should be sufficient.
 
   // Precompute the min log number containing unflushed data for the column
   // family being flushed (`cfd_to_flush`).
@@ -707,22 +711,6 @@ uint64_t PrecomputeMinLogNumberToKeepNon2PC(
     min_log_number_to_keep =
         std::min(cf_min_log_number_to_keep, min_log_number_to_keep);
   }
-  return min_log_number_to_keep;
-}
-
-uint64_t PrecomputeMinLogNumberToKeep2PC(
-    VersionSet* vset, const ColumnFamilyData& cfd_to_flush,
-    const autovector<VersionEdit*>& edit_list,
-    const autovector<MemTable*>& memtables_to_flush,
-    LogsWithPrepTracker* prep_tracker) {
-  assert(vset != nullptr);
-  assert(prep_tracker != nullptr);
-  // Calculate updated min_log_number_to_keep
-  // Since the function should only be called in 2pc mode, log number in
-  // the version edit should be sufficient.
-
-  uint64_t min_log_number_to_keep =
-      PrecomputeMinLogNumberToKeepNon2PC(vset, cfd_to_flush, edit_list);
 
   // if are 2pc we must consider logs containing prepared
   // sections of outstanding transactions.
@@ -751,43 +739,7 @@ uint64_t PrecomputeMinLogNumberToKeep2PC(
   return min_log_number_to_keep;
 }
 
-Status DBImpl::SetDBId() {
-  Status s;
-  // Happens when immutable_db_options_.write_dbid_to_manifest is set to true
-  // the very first time.
-  if (db_id_.empty()) {
-    // Check for the IDENTITY file and create it if not there.
-    s = fs_->FileExists(IdentityFileName(dbname_), IOOptions(), nullptr);
-    // Typically Identity file is created in NewDB() and for some reason if
-    // it is no longer available then at this point DB ID is not in Identity
-    // file or Manifest.
-    if (s.IsNotFound()) {
-      s = SetIdentityFile(env_, dbname_);
-      if (!s.ok()) {
-        return s;
-      }
-    } else if (!s.ok()) {
-      assert(s.IsIOError());
-      return s;
-    }
-    s = GetDbIdentityFromIdentityFile(&db_id_);
-    if (immutable_db_options_.write_dbid_to_manifest && s.ok()) {
-      VersionEdit edit;
-      edit.SetDBId(db_id_);
-      Options options;
-      MutableCFOptions mutable_cf_options(options);
-      versions_->db_id_ = db_id_;
-      s = versions_->LogAndApply(versions_->GetColumnFamilySet()->GetDefault(),
-                                 mutable_cf_options, &edit, &mutex_, nullptr,
-                                 /* new_descriptor_log */ false);
-    }
-  } else {
-    s = SetIdentityFile(env_, dbname_, db_id_);
-  }
-  return s;
-}
-
-Status DBImpl::DeleteUnreferencedSstFiles() {
+Status DBImpl::FinishBestEffortsRecovery() {
   mutex_.AssertHeld();
   std::vector<std::string> paths;
   paths.push_back(NormalizePath(dbname_ + std::string(1, kFilePathSeparator)));
@@ -808,13 +760,9 @@ Status DBImpl::DeleteUnreferencedSstFiles() {
   uint64_t next_file_number = versions_->current_next_file_number();
   uint64_t largest_file_number = next_file_number;
   std::set<std::string> files_to_delete;
-  Status s;
   for (const auto& path : paths) {
     std::vector<std::string> files;
-    s = env_->GetChildren(path, &files);
-    if (!s.ok()) {
-      break;
-    }
+    env_->GetChildren(path, &files);
     for (const auto& fname : files) {
       uint64_t number = 0;
       FileType type;
@@ -830,10 +778,6 @@ Status DBImpl::DeleteUnreferencedSstFiles() {
       }
     }
   }
-  if (!s.ok()) {
-    return s;
-  }
-
   if (largest_file_number > next_file_number) {
     versions_->next_file_number_.store(largest_file_number + 1);
   }
@@ -843,7 +787,9 @@ Status DBImpl::DeleteUnreferencedSstFiles() {
   assert(versions_->GetColumnFamilySet());
   ColumnFamilyData* default_cfd = versions_->GetColumnFamilySet()->GetDefault();
   assert(default_cfd);
-  s = versions_->LogAndApply(
+  // Even if new_descriptor_log is false, we will still switch to a new
+  // MANIFEST and update CURRENT file, since this is in recovery.
+  Status s = versions_->LogAndApply(
       default_cfd, *default_cfd->GetLatestMutableCFOptions(), &edit, &mutex_,
       directories_.GetDbDir(), /*new_descriptor_log*/ false);
   if (!s.ok()) {

db/db_impl/db_impl_open.cc

@@ -11,15 +11,15 @@
 #include "db/builder.h"
 #include "db/db_impl/db_impl.h"
 #include "db/error_handler.h"
-#include "db/periodic_work_scheduler.h"
 #include "env/composite_env_wrapper.h"
 #include "file/read_write_util.h"
 #include "file/sst_file_manager_impl.h"
 #include "file/writable_file_writer.h"
 #include "monitoring/persistent_stats_history.h"
+#include "monitoring/stats_dump_scheduler.h"
 #include "options/options_helper.h"
-#include "rocksdb/table.h"
 #include "rocksdb/wal_filter.h"
+#include "table/block_based/block_based_table_factory.h"
 #include "test_util/sync_point.h"
 #include "util/rate_limiter.h"
 
@@ -185,12 +185,12 @@ DBOptions SanitizeOptions(const std::string& dbname, const DBOptions& src) {
 }
 
 namespace {
-Status ValidateOptionsByTable(
+Status SanitizeOptionsByTable(
     const DBOptions& db_opts,
     const std::vector<ColumnFamilyDescriptor>& column_families) {
   Status s;
   for (auto cf : column_families) {
-    s = ValidateOptions(db_opts, cf.options);
+    s = cf.options.table_factory->SanitizeOptions(db_opts, cf.options);
     if (!s.ok()) {
       return s;
     }
@@ -364,7 +364,7 @@ IOStatus Directories::SetDirectories(FileSystem* fs, const std::string& dbname,
 
 Status DBImpl::Recover(
     const std::vector<ColumnFamilyDescriptor>& column_families, bool read_only,
-    bool error_if_wal_file_exists, bool error_if_data_exists_in_wals,
+    bool error_if_log_file_exist, bool error_if_data_exists_in_logs,
     uint64_t* recovered_seq) {
   mutex_.AssertHeld();
 
@@ -401,7 +401,7 @@ Status DBImpl::Recover(
       }
       for (const std::string& file : files_in_dbname) {
         uint64_t number = 0;
-        FileType type = kWalFile;  // initialize
+        FileType type = kLogFile;  // initialize
         if (ParseFileName(file, &number, &type) && type == kDescriptorFile) {
           // Found MANIFEST (descriptor log), thus best-efforts recovery does
           // not have to treat the db as empty.
@@ -479,14 +479,42 @@ Status DBImpl::Recover(
       // TryRecover may delete previous column_family_set_.
       column_family_memtables_.reset(
           new ColumnFamilyMemTablesImpl(versions_->GetColumnFamilySet()));
+      s = FinishBestEffortsRecovery();
     }
   }
   if (!s.ok()) {
     return s;
   }
-  s = SetDBId();
-  if (s.ok() && !read_only) {
-    s = DeleteUnreferencedSstFiles();
+  // Happens when immutable_db_options_.write_dbid_to_manifest is set to true
+  // the very first time.
+  if (db_id_.empty()) {
+    // Check for the IDENTITY file and create it if not there.
+    s = fs_->FileExists(IdentityFileName(dbname_), IOOptions(), nullptr);
+    // Typically Identity file is created in NewDB() and for some reason if
+    // it is no longer available then at this point DB ID is not in Identity
+    // file or Manifest.
+    if (s.IsNotFound()) {
+      s = SetIdentityFile(env_, dbname_);
+      if (!s.ok()) {
+        return s;
+      }
+    } else if (!s.ok()) {
+      assert(s.IsIOError());
+      return s;
+    }
+    s = GetDbIdentityFromIdentityFile(&db_id_);
+    if (immutable_db_options_.write_dbid_to_manifest && s.ok()) {
+      VersionEdit edit;
+      edit.SetDBId(db_id_);
+      Options options;
+      MutableCFOptions mutable_cf_options(options);
+      versions_->db_id_ = db_id_;
+      s = versions_->LogAndApply(versions_->GetColumnFamilySet()->GetDefault(),
+                             mutable_cf_options, &edit, &mutex_, nullptr,
+                             false);
+    }
+  } else {
+    s = SetIdentityFile(env_, dbname_, db_id_);
   }
 
   if (immutable_db_options_.paranoid_checks && s.ok()) {
@@ -508,7 +536,7 @@ Status DBImpl::Recover(
 
   std::vector<std::string> files_in_wal_dir;
   if (s.ok()) {
-    // Initial max_total_in_memory_state_ before recovery wals. Log recovery
+    // Initial max_total_in_memory_state_ before recovery logs. Log recovery
     // may check this value to decide whether to flush.
     max_total_in_memory_state_ = 0;
     for (auto cfd : *versions_->GetColumnFamilySet()) {
@@ -543,77 +571,50 @@ Status DBImpl::Recover(
       return s;
     }
 
-    std::unordered_map<uint64_t, std::string> wal_files;
+    std::vector<uint64_t> logs;
     for (const auto& file : files_in_wal_dir) {
       uint64_t number;
       FileType type;
-      if (ParseFileName(file, &number, &type) && type == kWalFile) {
+      if (ParseFileName(file, &number, &type) && type == kLogFile) {
         if (is_new_db) {
           return Status::Corruption(
               "While creating a new Db, wal_dir contains "
               "existing log file: ",
               file);
         } else {
-          wal_files[number] =
-              LogFileName(immutable_db_options_.wal_dir, number);
+          logs.push_back(number);
         }
       }
     }
 
-    if (immutable_db_options_.track_and_verify_wals_in_manifest) {
-      if (!immutable_db_options_.best_efforts_recovery) {
-        // Verify WALs in MANIFEST.
-        s = versions_->GetWalSet().CheckWals(env_, wal_files);
-      }  // else since best effort recovery does not recover from WALs, no need
-         // to check WALs.
-    } else if (!versions_->GetWalSet().GetWals().empty()) {
-      // Tracking is disabled, clear previously tracked WALs from MANIFEST,
-      // otherwise, in the future, if WAL tracking is enabled again,
-      // since the WALs deleted when WAL tracking is disabled are not persisted
-      // into MANIFEST, WAL check may fail.
-      VersionEdit edit;
-      WalNumber max_wal_number =
-          versions_->GetWalSet().GetWals().rbegin()->first;
-      edit.DeleteWalsBefore(max_wal_number + 1);
-      s = versions_->LogAndApplyToDefaultColumnFamily(&edit, &mutex_);
-    }
-    if (!s.ok()) {
-      return s;
-    }
-
-    if (!wal_files.empty()) {
-      if (error_if_wal_file_exists) {
+    if (logs.size() > 0) {
+      if (error_if_log_file_exist) {
         return Status::Corruption(
-            "The db was opened in readonly mode with error_if_wal_file_exists"
-            "flag but a WAL file already exists");
-      } else if (error_if_data_exists_in_wals) {
-        for (auto& wal_file : wal_files) {
+            "The db was opened in readonly mode with error_if_log_file_exist"
+            "flag but a log file already exists");
+      } else if (error_if_data_exists_in_logs) {
+        for (auto& log : logs) {
+          std::string fname = LogFileName(immutable_db_options_.wal_dir, log);
           uint64_t bytes;
-          s = env_->GetFileSize(wal_file.second, &bytes);
+          s = env_->GetFileSize(fname, &bytes);
           if (s.ok()) {
             if (bytes > 0) {
               return Status::Corruption(
-                  "error_if_data_exists_in_wals is set but there are data "
-                  " in WAL files.");
+                  "error_if_data_exists_in_logs is set but there are data "
+                  " in log files.");
             }
           }
         }
       }
     }
 
-    if (!wal_files.empty()) {
-      // Recover in the order in which the wals were generated
-      std::vector<uint64_t> wals;
-      wals.reserve(wal_files.size());
-      for (const auto& wal_file : wal_files) {
-        wals.push_back(wal_file.first);
-      }
-      std::sort(wals.begin(), wals.end());
-
-      bool corrupted_wal_found = false;
-      s = RecoverLogFiles(wals, &next_sequence, read_only,
-                          &corrupted_wal_found);
-      if (corrupted_wal_found && recovered_seq != nullptr) {
+    if (!logs.empty()) {
+      // Recover in the order in which the logs were generated
+      std::sort(logs.begin(), logs.end());
+      bool corrupted_log_found = false;
+      s = RecoverLogFiles(logs, &next_sequence, read_only,
+                          &corrupted_log_found);
+      if (corrupted_log_found && recovered_seq != nullptr) {
         *recovered_seq = next_sequence;
       }
       if (!s.ok()) {
@@ -684,56 +685,41 @@ Status DBImpl::PersistentStatsProcessFormatVersion() {
         (kStatsCFCurrentFormatVersion < format_version_recovered &&
          kStatsCFCompatibleFormatVersion < compatible_version_recovered)) {
       if (!s_format.ok() || !s_compatible.ok()) {
-        ROCKS_LOG_WARN(
+        ROCKS_LOG_INFO(
             immutable_db_options_.info_log,
-            "Recreating persistent stats column family since reading "
-            "persistent stats version key failed. Format key: %s, compatible "
-            "key: %s",
+            "Reading persistent stats version key failed. Format key: %s, "
+            "compatible key: %s",
             s_format.ToString().c_str(), s_compatible.ToString().c_str());
       } else {
-        ROCKS_LOG_WARN(
+        ROCKS_LOG_INFO(
             immutable_db_options_.info_log,
-            "Recreating persistent stats column family due to corrupted or "
-            "incompatible format version. Recovered format: %" PRIu64
-            "; recovered format compatible since: %" PRIu64 "\n",
-            format_version_recovered, compatible_version_recovered);
-      }
-      s = DropColumnFamily(persist_stats_cf_handle_);
-      if (s.ok()) {
-        s = DestroyColumnFamilyHandle(persist_stats_cf_handle_);
+            "Disable persistent stats due to corrupted or incompatible format "
+            "version\n");
       }
+      DropColumnFamily(persist_stats_cf_handle_);
+      DestroyColumnFamilyHandle(persist_stats_cf_handle_);
       ColumnFamilyHandle* handle = nullptr;
-      if (s.ok()) {
-        ColumnFamilyOptions cfo;
-        OptimizeForPersistentStats(&cfo);
-        s = CreateColumnFamily(cfo, kPersistentStatsColumnFamilyName, &handle);
-      }
-      if (s.ok()) {
-        persist_stats_cf_handle_ = static_cast<ColumnFamilyHandleImpl*>(handle);
-        // should also persist version here because old stats CF is discarded
-        should_persist_format_version = true;
-      }
+      ColumnFamilyOptions cfo;
+      OptimizeForPersistentStats(&cfo);
+      s = CreateColumnFamily(cfo, kPersistentStatsColumnFamilyName, &handle);
+      persist_stats_cf_handle_ = static_cast<ColumnFamilyHandleImpl*>(handle);
+      // should also persist version here because old stats CF is discarded
+      should_persist_format_version = true;
     }
   }
-  if (should_persist_format_version) {
+  if (s.ok() && should_persist_format_version) {
     // Persistent stats CF being created for the first time, need to write
     // format version key
     WriteBatch batch;
-    if (s.ok()) {
-      s = batch.Put(persist_stats_cf_handle_, kFormatVersionKeyString,
-                    ToString(kStatsCFCurrentFormatVersion));
-    }
-    if (s.ok()) {
-      s = batch.Put(persist_stats_cf_handle_, kCompatibleVersionKeyString,
-                    ToString(kStatsCFCompatibleFormatVersion));
-    }
-    if (s.ok()) {
-      WriteOptions wo;
-      wo.low_pri = true;
-      wo.no_slowdown = true;
-      wo.sync = false;
-      s = Write(wo, &batch);
-    }
+    batch.Put(persist_stats_cf_handle_, kFormatVersionKeyString,
+              ToString(kStatsCFCurrentFormatVersion));
+    batch.Put(persist_stats_cf_handle_, kCompatibleVersionKeyString,
+              ToString(kStatsCFCompatibleFormatVersion));
+    WriteOptions wo;
+    wo.low_pri = true;
+    wo.no_slowdown = true;
+    wo.sync = false;
+    s = Write(wo, &batch);
   }
   mutex_.Lock();
   return s;
@@ -766,10 +752,10 @@ Status DBImpl::InitPersistStatsColumnFamily() {
   return s;
 }
 
-// REQUIRES: wal_numbers are sorted in ascending order
-Status DBImpl::RecoverLogFiles(const std::vector<uint64_t>& wal_numbers,
+// REQUIRES: log_numbers are sorted in ascending order
+Status DBImpl::RecoverLogFiles(const std::vector<uint64_t>& log_numbers,
                                SequenceNumber* next_sequence, bool read_only,
-                               bool* corrupted_wal_found) {
+                               bool* corrupted_log_found) {
   struct LogReporter : public log::Reader::Reporter {
     Env* env;
     Logger* info_log;
@@ -799,10 +785,10 @@ Status DBImpl::RecoverLogFiles(const std::vector<uint64_t>& wal_numbers,
     auto stream = event_logger_.Log();
     stream << "job" << job_id << "event"
            << "recovery_started";
-    stream << "wal_files";
+    stream << "log_files";
     stream.StartArray();
-    for (auto wal_number : wal_numbers) {
-      stream << wal_number;
+    for (auto log_number : log_numbers) {
+      stream << log_number;
     }
     stream.EndArray();
   }
@@ -825,25 +811,25 @@ Status DBImpl::RecoverLogFiles(const std::vector<uint64_t>& wal_numbers,
   bool stop_replay_by_wal_filter = false;
   bool stop_replay_for_corruption = false;
   bool flushed = false;
-  uint64_t corrupted_wal_number = kMaxSequenceNumber;
-  uint64_t min_wal_number = MinLogNumberToKeep();
-  for (auto wal_number : wal_numbers) {
-    if (wal_number < min_wal_number) {
+  uint64_t corrupted_log_number = kMaxSequenceNumber;
+  uint64_t min_log_number = MinLogNumberToKeep();
+  for (auto log_number : log_numbers) {
+    if (log_number < min_log_number) {
       ROCKS_LOG_INFO(immutable_db_options_.info_log,
                      "Skipping log #%" PRIu64
                      " since it is older than min log to keep #%" PRIu64,
-                     wal_number, min_wal_number);
+                     log_number, min_log_number);
       continue;
     }
     // The previous incarnation may not have written any MANIFEST
     // records after allocating this log number.  So we manually
     // update the file number allocation counter in VersionSet.
-    versions_->MarkFileNumberUsed(wal_number);
+    versions_->MarkFileNumberUsed(log_number);
     // Open the log file
-    std::string fname = LogFileName(immutable_db_options_.wal_dir, wal_number);
+    std::string fname = LogFileName(immutable_db_options_.wal_dir, log_number);
 
     ROCKS_LOG_INFO(immutable_db_options_.info_log,
-                   "Recovering log #%" PRIu64 " mode %d", wal_number,
+                   "Recovering log #%" PRIu64 " mode %d", log_number,
                    static_cast<int>(immutable_db_options_.wal_recovery_mode));
     auto logFileDropped = [this, &fname]() {
       uint64_t bytes;
@@ -896,7 +882,7 @@ Status DBImpl::RecoverLogFiles(const std::vector<uint64_t>& wal_numbers,
     // to be skipped instead of propagating bad information (like overly
     // large sequence numbers).
     log::Reader reader(immutable_db_options_.info_log, std::move(file_reader),
-                       &reporter, true /*checksum*/, wal_number);
+                       &reporter, true /*checksum*/, log_number);
 
     // Determine if we should tolerate incomplete records at the tail end of the
     // Read all the records and add to a memtable
@@ -944,7 +930,7 @@ Status DBImpl::RecoverLogFiles(const std::vector<uint64_t>& wal_numbers,
 
         WalFilter::WalProcessingOption wal_processing_option =
             immutable_db_options_.wal_filter->LogRecordFound(
-                wal_number, fname, batch, &new_batch, &batch_changed);
+                log_number, fname, batch, &new_batch, &batch_changed);
 
         switch (wal_processing_option) {
           case WalFilter::WalProcessingOption::kContinueProcessing:
@@ -996,7 +982,7 @@ Status DBImpl::RecoverLogFiles(const std::vector<uint64_t>& wal_numbers,
                 " mode %d log filter %s returned "
                 "more records (%d) than original (%d) which is not allowed. "
                 "Aborting recovery.",
-                wal_number,
+                log_number,
                 static_cast<int>(immutable_db_options_.wal_recovery_mode),
                 immutable_db_options_.wal_filter->Name(), new_count,
                 original_count);
@@ -1023,7 +1009,7 @@ Status DBImpl::RecoverLogFiles(const std::vector<uint64_t>& wal_numbers,
       bool has_valid_writes = false;
       status = WriteBatchInternal::InsertInto(
           &batch, column_family_memtables_.get(), &flush_scheduler_,
-          &trim_history_scheduler_, true, wal_number, this,
+          &trim_history_scheduler_, true, log_number, this,
           false /* concurrent_memtable_writes */, next_sequence,
           &has_valid_writes, seq_per_batch_, batch_per_txn_);
       MaybeIgnoreError(&status);
@@ -1043,7 +1029,7 @@ Status DBImpl::RecoverLogFiles(const std::vector<uint64_t>& wal_numbers,
           cfd->UnrefAndTryDelete();
           // If this asserts, it means that InsertInto failed in
           // filtering updates to already-flushed column families
-          assert(cfd->GetLogNumber() <= wal_number);
+          assert(cfd->GetLogNumber() <= log_number);
           auto iter = version_edits.find(cfd->GetID());
           assert(iter != version_edits.end());
           VersionEdit* edit = &iter->second;
@@ -1080,21 +1066,21 @@ Status DBImpl::RecoverLogFiles(const std::vector<uint64_t>& wal_numbers,
                           " seq #%" PRIu64
                           ". %s. This likely mean loss of synced WAL, "
                           "thus recovery fails.",
-                          wal_number, *next_sequence,
+                          log_number, *next_sequence,
                           status.ToString().c_str());
           return status;
         }
         // We should ignore the error but not continue replaying
         status = Status::OK();
         stop_replay_for_corruption = true;
-        corrupted_wal_number = wal_number;
-        if (corrupted_wal_found != nullptr) {
-          *corrupted_wal_found = true;
+        corrupted_log_number = log_number;
+        if (corrupted_log_found != nullptr) {
+          *corrupted_log_found = true;
         }
         ROCKS_LOG_INFO(immutable_db_options_.info_log,
                        "Point in time recovered to log #%" PRIu64
                        " seq #%" PRIu64,
-                       wal_number, *next_sequence);
+                       log_number, *next_sequence);
       } else {
         assert(immutable_db_options_.wal_recovery_mode ==
                    WALRecoveryMode::kTolerateCorruptedTailRecords ||
@@ -1120,7 +1106,7 @@ Status DBImpl::RecoverLogFiles(const std::vector<uint64_t>& wal_numbers,
   // corruption. This could during PIT recovery when the WAL is corrupted and
   // some (but not all) CFs are flushed
   // Exclude the PIT case where no log is dropped after the corruption point.
-  // This is to cover the case for empty wals after corrupted log, in which we
+  // This is to cover the case for empty logs after corrupted log, in which we
   // don't reset stop_replay_for_corruption.
   if (stop_replay_for_corruption == true &&
       (immutable_db_options_.wal_recovery_mode ==
@@ -1128,7 +1114,7 @@ Status DBImpl::RecoverLogFiles(const std::vector<uint64_t>& wal_numbers,
        immutable_db_options_.wal_recovery_mode ==
            WALRecoveryMode::kTolerateCorruptedTailRecords)) {
     for (auto cfd : *versions_->GetColumnFamilySet()) {
-      if (cfd->GetLogNumber() > corrupted_wal_number) {
+      if (cfd->GetLogNumber() > corrupted_log_number) {
         ROCKS_LOG_ERROR(immutable_db_options_.info_log,
                         "Column family inconsistency: SST file contains data"
                         " beyond the point of corruption.");
@@ -1143,16 +1129,16 @@ Status DBImpl::RecoverLogFiles(const std::vector<uint64_t>& wal_numbers,
   if (!read_only) {
     // no need to refcount since client still doesn't have access
     // to the DB and can not drop column families while we iterate
-    const WalNumber max_wal_number = wal_numbers.back();
+    auto max_log_number = log_numbers.back();
     for (auto cfd : *versions_->GetColumnFamilySet()) {
       auto iter = version_edits.find(cfd->GetID());
       assert(iter != version_edits.end());
       VersionEdit* edit = &iter->second;
 
-      if (cfd->GetLogNumber() > max_wal_number) {
+      if (cfd->GetLogNumber() > max_log_number) {
         // Column family cfd has already flushed the data
-        // from all wals. Memtable has to be empty because
-        // we filter the updates based on wal_number
+        // from all logs. Memtable has to be empty because
+        // we filter the updates based on log_number
         // (in WriteBatch::InsertInto)
         assert(cfd->mem()->GetFirstSequenceNumber() == 0);
         assert(edit->NumEntries() == 0);
@@ -1184,13 +1170,13 @@ Status DBImpl::RecoverLogFiles(const std::vector<uint64_t>& wal_numbers,
       // Update the log number info in the version edit corresponding to this
       // column family. Note that the version edits will be written to MANIFEST
       // together later.
-      // writing wal_number in the manifest means that any log file
-      // with number strongly less than (wal_number + 1) is already
+      // writing log_number in the manifest means that any log file
+      // with number strongly less than (log_number + 1) is already
       // recovered and should be ignored on next reincarnation.
-      // Since we already recovered max_wal_number, we want all wals
-      // with numbers `<= max_wal_number` (includes this one) to be ignored
+      // Since we already recovered max_log_number, we want all logs
+      // with numbers `<= max_log_number` (includes this one) to be ignored
       if (flushed || cfd->mem()->GetFirstSequenceNumber() == 0) {
-        edit->SetLogNumber(max_wal_number + 1);
+        edit->SetLogNumber(max_log_number + 1);
       }
     }
     if (status.ok()) {
@@ -1198,7 +1184,7 @@ Status DBImpl::RecoverLogFiles(const std::vector<uint64_t>& wal_numbers,
       // not actually used. that is because VersionSet assumes
       // VersionSet::next_file_number_ always to be strictly greater than any
       // log number
-      versions_->MarkFileNumberUsed(max_wal_number + 1);
+      versions_->MarkFileNumberUsed(max_log_number + 1);
 
       autovector<ColumnFamilyData*> cfds;
       autovector<const MutableCFOptions*> cf_opts;
@@ -1210,14 +1196,6 @@ Status DBImpl::RecoverLogFiles(const std::vector<uint64_t>& wal_numbers,
         assert(iter != version_edits.end());
         edit_lists.push_back({&iter->second});
       }
-
-      std::unique_ptr<VersionEdit> wal_deletion;
-      if (immutable_db_options_.track_and_verify_wals_in_manifest) {
-        wal_deletion.reset(new VersionEdit);
-        wal_deletion->DeleteWalsBefore(max_wal_number + 1);
-        edit_lists.back().push_back(wal_deletion.get());
-      }
-
       // write MANIFEST with update
       status = versions_->LogAndApply(cfds, cf_opts, edit_lists, &mutex_,
                                       directories_.GetDbDir(),
@@ -1226,7 +1204,7 @@ Status DBImpl::RecoverLogFiles(const std::vector<uint64_t>& wal_numbers,
   }
 
   if (status.ok() && data_seen && !flushed) {
-    status = RestoreAliveLogFiles(wal_numbers);
+    status = RestoreAliveLogFiles(log_numbers);
   }
 
   event_logger_.Log() << "job" << job_id << "event"
@@ -1235,8 +1213,8 @@ Status DBImpl::RecoverLogFiles(const std::vector<uint64_t>& wal_numbers,
   return status;
 }
 
-Status DBImpl::RestoreAliveLogFiles(const std::vector<uint64_t>& wal_numbers) {
-  if (wal_numbers.empty()) {
+Status DBImpl::RestoreAliveLogFiles(const std::vector<uint64_t>& log_numbers) {
+  if (log_numbers.empty()) {
     return Status::OK();
   }
   Status s;
@@ -1249,20 +1227,20 @@ Status DBImpl::RestoreAliveLogFiles(const std::vector<uint64_t>& wal_numbers) {
   // FindObsoleteFiles()
   total_log_size_ = 0;
   log_empty_ = false;
-  for (auto wal_number : wal_numbers) {
-    LogFileNumberSize log(wal_number);
-    std::string fname = LogFileName(immutable_db_options_.wal_dir, wal_number);
-    // This gets the appear size of the wals, not including preallocated space.
+  for (auto log_number : log_numbers) {
+    LogFileNumberSize log(log_number);
+    std::string fname = LogFileName(immutable_db_options_.wal_dir, log_number);
+    // This gets the appear size of the logs, not including preallocated space.
     s = env_->GetFileSize(fname, &log.size);
     if (!s.ok()) {
       break;
     }
     total_log_size_ += log.size;
     alive_log_files_.push_back(log);
-    // We preallocate space for wals, but then after a crash and restart, those
+    // We preallocate space for logs, but then after a crash and restart, those
     // preallocated space are not needed anymore. It is likely only the last
     // log has such preallocated space, so we only truncate for the last log.
-    if (wal_number == wal_numbers.back()) {
+    if (log_number == log_numbers.back()) {
       std::unique_ptr<FSWritableFile> last_log;
       Status truncate_status = fs_->ReopenWritableFile(
           fname,
@@ -1279,7 +1257,7 @@ Status DBImpl::RestoreAliveLogFiles(const std::vector<uint64_t>& wal_numbers) {
       // Not a critical error if fail to truncate.
       if (!truncate_status.ok()) {
         ROCKS_LOG_WARN(immutable_db_options_.info_log,
-                       "Failed to truncate log #%" PRIu64 ": %s", wal_number,
+                       "Failed to truncate log #%" PRIu64 ": %s", log_number,
                        truncate_status.ToString().c_str());
       }
     }
@@ -1294,10 +1272,7 @@ Status DBImpl::WriteLevel0TableForRecovery(int job_id, ColumnFamilyData* cfd,
                                            MemTable* mem, VersionEdit* edit) {
   mutex_.AssertHeld();
   const uint64_t start_micros = env_->NowMicros();
-
   FileMetaData meta;
-  std::vector<BlobFileAddition> blob_file_additions;
-
   std::unique_ptr<std::list<uint64_t>::iterator> pending_outputs_inserted_elem(
       new std::list<uint64_t>::iterator(
           CaptureCurrentFileNumberInPendingOutputs()));
@@ -1344,15 +1319,13 @@ Status DBImpl::WriteLevel0TableForRecovery(int job_id, ColumnFamilyData* cfd,
       if (range_del_iter != nullptr) {
         range_del_iters.emplace_back(range_del_iter);
       }
-
       IOStatus io_s;
       s = BuildTable(
-          dbname_, versions_.get(), immutable_db_options_, *cfd->ioptions(),
-          mutable_cf_options, file_options_for_compaction_, cfd->table_cache(),
-          iter.get(), std::move(range_del_iters), &meta, &blob_file_additions,
-          cfd->internal_comparator(), cfd->int_tbl_prop_collector_factories(),
-          cfd->GetID(), cfd->GetName(), snapshot_seqs,
-          earliest_write_conflict_snapshot, snapshot_checker,
+          dbname_, env_, fs_.get(), *cfd->ioptions(), mutable_cf_options,
+          file_options_for_compaction_, cfd->table_cache(), iter.get(),
+          std::move(range_del_iters), &meta, cfd->internal_comparator(),
+          cfd->int_tbl_prop_collector_factories(), cfd->GetID(), cfd->GetName(),
+          snapshot_seqs, earliest_write_conflict_snapshot, snapshot_checker,
           GetCompressionFlush(*cfd->ioptions(), mutable_cf_options),
           mutable_cf_options.sample_for_compression,
           mutable_cf_options.compression_opts, paranoid_file_checks,
@@ -1374,39 +1347,23 @@ Status DBImpl::WriteLevel0TableForRecovery(int job_id, ColumnFamilyData* cfd,
 
   // Note that if file_size is zero, the file has been deleted and
   // should not be added to the manifest.
-  const bool has_output = meta.fd.GetFileSize() > 0;
-
-  constexpr int level = 0;
-
-  if (s.ok() && has_output) {
+  int level = 0;
+  if (s.ok() && meta.fd.GetFileSize() > 0) {
     edit->AddFile(level, meta.fd.GetNumber(), meta.fd.GetPathId(),
                   meta.fd.GetFileSize(), meta.smallest, meta.largest,
                   meta.fd.smallest_seqno, meta.fd.largest_seqno,
                   meta.marked_for_compaction, meta.oldest_blob_file_number,
                   meta.oldest_ancester_time, meta.file_creation_time,
                   meta.file_checksum, meta.file_checksum_func_name);
-
-    edit->SetBlobFileAdditions(std::move(blob_file_additions));
   }
 
   InternalStats::CompactionStats stats(CompactionReason::kFlush, 1);
   stats.micros = env_->NowMicros() - start_micros;
-
-  if (has_output) {
-    stats.bytes_written = meta.fd.GetFileSize();
-    stats.num_output_files = 1;
-  }
-
-  const auto& blobs = edit->GetBlobFileAdditions();
-  for (const auto& blob : blobs) {
-    stats.bytes_written += blob.GetTotalBlobBytes();
-  }
-
-  stats.num_output_files += static_cast<int>(blobs.size());
-
+  stats.bytes_written = meta.fd.GetFileSize();
+  stats.num_output_files = 1;
   cfd->internal_stats()->AddCompactionStats(level, Env::Priority::USER, stats);
   cfd->internal_stats()->AddCFStats(InternalStats::BYTES_FLUSHED,
-                                    stats.bytes_written);
+                                    meta.fd.GetFileSize());
   RecordTick(stats_, COMPACT_WRITE_BYTES, meta.fd.GetFileSize());
   return s;
 }
@@ -1494,7 +1451,7 @@ Status DBImpl::Open(const DBOptions& db_options, const std::string& dbname,
                     const std::vector<ColumnFamilyDescriptor>& column_families,
                     std::vector<ColumnFamilyHandle*>* handles, DB** dbptr,
                     const bool seq_per_batch, const bool batch_per_txn) {
-  Status s = ValidateOptionsByTable(db_options, column_families);
+  Status s = SanitizeOptionsByTable(db_options, column_families);
   if (!s.ok()) {
     return s;
   }
@@ -1617,7 +1574,7 @@ Status DBImpl::Open(const DBOptions& db_options, const std::string& dbname,
       // In WritePrepared there could be gap in sequence numbers. This breaks
       // the trick we use in kPointInTimeRecovery which assumes the first seq in
       // the log right after the corrupted log is one larger than the last seq
-      // we read from the wals. To let this trick keep working, we add a dummy
+      // we read from the logs. To let this trick keep working, we add a dummy
       // entry with the expected sequence to the first log right after recovery.
       // In non-WritePrepared case also the new log after recovery could be
       // empty, and thus missing the consecutive seq hint to distinguish
@@ -1641,7 +1598,7 @@ Status DBImpl::Open(const DBOptions& db_options, const std::string& dbname,
     }
   }
   if (s.ok() && impl->immutable_db_options_.persist_stats_to_disk) {
-    // try to read format version
+    // try to read format version but no need to fail Open() even if it fails
     s = impl->PersistentStatsProcessFormatVersion();
   }
 
@@ -1685,8 +1642,6 @@ Status DBImpl::Open(const DBOptions& db_options, const std::string& dbname,
     *dbptr = impl;
     impl->opened_successfully_ = true;
     impl->MaybeScheduleFlushOrCompaction();
-  } else {
-    persist_options_status.PermitUncheckedError();
   }
   impl->mutex_.Unlock();
 
@@ -1781,13 +1736,9 @@ Status DBImpl::Open(const DBOptions& db_options, const std::string& dbname,
           "DB::Open() failed --- Unable to persist Options file",
           persist_options_status.ToString());
     }
-  } else {
-    ROCKS_LOG_WARN(impl->immutable_db_options_.info_log,
-                   "Persisting Option File error: %s",
-                   persist_options_status.ToString().c_str());
   }
   if (s.ok()) {
-    impl->StartPeriodicWorkScheduler();
+    impl->StartStatsDumpScheduler();
   } else {
     for (auto* h : *handles) {
       delete h;

db/db_impl/db_impl_readonly.cc

@@ -151,7 +151,7 @@ Status OpenForReadOnlyCheckExistence(const DBOptions& db_options,
 }  // namespace
 
 Status DB::OpenForReadOnly(const Options& options, const std::string& dbname,
-                           DB** dbptr, bool /*error_if_wal_file_exists*/) {
+                           DB** dbptr, bool /*error_if_log_file_exist*/) {
   // If dbname does not exist in the file system, should not do anything
   Status s = OpenForReadOnlyCheckExistence(options, dbname);
   if (!s.ok()) {
@@ -188,7 +188,7 @@ Status DB::OpenForReadOnly(
     const DBOptions& db_options, const std::string& dbname,
     const std::vector<ColumnFamilyDescriptor>& column_families,
     std::vector<ColumnFamilyHandle*>* handles, DB** dbptr,
-    bool error_if_wal_file_exists) {
+    bool error_if_log_file_exist) {
   // If dbname does not exist in the file system, should not do anything
   Status s = OpenForReadOnlyCheckExistence(db_options, dbname);
   if (!s.ok()) {
@@ -197,14 +197,14 @@ Status DB::OpenForReadOnly(
 
   return DBImplReadOnly::OpenForReadOnlyWithoutCheck(
       db_options, dbname, column_families, handles, dbptr,
-      error_if_wal_file_exists);
+      error_if_log_file_exist);
 }
 
 Status DBImplReadOnly::OpenForReadOnlyWithoutCheck(
     const DBOptions& db_options, const std::string& dbname,
     const std::vector<ColumnFamilyDescriptor>& column_families,
     std::vector<ColumnFamilyHandle*>* handles, DB** dbptr,
-    bool error_if_wal_file_exists) {
+    bool error_if_log_file_exist) {
   *dbptr = nullptr;
   handles->clear();
 
@@ -212,7 +212,7 @@ Status DBImplReadOnly::OpenForReadOnlyWithoutCheck(
   DBImplReadOnly* impl = new DBImplReadOnly(db_options, dbname);
   impl->mutex_.Lock();
   Status s = impl->Recover(column_families, true /* read only */,
-                           error_if_wal_file_exists);
+                           error_if_log_file_exist);
   if (s.ok()) {
     // set column family handles
     for (auto cf : column_families) {
@@ -253,7 +253,7 @@ Status DBImplReadOnly::OpenForReadOnlyWithoutCheck(
 
 Status DB::OpenForReadOnly(const Options& /*options*/,
                            const std::string& /*dbname*/, DB** /*dbptr*/,
-                           bool /*error_if_wal_file_exists*/) {
+                           bool /*error_if_log_file_exist*/) {
   return Status::NotSupported("Not supported in ROCKSDB_LITE.");
 }
 
@@ -261,7 +261,7 @@ Status DB::OpenForReadOnly(
     const DBOptions& /*db_options*/, const std::string& /*dbname*/,
     const std::vector<ColumnFamilyDescriptor>& /*column_families*/,
     std::vector<ColumnFamilyHandle*>* /*handles*/, DB** /*dbptr*/,
-    bool /*error_if_wal_file_exists*/) {
+    bool /*error_if_log_file_exist*/) {
   return Status::NotSupported("Not supported in ROCKSDB_LITE.");
 }
 #endif  // !ROCKSDB_LITE

db/db_impl/db_impl_readonly.h

@@ -138,7 +138,7 @@ class DBImplReadOnly : public DBImpl {
       const DBOptions& db_options, const std::string& dbname,
       const std::vector<ColumnFamilyDescriptor>& column_families,
       std::vector<ColumnFamilyHandle*>* handles, DB** dbptr,
-      bool error_if_wal_file_exists = false);
+      bool error_if_log_file_exist = false);
   friend class DB;
 };
 }  // namespace ROCKSDB_NAMESPACE

db/db_impl/db_impl_secondary.cc

@@ -28,8 +28,8 @@ DBImplSecondary::~DBImplSecondary() {}
 
 Status DBImplSecondary::Recover(
     const std::vector<ColumnFamilyDescriptor>& column_families,
-    bool /*readonly*/, bool /*error_if_wal_file_exists*/,
-    bool /*error_if_data_exists_in_wals*/, uint64_t*) {
+    bool /*readonly*/, bool /*error_if_log_file_exist*/,
+    bool /*error_if_data_exists_in_logs*/, uint64_t*) {
   mutex_.AssertHeld();
 
   JobContext job_context(0);
@@ -112,7 +112,7 @@ Status DBImplSecondary::FindNewLogNumbers(std::vector<uint64_t>* logs) {
   for (size_t i = 0; i < filenames.size(); i++) {
     uint64_t number;
     FileType type;
-    if (ParseFileName(filenames[i], &number, &type) && type == kWalFile &&
+    if (ParseFileName(filenames[i], &number, &type) && type == kLogFile &&
         number >= log_number_min) {
       logs->push_back(number);
     }
@@ -192,8 +192,6 @@ Status DBImplSecondary::RecoverLogFiles(
     auto it  = log_readers_.find(log_number);
     assert(it != log_readers_.end());
     log::FragmentBufferedReader* reader = it->second->reader_;
-    Status* wal_read_status = it->second->status_;
-    assert(wal_read_status);
     // Manually update the file number allocation counter in VersionSet.
     versions_->MarkFileNumberUsed(log_number);
 
@@ -205,16 +203,13 @@ Status DBImplSecondary::RecoverLogFiles(
 
     while (reader->ReadRecord(&record, &scratch,
                               immutable_db_options_.wal_recovery_mode) &&
-           wal_read_status->ok() && status.ok()) {
+           status.ok()) {
       if (record.size() < WriteBatchInternal::kHeader) {
         reader->GetReporter()->Corruption(
             record.size(), Status::Corruption("log record too small"));
         continue;
       }
-      status = WriteBatchInternal::SetContents(&batch, record);
-      if (!status.ok()) {
-        break;
-      }
+      WriteBatchInternal::SetContents(&batch, record);
       SequenceNumber seq_of_batch = WriteBatchInternal::Sequence(&batch);
       std::vector<uint32_t> column_family_ids;
       status = CollectColumnFamilyIdsFromWriteBatch(batch, &column_family_ids);
@@ -300,9 +295,6 @@ Status DBImplSecondary::RecoverLogFiles(
         reader->GetReporter()->Corruption(record.size(), status);
       }
     }
-    if (status.ok() && !wal_read_status->ok()) {
-      status = *wal_read_status;
-    }
     if (!status.ok()) {
       return status;
     }

db/db_impl/db_impl_secondary.h

@@ -77,8 +77,8 @@ class DBImplSecondary : public DBImpl {
   // Recover by replaying MANIFEST and WAL. Also initialize manifest_reader_
   // and log_readers_ to facilitate future operations.
   Status Recover(const std::vector<ColumnFamilyDescriptor>& column_families,
-                 bool read_only, bool error_if_wal_file_exists,
-                 bool error_if_data_exists_in_wals,
+                 bool read_only, bool error_if_log_file_exist,
+                 bool error_if_data_exists_in_logs,
                  uint64_t* = nullptr) override;
 
   // Implementations of the DB interface

db/db_impl/db_impl_write.cc

@@ -77,8 +77,7 @@ Status DBImpl::WriteImpl(const WriteOptions& write_options,
   if (tracer_) {
     InstrumentedMutexLock lock(&trace_mutex_);
     if (tracer_) {
-      // TODO: maybe handle the tracing status?
-      tracer_->Write(my_batch).PermitUncheckedError();
+      tracer_->Write(my_batch);
     }
   }
   if (write_options.sync && write_options.disableWAL) {
@@ -102,10 +101,12 @@ Status DBImpl::WriteImpl(const WriteOptions& write_options,
   assert(!WriteBatchInternal::IsLatestPersistentState(my_batch) ||
          disable_memtable);
 
+  Status status;
+  IOStatus io_s;
   if (write_options.low_pri) {
-    Status s = ThrottleLowPriWritesIfNeeded(write_options, my_batch);
-    if (!s.ok()) {
-      return s;
+    status = ThrottleLowPriWritesIfNeeded(write_options, my_batch);
+    if (!status.ok()) {
+      return status;
     }
   }
 
@@ -125,13 +126,13 @@ Status DBImpl::WriteImpl(const WriteOptions& write_options,
                                      ? batch_cnt
                                      // every key is a sub-batch consuming a seq
                                      : WriteBatchInternal::Count(my_batch);
-    uint64_t seq = 0;
+    uint64_t seq;
     // Use a write thread to i) optimize for WAL write, ii) publish last
     // sequence in in increasing order, iii) call pre_release_callback serially
-    Status status = WriteImplWALOnly(
-        &write_thread_, write_options, my_batch, callback, log_used, log_ref,
-        &seq, sub_batch_cnt, pre_release_callback, kDoAssignOrder,
-        kDoPublishLastSeq, disable_memtable);
+    status = WriteImplWALOnly(&write_thread_, write_options, my_batch, callback,
+                              log_used, log_ref, &seq, sub_batch_cnt,
+                              pre_release_callback, kDoAssignOrder,
+                              kDoPublishLastSeq, disable_memtable);
     TEST_SYNC_POINT("DBImpl::WriteImpl:UnorderedWriteAfterWriteWAL");
     if (!status.ok()) {
       return status;
@@ -163,7 +164,6 @@ Status DBImpl::WriteImpl(const WriteOptions& write_options,
   StopWatch write_sw(env_, immutable_db_options_.statistics.get(), DB_WRITE);
 
   write_thread_.JoinBatchGroup(&w);
-  Status status;
   if (w.state == WriteThread::STATE_PARALLEL_MEMTABLE_WRITER) {
     // we are a non-leader in a parallel group
 
@@ -204,8 +204,6 @@ Status DBImpl::WriteImpl(const WriteOptions& write_options,
       *seq_used = w.sequence;
     }
     // write is complete and leader has updated sequence
-    // Should we handle it?
-    status.PermitUncheckedError();
     return w.FinalStatus();
   }
   // else we are the leader of the write batch group
@@ -254,7 +252,6 @@ Status DBImpl::WriteImpl(const WriteOptions& write_options,
   last_batch_group_size_ =
       write_thread_.EnterAsBatchGroupLeader(&w, &write_group);
 
-  IOStatus io_s;
   if (status.ok()) {
     // Rules for when we can update the memtable concurrently
     // 1. supported by memtable
@@ -426,11 +423,7 @@ Status DBImpl::WriteImpl(const WriteOptions& write_options,
 
   if (need_log_sync) {
     mutex_.Lock();
-    if (status.ok()) {
-      status = MarkLogsSynced(logfile_number_, need_log_dir_sync);
-    } else {
-      MarkLogsNotSynced(logfile_number_);
-    }
+    MarkLogsSynced(logfile_number_, need_log_dir_sync, status);
     mutex_.Unlock();
     // Requesting sync with two_write_queues_ is expected to be very rare. We
     // hence provide a simple implementation that is not necessarily efficient.
@@ -555,11 +548,7 @@ Status DBImpl::PipelinedWriteImpl(const WriteOptions& write_options,
 
     if (need_log_sync) {
       mutex_.Lock();
-      if (w.status.ok()) {
-        w.status = MarkLogsSynced(logfile_number_, need_log_dir_sync);
-      } else {
-        MarkLogsNotSynced(logfile_number_);
-      }
+      MarkLogsSynced(logfile_number_, need_log_dir_sync, w.status);
       mutex_.Unlock();
     }
 
@@ -849,9 +838,7 @@ void DBImpl::WriteStatusCheckOnLocked(const Status& status) {
   mutex_.AssertHeld();
   if (immutable_db_options_.paranoid_checks && !status.ok() &&
       !status.IsBusy() && !status.IsIncomplete()) {
-    // Maybe change the return status to void?
-    error_handler_.SetBGError(status, BackgroundErrorReason::kWriteCallback)
-        .PermitUncheckedError();
+    error_handler_.SetBGError(status, BackgroundErrorReason::kWriteCallback);
   }
 }
 
@@ -862,9 +849,7 @@ void DBImpl::WriteStatusCheck(const Status& status) {
   if (immutable_db_options_.paranoid_checks && !status.ok() &&
       !status.IsBusy() && !status.IsIncomplete()) {
     mutex_.Lock();
-    // Maybe change the return status to void?
-    error_handler_.SetBGError(status, BackgroundErrorReason::kWriteCallback)
-        .PermitUncheckedError();
+    error_handler_.SetBGError(status, BackgroundErrorReason::kWriteCallback);
     mutex_.Unlock();
   }
 }
@@ -876,9 +861,7 @@ void DBImpl::IOStatusCheck(const IOStatus& io_status) {
        !io_status.IsBusy() && !io_status.IsIncomplete()) ||
       io_status.IsIOFenced()) {
     mutex_.Lock();
-    // Maybe change the return status to void?
-    error_handler_.SetBGError(io_status, BackgroundErrorReason::kWriteCallback)
-        .PermitUncheckedError();
+    error_handler_.SetBGError(io_status, BackgroundErrorReason::kWriteCallback);
     mutex_.Unlock();
   }
 }
@@ -892,9 +875,7 @@ void DBImpl::MemTableInsertStatusCheck(const Status& status) {
   if (!status.ok()) {
     mutex_.Lock();
     assert(!error_handler_.IsBGWorkStopped());
-    // Maybe change the return status to void?
-    error_handler_.SetBGError(status, BackgroundErrorReason::kMemTable)
-        .PermitUncheckedError();
+    error_handler_.SetBGError(status, BackgroundErrorReason::kMemTable);
     mutex_.Unlock();
   }
 }
@@ -1008,10 +989,8 @@ WriteBatch* DBImpl::MergeBatch(const WriteThread::WriteGroup& write_group,
     merged_batch = tmp_batch;
     for (auto writer : write_group) {
       if (!writer->CallbackFailed()) {
-        Status s = WriteBatchInternal::Append(merged_batch, writer->batch,
-                                              /*WAL_only*/ true);
-        // Always returns Status::OK.
-        assert(s.ok());
+        WriteBatchInternal::Append(merged_batch, writer->batch,
+                                   /*WAL_only*/ true);
         if (WriteBatchInternal::IsLatestPersistentState(writer->batch)) {
           // We only need to cache the last of such write batch
           *to_be_cached_state = writer->batch;
@@ -1790,15 +1769,10 @@ Status DBImpl::SwitchMemtable(ColumnFamilyData* cfd, WriteContext* context) {
     }
     // We may have lost data from the WritableFileBuffer in-memory buffer for
     // the current log, so treat it as a fatal error and set bg_error
-    // Should handle return error?
     if (!io_s.ok()) {
-      // Should handle return error?
-      error_handler_.SetBGError(io_s, BackgroundErrorReason::kMemTable)
-          .PermitUncheckedError();
+      error_handler_.SetBGError(io_s, BackgroundErrorReason::kMemTable);
     } else {
-      // Should handle return error?
-      error_handler_.SetBGError(s, BackgroundErrorReason::kMemTable)
-          .PermitUncheckedError();
+      error_handler_.SetBGError(s, BackgroundErrorReason::kMemTable);
     }
     // Read back bg_error in order to get the right severity
     s = error_handler_.GetBGError();
@@ -1832,10 +1806,6 @@ Status DBImpl::SwitchMemtable(ColumnFamilyData* cfd, WriteContext* context) {
   NotifyOnMemTableSealed(cfd, memtable_info);
   mutex_.Lock();
 #endif  // ROCKSDB_LITE
-  // It is possible that we got here without checking the value of i_os, but
-  // that is okay.  If we did, it most likely means that s was already an error.
-  // In any case, ignore any unchecked error for i_os here.
-  io_s.PermitUncheckedError();
   return s;
 }
 
@@ -1926,10 +1896,7 @@ Status DB::Delete(const WriteOptions& opt, ColumnFamilyHandle* column_family,
 Status DB::SingleDelete(const WriteOptions& opt,
                         ColumnFamilyHandle* column_family, const Slice& key) {
   WriteBatch batch;
-  Status s = batch.SingleDelete(column_family, key);
-  if (!s.ok()) {
-    return s;
-  }
+  batch.SingleDelete(column_family, key);
   return Write(opt, &batch);
 }
 
@@ -1937,10 +1904,7 @@ Status DB::DeleteRange(const WriteOptions& opt,
                        ColumnFamilyHandle* column_family,
                        const Slice& begin_key, const Slice& end_key) {
   WriteBatch batch;
-  Status s = batch.DeleteRange(column_family, begin_key, end_key);
-  if (!s.ok()) {
-    return s;
-  }
+  batch.DeleteRange(column_family, begin_key, end_key);
   return Write(opt, &batch);
 }
 

db/db_impl/db_secondary_test.cc

@@ -52,7 +52,7 @@ class DBSecondaryTest : public DBTestBase {
 
   void CloseSecondary() {
     for (auto h : handles_secondary_) {
-      ASSERT_OK(db_secondary_->DestroyColumnFamilyHandle(h));
+      db_secondary_->DestroyColumnFamilyHandle(h);
     }
     handles_secondary_.clear();
     delete db_secondary_;
@@ -97,14 +97,14 @@ void DBSecondaryTest::CheckFileTypeCounts(const std::string& dir,
                                           int expected_log, int expected_sst,
                                           int expected_manifest) const {
   std::vector<std::string> filenames;
-  ASSERT_OK(env_->GetChildren(dir, &filenames));
+  env_->GetChildren(dir, &filenames);
 
   int log_cnt = 0, sst_cnt = 0, manifest_cnt = 0;
   for (auto file : filenames) {
     uint64_t number;
     FileType type;
     if (ParseFileName(file, &number, &type)) {
-      log_cnt += (type == kWalFile);
+      log_cnt += (type == kLogFile);
       sst_cnt += (type == kTableFile);
       manifest_cnt += (type == kDescriptorFile);
     }
@@ -777,8 +777,8 @@ TEST_F(DBSecondaryTest, CatchUpAfterFlush) {
 
   WriteOptions write_opts;
   WriteBatch wb;
-  ASSERT_OK(wb.Put("key0", "value0"));
-  ASSERT_OK(wb.Put("key1", "value1"));
+  wb.Put("key0", "value0");
+  wb.Put("key1", "value1");
   ASSERT_OK(dbfull()->Write(write_opts, &wb));
   ReadOptions read_opts;
   std::unique_ptr<Iterator> iter1(db_secondary_->NewIterator(read_opts));
@@ -791,27 +791,25 @@ TEST_F(DBSecondaryTest, CatchUpAfterFlush) {
   ASSERT_FALSE(iter1->Valid());
   iter1->Seek("key1");
   ASSERT_FALSE(iter1->Valid());
-  ASSERT_OK(iter1->status());
   std::unique_ptr<Iterator> iter2(db_secondary_->NewIterator(read_opts));
   iter2->Seek("key0");
   ASSERT_TRUE(iter2->Valid());
   ASSERT_EQ("value0", iter2->value());
   iter2->Seek("key1");
   ASSERT_TRUE(iter2->Valid());
-  ASSERT_OK(iter2->status());
   ASSERT_EQ("value1", iter2->value());
 
   {
     WriteBatch wb1;
-    ASSERT_OK(wb1.Put("key0", "value01"));
-    ASSERT_OK(wb1.Put("key1", "value11"));
+    wb1.Put("key0", "value01");
+    wb1.Put("key1", "value11");
     ASSERT_OK(dbfull()->Write(write_opts, &wb1));
   }
 
   {
     WriteBatch wb2;
-    ASSERT_OK(wb2.Put("key0", "new_value0"));
-    ASSERT_OK(wb2.Delete("key1"));
+    wb2.Put("key0", "new_value0");
+    wb2.Delete("key1");
     ASSERT_OK(dbfull()->Write(write_opts, &wb2));
   }
 
@@ -825,7 +823,6 @@ TEST_F(DBSecondaryTest, CatchUpAfterFlush) {
   ASSERT_EQ("new_value0", iter3->value());
   iter3->Seek("key1");
   ASSERT_FALSE(iter3->Valid());
-  ASSERT_OK(iter3->status());
 }
 
 TEST_F(DBSecondaryTest, CheckConsistencyWhenOpen) {
@@ -883,7 +880,6 @@ TEST_F(DBSecondaryTest, StartFromInconsistent) {
       });
   SyncPoint::GetInstance()->EnableProcessing();
   Options options1;
-  options1.env = env_;
   Status s = TryOpenSecondary(options1);
   ASSERT_TRUE(s.IsCorruption());
 }
@@ -895,7 +891,6 @@ TEST_F(DBSecondaryTest, InconsistencyDuringCatchUp) {
   ASSERT_OK(Flush());
 
   Options options1;
-  options1.env = env_;
   OpenSecondary(options1);
 
   {

db/db_info_dumper.cc

@@ -62,7 +62,7 @@ void DumpDBFileSummary(const ImmutableDBOptions& options,
                 dbname.c_str(), file.c_str());
         }
         break;
-      case kWalFile:
+      case kLogFile:
         if (env->GetFileSize(dbname + "/" + file, &file_size).ok()) {
           char str[16];
           snprintf(str, sizeof(str), "%" PRIu64, file_size);
@@ -118,7 +118,7 @@ void DumpDBFileSummary(const ImmutableDBOptions& options,
     wal_info.clear();
     for (const std::string& file : files) {
       if (ParseFileName(file, &number, &type)) {
-        if (type == kWalFile) {
+        if (type == kLogFile) {
           if (env->GetFileSize(options.wal_dir + "/" + file, &file_size).ok()) {
             char str[16];
             snprintf(str, sizeof(str), "%" PRIu64, file_size);

db/db_iter.cc

@@ -107,12 +107,11 @@ Status DBIter::GetProperty(std::string prop_name, std::string* prop) {
 }
 
 bool DBIter::ParseKey(ParsedInternalKey* ikey) {
-  Status s =
-      ParseInternalKey(iter_.key(), ikey, false /* log_err_key */);  // TODO
-  if (!s.ok()) {
-    status_ = Status::Corruption("In DBIter: ", s.getState());
+  if (!ParseInternalKey(iter_.key(), ikey)) {
+    status_ = Status::Corruption("corrupted internal key in DBIter");
     valid_ = false;
-    ROCKS_LOG_ERROR(logger_, "In DBIter: %s", status_.getState());
+    ROCKS_LOG_ERROR(logger_, "corrupted internal key in DBIter: %s",
+                    iter_.key().ToString(true).c_str());
     return false;
   } else {
     return true;
@@ -148,13 +147,13 @@ void DBIter::Next() {
 
   local_stats_.next_count_++;
   if (ok && iter_.Valid()) {
+    Slice prefix;
     if (prefix_same_as_start_) {
       assert(prefix_extractor_ != nullptr);
-      const Slice prefix = prefix_.GetUserKey();
-      FindNextUserEntry(true /* skipping the current user key */, &prefix);
-    } else {
-      FindNextUserEntry(true /* skipping the current user key */, nullptr);
+      prefix = prefix_.GetUserKey();
     }
+    FindNextUserEntry(true /* skipping the current user key */,
+                      prefix_same_as_start_ ? &prefix : nullptr);
   } else {
     is_key_seqnum_zero_ = false;
     valid_ = false;
@@ -385,11 +384,8 @@ bool DBIter::FindNextUserEntryInternal(bool skipping_saved_key,
             }
             break;
           default:
-            valid_ = false;
-            status_ = Status::Corruption(
-                "Unknown value type: " +
-                std::to_string(static_cast<unsigned int>(ikey_.type)));
-            return false;
+            assert(false);
+            break;
         }
       }
     } else {
@@ -437,11 +433,11 @@ bool DBIter::FindNextUserEntryInternal(bool skipping_saved_key,
               &last_key,
               ParsedInternalKey(saved_key_.GetUserKey(), 0, kTypeDeletion));
         } else {
-          const std::string kTsMin(timestamp_size_, static_cast<char>(0));
+          std::string min_ts(timestamp_size_, static_cast<char>(0));
           AppendInternalKeyWithDifferentTimestamp(
               &last_key,
               ParsedInternalKey(saved_key_.GetUserKey(), 0, kTypeDeletion),
-              kTsMin);
+              min_ts);
         }
         // Don't set skipping_saved_key = false because we may still see more
         // user-keys equal to saved_key_.
@@ -560,11 +556,7 @@ bool DBIter::MergeValuesNewToOld() {
       valid_ = false;
       return false;
     } else {
-      valid_ = false;
-      status_ = Status::Corruption(
-          "Unrecognized value type: " +
-          std::to_string(static_cast<unsigned int>(ikey.type)));
-      return false;
+      assert(false);
     }
   }
 
@@ -811,19 +803,12 @@ bool DBIter::FindValueForCurrentKey() {
                 ikey, RangeDelPositioningMode::kBackwardTraversal)) {
           last_key_entry_type = kTypeRangeDeletion;
           PERF_COUNTER_ADD(internal_delete_skipped_count, 1);
-        } else if (iter_.iter()->IsValuePinned()) {
-          pinned_value_ = iter_.value();
         } else {
-          valid_ = false;
-          status_ = Status::NotSupported(
-              "Backward iteration not supported if underlying iterator's value "
-              "cannot be pinned.");
+          assert(iter_.iter()->IsValuePinned());
+          pinned_value_ = iter_.value();
         }
         merge_context_.Clear();
         last_not_merge_type = last_key_entry_type;
-        if (!status_.ok()) {
-          return false;
-        }
         break;
       case kTypeDeletion:
       case kTypeSingleDeletion:
@@ -847,11 +832,7 @@ bool DBIter::FindValueForCurrentKey() {
         }
         break;
       default:
-        valid_ = false;
-        status_ = Status::Corruption(
-            "Unknown value type: " +
-            std::to_string(static_cast<unsigned int>(last_key_entry_type)));
-        return false;
+        assert(false);
     }
 
     PERF_COUNTER_ADD(internal_key_skipped_count, 1);
@@ -865,7 +846,6 @@ bool DBIter::FindValueForCurrentKey() {
   }
 
   Status s;
-  s.PermitUncheckedError();
   is_blob_ = false;
   switch (last_key_entry_type) {
     case kTypeDeletion:
@@ -917,11 +897,8 @@ bool DBIter::FindValueForCurrentKey() {
       is_blob_ = true;
       break;
     default:
-      valid_ = false;
-      status_ = Status::Corruption(
-          "Unknown value type: " +
-          std::to_string(static_cast<unsigned int>(last_key_entry_type)));
-      return false;
+      assert(false);
+      break;
   }
   if (!s.ok()) {
     valid_ = false;
@@ -1070,11 +1047,7 @@ bool DBIter::FindValueForCurrentKeyUsingSeek() {
       valid_ = false;
       return false;
     } else {
-      valid_ = false;
-      status_ = Status::Corruption(
-          "Unknown value type: " +
-          std::to_string(static_cast<unsigned int>(ikey.type)));
-      return false;
+      assert(false);
     }
   }
 

db/db_iter.h

@@ -140,14 +140,7 @@ class DBIter final : public Iterator {
   }
   ReadRangeDelAggregator* GetRangeDelAggregator() { return &range_del_agg_; }
 
-  bool Valid() const override {
-#ifdef ROCKSDB_ASSERT_STATUS_CHECKED
-    if (valid_) {
-      status_.PermitUncheckedError();
-    }
-#endif  // ROCKSDB_ASSERT_STATUS_CHECKED
-    return valid_;
-  }
+  bool Valid() const override { return valid_; }
   Slice key() const override {
     assert(valid_);
     if (start_seqnum_ > 0 || timestamp_lb_) {

db/db_iter_test.cc

@@ -99,11 +99,9 @@ class TestIterator : public InternalIterator {
     }
     for (auto it = data_.begin(); it != data_.end(); ++it) {
       ParsedInternalKey ikey;
-      Status pik_status =
-          ParseInternalKey(it->first, &ikey, true /* log_err_key */);
-      pik_status.PermitUncheckedError();
-      assert(pik_status.ok());
-      if (!pik_status.ok() || ikey.user_key != _key) {
+      bool ok __attribute__((__unused__)) = ParseInternalKey(it->first, &ikey);
+      assert(ok);
+      if (ikey.user_key != _key) {
         continue;
       }
       if (valid_ && data_.begin() + iter_ > it) {

db/db_iterator_test.cc

@@ -2146,7 +2146,7 @@ TEST_P(DBIteratorTest, ReadAhead) {
   BlockBasedTableOptions table_options;
   table_options.block_size = 1024;
   table_options.no_block_cache = true;
-  options.table_factory.reset(NewBlockBasedTableFactory(table_options));
+  options.table_factory.reset(new BlockBasedTableFactory(table_options));
   Reopen(options);
 
   std::string value(1024, 'a');
@@ -3021,44 +3021,6 @@ TEST_F(DBIteratorWithReadCallbackTest, ReadCallback) {
   delete iter;
 }
 
-TEST_F(DBIteratorTest, BackwardIterationOnInplaceUpdateMemtable) {
-  Options options = CurrentOptions();
-  options.create_if_missing = true;
-  options.inplace_update_support = false;
-  options.env = env_;
-  DestroyAndReopen(options);
-  constexpr int kNumKeys = 10;
-
-  // Write kNumKeys to WAL.
-  for (int i = 0; i < kNumKeys; ++i) {
-    ASSERT_OK(Put(Key(i), "val"));
-  }
-  ReadOptions read_opts;
-  read_opts.total_order_seek = true;
-  {
-    std::unique_ptr<Iterator> iter(db_->NewIterator(read_opts));
-    int count = 0;
-    for (iter->SeekToLast(); iter->Valid(); iter->Prev()) {
-      ++count;
-    }
-    ASSERT_EQ(kNumKeys, count);
-  }
-
-  // Reopen and rebuild the memtable from WAL.
-  options.create_if_missing = false;
-  options.avoid_flush_during_recovery = true;
-  options.inplace_update_support = true;
-  options.allow_concurrent_memtable_write = false;
-  Reopen(options);
-  {
-    std::unique_ptr<Iterator> iter(db_->NewIterator(read_opts));
-    iter->SeekToLast();
-    // Backward iteration not supported due to inplace_update_support = true.
-    ASSERT_TRUE(iter->status().IsNotSupported());
-    ASSERT_FALSE(iter->Valid());
-  }
-}
-
 }  // namespace ROCKSDB_NAMESPACE
 
 int main(int argc, char** argv) {

db/db_memtable_test.cc

@@ -316,7 +316,6 @@ TEST_F(DBMemTableTest, InsertWithHint) {
 TEST_F(DBMemTableTest, ColumnFamilyId) {
   // Verifies MemTableRepFactory is told the right column family id.
   Options options;
-  options.env = CurrentOptions().env;
   options.allow_concurrent_memtable_write = false;
   options.create_if_missing = true;
   options.memtable_factory.reset(new MockMemTableRepFactory());

db/db_merge_operator_test.cc

@@ -37,7 +37,7 @@ class TestReadCallback : public ReadCallback {
 class DBMergeOperatorTest : public DBTestBase {
  public:
   DBMergeOperatorTest()
-      : DBTestBase("/db_merge_operator_test", /*env_do_fsync=*/false) {}
+      : DBTestBase("/db_merge_operator_test", /*env_do_fsync=*/true) {}
 
   std::string GetWithReadCallback(SnapshotChecker* snapshot_checker,
                                   const Slice& key,

db/db_options_test.cc

@@ -33,14 +33,17 @@ class DBOptionsTest : public DBTestBase {
   std::unordered_map<std::string, std::string> GetMutableDBOptionsMap(
       const DBOptions& options) {
     std::string options_str;
-    std::unordered_map<std::string, std::string> mutable_map;
     ConfigOptions config_options;
     config_options.delimiter = "; ";
-
-    EXPECT_OK(GetStringFromMutableDBOptions(
-        config_options, MutableDBOptions(options), &options_str));
-    EXPECT_OK(StringToMap(options_str, &mutable_map));
-
+    GetStringFromDBOptions(config_options, options, &options_str);
+    std::unordered_map<std::string, std::string> options_map;
+    StringToMap(options_str, &options_map);
+    std::unordered_map<std::string, std::string> mutable_map;
+    for (const auto& opt : db_options_type_info) {
+      if (opt.second.IsMutable() && opt.second.ShouldSerialize()) {
+        mutable_map[opt.first] = options_map[opt.first];
+      }
+    }
     return mutable_map;
   }
 
@@ -50,10 +53,15 @@ class DBOptionsTest : public DBTestBase {
     ConfigOptions config_options;
     config_options.delimiter = "; ";
 
+    GetStringFromColumnFamilyOptions(config_options, options, &options_str);
+    std::unordered_map<std::string, std::string> options_map;
+    StringToMap(options_str, &options_map);
     std::unordered_map<std::string, std::string> mutable_map;
-    EXPECT_OK(GetStringFromMutableCFOptions(
-        config_options, MutableCFOptions(options), &options_str));
-    EXPECT_OK(StringToMap(options_str, &mutable_map));
+    for (const auto& opt : cf_options_type_info) {
+      if (opt.second.IsMutable() && opt.second.ShouldSerialize()) {
+        mutable_map[opt.first] = options_map[opt.first];
+      }
+    }
     return mutable_map;
   }
 
@@ -79,22 +87,6 @@ class DBOptionsTest : public DBTestBase {
 #endif  // ROCKSDB_LITE
 };
 
-TEST_F(DBOptionsTest, ImmutableTrackAndVerifyWalsInManifest) {
-  Options options;
-  options.env = env_;
-  options.track_and_verify_wals_in_manifest = true;
-
-  ImmutableDBOptions db_options(options);
-  ASSERT_TRUE(db_options.track_and_verify_wals_in_manifest);
-
-  Reopen(options);
-  ASSERT_TRUE(dbfull()->GetDBOptions().track_and_verify_wals_in_manifest);
-
-  Status s =
-      dbfull()->SetDBOptions({{"track_and_verify_wals_in_manifest", "false"}});
-  ASSERT_FALSE(s.ok());
-}
-
 // RocksDB lite don't support dynamic options.
 #ifndef ROCKSDB_LITE
 
@@ -151,7 +143,7 @@ TEST_F(DBOptionsTest, SetBytesPerSync) {
   WriteOptions write_opts;
   // should sync approximately 40MB/1MB ~= 40 times.
   for (i = 0; i < 40; i++) {
-    ASSERT_OK(Put(Key(i), kValue, write_opts));
+    Put(Key(i), kValue, write_opts);
   }
   ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->EnableProcessing();
   ASSERT_OK(dbfull()->CompactRange(CompactRangeOptions(), nullptr, nullptr));
@@ -167,7 +159,7 @@ TEST_F(DBOptionsTest, SetBytesPerSync) {
   // should sync approximately 40MB*2/8MB ~= 10 times.
   // data will be 40*2MB because of previous Puts too.
   for (i = 0; i < 40; i++) {
-    ASSERT_OK(Put(Key(i), kValue, write_opts));
+    Put(Key(i), kValue, write_opts);
   }
   ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->EnableProcessing();
   ASSERT_OK(dbfull()->CompactRange(CompactRangeOptions(), nullptr, nullptr));
@@ -198,7 +190,7 @@ TEST_F(DBOptionsTest, SetWalBytesPerSync) {
   const std::string kValue(kValueSize, 'v');
   int i = 0;
   for (; i < 10; i++) {
-    ASSERT_OK(Put(Key(i), kValue));
+    Put(Key(i), kValue);
   }
   // Do not flush. If we flush here, SwitchWAL will reuse old WAL file since its
   // empty and will not get the new wal_bytes_per_sync value.
@@ -209,7 +201,7 @@ TEST_F(DBOptionsTest, SetWalBytesPerSync) {
   counter = 0;
   i = 0;
   for (; i < 10; i++) {
-    ASSERT_OK(Put(Key(i), kValue));
+    Put(Key(i), kValue);
   }
   ASSERT_GT(counter, 0);
   ASSERT_GT(low_bytes_per_sync, 0);
@@ -244,9 +236,9 @@ TEST_F(DBOptionsTest, WritableFileMaxBufferSize) {
   for (; i < 3; i++) {
     ASSERT_OK(Put("foo", ToString(i)));
     ASSERT_OK(Put("bar", ToString(i)));
-    ASSERT_OK(Flush());
+    Flush();
   }
-  ASSERT_OK(dbfull()->TEST_WaitForCompact());
+  dbfull()->TEST_WaitForCompact();
   ASSERT_EQ(unmatch_cnt, 0);
   ASSERT_GE(match_cnt, 11);
 
@@ -262,9 +254,9 @@ TEST_F(DBOptionsTest, WritableFileMaxBufferSize) {
   for (; i < 3; i++) {
     ASSERT_OK(Put("foo", ToString(i)));
     ASSERT_OK(Put("bar", ToString(i)));
-    ASSERT_OK(Flush());
+    Flush();
   }
-  ASSERT_OK(dbfull()->TEST_WaitForCompact());
+  dbfull()->TEST_WaitForCompact();
   ASSERT_EQ(unmatch_cnt, 0);
   ASSERT_GE(match_cnt, 11);
 }
@@ -300,14 +292,14 @@ TEST_F(DBOptionsTest, EnableAutoCompactionAndTriggerStall) {
       DestroyAndReopen(options);
       int i = 0;
       for (; i < 1024; i++) {
-        ASSERT_OK(Put(Key(i), kValue));
+        Put(Key(i), kValue);
       }
-      ASSERT_OK(Flush());
+      Flush();
       for (; i < 1024 * 2; i++) {
-        ASSERT_OK(Put(Key(i), kValue));
+        Put(Key(i), kValue);
       }
-      ASSERT_OK(Flush());
-      ASSERT_OK(dbfull()->TEST_WaitForFlushMemTable());
+      Flush();
+      dbfull()->TEST_WaitForFlushMemTable();
       ASSERT_EQ(2, NumTableFilesAtLevel(0));
       uint64_t l0_size = SizeAtLevel(0);
 
@@ -329,7 +321,7 @@ TEST_F(DBOptionsTest, EnableAutoCompactionAndTriggerStall) {
           break;
       }
       Reopen(options);
-      ASSERT_OK(dbfull()->TEST_WaitForCompact());
+      dbfull()->TEST_WaitForCompact();
       ASSERT_FALSE(dbfull()->TEST_write_controler().IsStopped());
       ASSERT_FALSE(dbfull()->TEST_write_controler().NeedsDelay());
 
@@ -376,7 +368,7 @@ TEST_F(DBOptionsTest, EnableAutoCompactionAndTriggerStall) {
       TEST_SYNC_POINT("DBOptionsTest::EnableAutoCompactionAndTriggerStall:3");
 
       // Background compaction executed.
-      ASSERT_OK(dbfull()->TEST_WaitForCompact());
+      dbfull()->TEST_WaitForCompact();
       ASSERT_FALSE(dbfull()->TEST_write_controler().IsStopped());
       ASSERT_FALSE(dbfull()->TEST_write_controler().NeedsDelay());
     }
@@ -393,12 +385,12 @@ TEST_F(DBOptionsTest, SetOptionsMayTriggerCompaction) {
     // Need to insert two keys to avoid trivial move.
     ASSERT_OK(Put("foo", ToString(i)));
     ASSERT_OK(Put("bar", ToString(i)));
-    ASSERT_OK(Flush());
+    Flush();
   }
   ASSERT_EQ("3", FilesPerLevel());
   ASSERT_OK(
       dbfull()->SetOptions({{"level0_file_num_compaction_trigger", "3"}}));
-  ASSERT_OK(dbfull()->TEST_WaitForCompact());
+  dbfull()->TEST_WaitForCompact();
   ASSERT_EQ("0,1", FilesPerLevel());
 }
 
@@ -520,7 +512,7 @@ TEST_F(DBOptionsTest, MaxTotalWalSizeChange) {
   ASSERT_OK(dbfull()->SetDBOptions({{"max_total_wal_size", "10"}}));
 
   for (size_t cf = 0; cf < handles_.size(); ++cf) {
-    ASSERT_OK(dbfull()->TEST_WaitForFlushMemTable(handles_[cf]));
+    dbfull()->TEST_WaitForFlushMemTable(handles_[cf]);
     ASSERT_EQ("1", FilesPerLevel(static_cast<int>(cf)));
   }
 }
@@ -622,7 +614,6 @@ TEST_F(DBOptionsTest, MaxOpenFilesChange) {
 
 TEST_F(DBOptionsTest, SanitizeDelayedWriteRate) {
   Options options;
-  options.env = CurrentOptions().env;
   options.delayed_write_rate = 0;
   Reopen(options);
   ASSERT_EQ(16 * 1024 * 1024, dbfull()->GetDBOptions().delayed_write_rate);
@@ -634,7 +625,6 @@ TEST_F(DBOptionsTest, SanitizeDelayedWriteRate) {
 
 TEST_F(DBOptionsTest, SanitizeUniversalTTLCompaction) {
   Options options;
-  options.env = CurrentOptions().env;
   options.compaction_style = kCompactionStyleUniversal;
 
   options.ttl = 0;
@@ -664,7 +654,6 @@ TEST_F(DBOptionsTest, SanitizeUniversalTTLCompaction) {
 
 TEST_F(DBOptionsTest, SanitizeTtlDefault) {
   Options options;
-  options.env = CurrentOptions().env;
   Reopen(options);
   ASSERT_EQ(30 * 24 * 60 * 60, dbfull()->GetOptions().ttl);
 
@@ -681,7 +670,6 @@ TEST_F(DBOptionsTest, SanitizeTtlDefault) {
 TEST_F(DBOptionsTest, SanitizeFIFOPeriodicCompaction) {
   Options options;
   options.compaction_style = kCompactionStyleFIFO;
-  options.env = CurrentOptions().env;
   options.ttl = 0;
   Reopen(options);
   ASSERT_EQ(30 * 24 * 60 * 60, dbfull()->GetOptions().ttl);
@@ -707,7 +695,6 @@ TEST_F(DBOptionsTest, SanitizeFIFOPeriodicCompaction) {
 
 TEST_F(DBOptionsTest, SetFIFOCompactionOptions) {
   Options options;
-  options.env = CurrentOptions().env;
   options.compaction_style = kCompactionStyleFIFO;
   options.write_buffer_size = 10 << 10;  // 10KB
   options.arena_block_size = 4096;
@@ -738,13 +725,13 @@ TEST_F(DBOptionsTest, SetFIFOCompactionOptions) {
 
   // No files should be compacted as ttl is set to 1 hour.
   ASSERT_EQ(dbfull()->GetOptions().ttl, 3600);
-  ASSERT_OK(dbfull()->CompactRange(CompactRangeOptions(), nullptr, nullptr));
+  dbfull()->CompactRange(CompactRangeOptions(), nullptr, nullptr);
   ASSERT_EQ(NumTableFilesAtLevel(0), 10);
 
   // Set ttl to 1 minute. So all files should get deleted.
   ASSERT_OK(dbfull()->SetOptions({{"ttl", "60"}}));
   ASSERT_EQ(dbfull()->GetOptions().ttl, 60);
-  ASSERT_OK(dbfull()->CompactRange(CompactRangeOptions(), nullptr, nullptr));
+  dbfull()->CompactRange(CompactRangeOptions(), nullptr, nullptr);
   ASSERT_OK(dbfull()->TEST_WaitForCompact());
   ASSERT_EQ(NumTableFilesAtLevel(0), 0);
 
@@ -760,7 +747,7 @@ TEST_F(DBOptionsTest, SetFIFOCompactionOptions) {
     for (int j = 0; j < 10; j++) {
       ASSERT_OK(Put(ToString(i * 20 + j), rnd.RandomString(980)));
     }
-    ASSERT_OK(Flush());
+    Flush();
   }
   ASSERT_OK(dbfull()->TEST_WaitForCompact());
   ASSERT_EQ(NumTableFilesAtLevel(0), 10);
@@ -768,7 +755,7 @@ TEST_F(DBOptionsTest, SetFIFOCompactionOptions) {
   // No files should be compacted as max_table_files_size is set to 500 KB.
   ASSERT_EQ(dbfull()->GetOptions().compaction_options_fifo.max_table_files_size,
             500 << 10);
-  ASSERT_OK(dbfull()->CompactRange(CompactRangeOptions(), nullptr, nullptr));
+  dbfull()->CompactRange(CompactRangeOptions(), nullptr, nullptr);
   ASSERT_EQ(NumTableFilesAtLevel(0), 10);
 
   // Set max_table_files_size to 12 KB. So only 1 file should remain now.
@@ -776,7 +763,7 @@ TEST_F(DBOptionsTest, SetFIFOCompactionOptions) {
       {{"compaction_options_fifo", "{max_table_files_size=12288;}"}}));
   ASSERT_EQ(dbfull()->GetOptions().compaction_options_fifo.max_table_files_size,
             12 << 10);
-  ASSERT_OK(dbfull()->CompactRange(CompactRangeOptions(), nullptr, nullptr));
+  dbfull()->CompactRange(CompactRangeOptions(), nullptr, nullptr);
   ASSERT_OK(dbfull()->TEST_WaitForCompact());
   ASSERT_EQ(NumTableFilesAtLevel(0), 1);
 
@@ -792,7 +779,7 @@ TEST_F(DBOptionsTest, SetFIFOCompactionOptions) {
     for (int j = 0; j < 10; j++) {
       ASSERT_OK(Put(ToString(i * 20 + j), rnd.RandomString(980)));
     }
-    ASSERT_OK(Flush());
+    Flush();
   }
   ASSERT_OK(dbfull()->TEST_WaitForCompact());
   ASSERT_EQ(NumTableFilesAtLevel(0), 10);
@@ -801,7 +788,7 @@ TEST_F(DBOptionsTest, SetFIFOCompactionOptions) {
   // allow_compaction is false
   ASSERT_EQ(dbfull()->GetOptions().compaction_options_fifo.allow_compaction,
             false);
-  ASSERT_OK(dbfull()->CompactRange(CompactRangeOptions(), nullptr, nullptr));
+  dbfull()->CompactRange(CompactRangeOptions(), nullptr, nullptr);
   ASSERT_EQ(NumTableFilesAtLevel(0), 10);
 
   // Set allow_compaction to true. So number of files should be between 1 and 5.
@@ -809,7 +796,7 @@ TEST_F(DBOptionsTest, SetFIFOCompactionOptions) {
       {{"compaction_options_fifo", "{allow_compaction=true;}"}}));
   ASSERT_EQ(dbfull()->GetOptions().compaction_options_fifo.allow_compaction,
             true);
-  ASSERT_OK(dbfull()->CompactRange(CompactRangeOptions(), nullptr, nullptr));
+  dbfull()->CompactRange(CompactRangeOptions(), nullptr, nullptr);
   ASSERT_OK(dbfull()->TEST_WaitForCompact());
   ASSERT_GE(NumTableFilesAtLevel(0), 1);
   ASSERT_LE(NumTableFilesAtLevel(0), 5);
@@ -830,14 +817,14 @@ TEST_F(DBOptionsTest, CompactionReadaheadSizeChange) {
   ASSERT_OK(dbfull()->SetDBOptions({{"compaction_readahead_size", "256"}}));
   ASSERT_EQ(256, dbfull()->GetDBOptions().compaction_readahead_size);
   for (int i = 0; i < 1024; i++) {
-    ASSERT_OK(Put(Key(i), kValue));
+    Put(Key(i), kValue);
   }
-  ASSERT_OK(Flush());
+  Flush();
   for (int i = 0; i < 1024 * 2; i++) {
-    ASSERT_OK(Put(Key(i), kValue));
+    Put(Key(i), kValue);
   }
-  ASSERT_OK(Flush());
-  ASSERT_OK(dbfull()->TEST_WaitForCompact());
+  Flush();
+  dbfull()->TEST_WaitForCompact();
   ASSERT_EQ(256, env_->compaction_readahead_size_);
   Close();
 }
@@ -847,7 +834,6 @@ TEST_F(DBOptionsTest, FIFOTtlBackwardCompatible) {
   options.compaction_style = kCompactionStyleFIFO;
   options.write_buffer_size = 10 << 10;  // 10KB
   options.create_if_missing = true;
-  options.env = CurrentOptions().env;
 
   ASSERT_OK(TryReopen(options));
 
@@ -857,7 +843,7 @@ TEST_F(DBOptionsTest, FIFOTtlBackwardCompatible) {
     for (int j = 0; j < 10; j++) {
       ASSERT_OK(Put(ToString(i * 20 + j), rnd.RandomString(980)));
     }
-    ASSERT_OK(Flush());
+    Flush();
   }
   ASSERT_OK(dbfull()->TEST_WaitForCompact());
   ASSERT_EQ(NumTableFilesAtLevel(0), 10);
@@ -901,7 +887,6 @@ TEST_F(DBOptionsTest, ChangeCompression) {
   options.bottommost_compression = CompressionType::kNoCompression;
   options.bottommost_compression_opts.level = 2;
   options.bottommost_compression_opts.parallel_threads = 1;
-  options.env = CurrentOptions().env;
 
   ASSERT_OK(TryReopen(options));
 
@@ -923,7 +908,7 @@ TEST_F(DBOptionsTest, ChangeCompression) {
   ASSERT_OK(Put("foo", "foofoofoo"));
   ASSERT_OK(Put("bar", "foofoofoo"));
   ASSERT_OK(Flush());
-  ASSERT_OK(dbfull()->TEST_WaitForCompact());
+  dbfull()->TEST_WaitForCompact();
   ASSERT_TRUE(compacted);
   ASSERT_EQ(CompressionType::kNoCompression, compression_used);
   ASSERT_EQ(options.compression_opts.level, compression_opt_used.level);
@@ -941,7 +926,7 @@ TEST_F(DBOptionsTest, ChangeCompression) {
   ASSERT_OK(Put("foo", "foofoofoo"));
   ASSERT_OK(Put("bar", "foofoofoo"));
   ASSERT_OK(Flush());
-  ASSERT_OK(dbfull()->TEST_WaitForCompact());
+  dbfull()->TEST_WaitForCompact();
   ASSERT_TRUE(compacted);
   ASSERT_EQ(CompressionType::kSnappyCompression, compression_used);
   ASSERT_EQ(6, compression_opt_used.level);
@@ -952,66 +937,6 @@ TEST_F(DBOptionsTest, ChangeCompression) {
 
 #endif  // ROCKSDB_LITE
 
-TEST_F(DBOptionsTest, BottommostCompressionOptsWithFallbackType) {
-  // Verify the bottommost compression options still take effect even when the
-  // bottommost compression type is left at its default value. Verify for both
-  // automatic and manual compaction.
-  if (!Snappy_Supported() || !LZ4_Supported()) {
-    return;
-  }
-
-  constexpr int kUpperCompressionLevel = 1;
-  constexpr int kBottommostCompressionLevel = 2;
-  constexpr int kNumL0Files = 2;
-
-  Options options = CurrentOptions();
-  options.level0_file_num_compaction_trigger = kNumL0Files;
-  options.compression = CompressionType::kLZ4Compression;
-  options.compression_opts.level = kUpperCompressionLevel;
-  options.bottommost_compression_opts.level = kBottommostCompressionLevel;
-  options.bottommost_compression_opts.enabled = true;
-  Reopen(options);
-
-  CompressionType compression_used = CompressionType::kDisableCompressionOption;
-  CompressionOptions compression_opt_used;
-  bool compacted = false;
-  SyncPoint::GetInstance()->SetCallBack(
-      "CompactionPicker::RegisterCompaction:Registered", [&](void* arg) {
-        Compaction* c = static_cast<Compaction*>(arg);
-        compression_used = c->output_compression();
-        compression_opt_used = c->output_compression_opts();
-        compacted = true;
-      });
-  SyncPoint::GetInstance()->EnableProcessing();
-
-  // First, verify for automatic compaction.
-  for (int i = 0; i < kNumL0Files; ++i) {
-    ASSERT_OK(Put("foo", "foofoofoo"));
-    ASSERT_OK(Put("bar", "foofoofoo"));
-    ASSERT_OK(Flush());
-  }
-  ASSERT_OK(dbfull()->TEST_WaitForCompact());
-
-  ASSERT_TRUE(compacted);
-  ASSERT_EQ(CompressionType::kLZ4Compression, compression_used);
-  ASSERT_EQ(kBottommostCompressionLevel, compression_opt_used.level);
-
-  // Second, verify for manual compaction.
-  compacted = false;
-  compression_used = CompressionType::kDisableCompressionOption;
-  compression_opt_used = CompressionOptions();
-  CompactRangeOptions cro;
-  cro.bottommost_level_compaction = BottommostLevelCompaction::kForceOptimized;
-  ASSERT_OK(dbfull()->CompactRange(cro, nullptr, nullptr));
-
-  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->DisableProcessing();
-  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->ClearAllCallBacks();
-
-  ASSERT_TRUE(compacted);
-  ASSERT_EQ(CompressionType::kLZ4Compression, compression_used);
-  ASSERT_EQ(kBottommostCompressionLevel, compression_opt_used.level);
-}
-
 }  // namespace ROCKSDB_NAMESPACE
 
 int main(int argc, char** argv) {

db/db_properties_test.cc

@@ -27,7 +27,7 @@ namespace ROCKSDB_NAMESPACE {
 class DBPropertiesTest : public DBTestBase {
  public:
   DBPropertiesTest()
-      : DBTestBase("/db_properties_test", /*env_do_fsync=*/false) {}
+      : DBTestBase("/db_properties_test", /*env_do_fsync=*/true) {}
 };
 
 #ifndef ROCKSDB_LITE
@@ -53,12 +53,12 @@ TEST_F(DBPropertiesTest, Empty) {
 
     // Block sync calls
     env_->delay_sstable_sync_.store(true, std::memory_order_release);
-    ASSERT_OK(Put(1, "k1", std::string(100000, 'x')));  // Fill memtable
+    Put(1, "k1", std::string(100000, 'x'));  // Fill memtable
     ASSERT_TRUE(dbfull()->GetProperty(
         handles_[1], "rocksdb.num-entries-active-mem-table", &num));
     ASSERT_EQ("2", num);
 
-    ASSERT_OK(Put(1, "k2", std::string(100000, 'y')));  // Trigger compaction
+    Put(1, "k2", std::string(100000, 'y'));  // Trigger compaction
     ASSERT_TRUE(dbfull()->GetProperty(
         handles_[1], "rocksdb.num-entries-active-mem-table", &num));
     ASSERT_EQ("1", num);
@@ -98,10 +98,10 @@ TEST_F(DBPropertiesTest, CurrentVersionNumber) {
   uint64_t v1, v2, v3;
   ASSERT_TRUE(
       dbfull()->GetIntProperty("rocksdb.current-super-version-number", &v1));
-  ASSERT_OK(Put("12345678", ""));
+  Put("12345678", "");
   ASSERT_TRUE(
       dbfull()->GetIntProperty("rocksdb.current-super-version-number", &v2));
-  ASSERT_OK(Flush());
+  Flush();
   ASSERT_TRUE(
       dbfull()->GetIntProperty("rocksdb.current-super-version-number", &v3));
 
@@ -127,8 +127,8 @@ TEST_F(DBPropertiesTest, GetAggregatedIntPropertyTest) {
   Random rnd(301);
   for (auto* handle : handles_) {
     for (int i = 0; i < kKeyNum; ++i) {
-      ASSERT_OK(db_->Put(WriteOptions(), handle, rnd.RandomString(kKeySize),
-                         rnd.RandomString(kValueSize)));
+      db_->Put(WriteOptions(), handle, rnd.RandomString(kKeySize),
+               rnd.RandomString(kValueSize));
     }
   }
 
@@ -154,7 +154,7 @@ TEST_F(DBPropertiesTest, GetAggregatedIntPropertyTest) {
         DB::Properties::kEstimateTableReadersMem, &before_flush_trm));
 
     // Issue flush and expect larger memory usage of table readers.
-    ASSERT_OK(db_->Flush(FlushOptions(), handle));
+    db_->Flush(FlushOptions(), handle);
 
     ASSERT_TRUE(db_->GetAggregatedIntProperty(
         DB::Properties::kEstimateTableReadersMem, &after_flush_trm));
@@ -300,9 +300,9 @@ TEST_F(DBPropertiesTest, ValidateSampleNumber) {
     for (int i = 0; i < files; i++) {
       int rows = files / 10;
       for (int j = 0; j < rows; j++) {
-        ASSERT_OK(db_->Put(WriteOptions(), std::to_string(++key), "foo"));
+        db_->Put(WriteOptions(), std::to_string(++key), "foo");
       }
-      ASSERT_OK(db_->Flush(FlushOptions()));
+      db_->Flush(FlushOptions());
     }
   }
   std::string num;
@@ -336,7 +336,7 @@ TEST_F(DBPropertiesTest, AggregatedTableProperties) {
     table_options.filter_policy.reset(
         NewBloomFilterPolicy(kBloomBitsPerKey, false));
     table_options.block_size = 1024;
-    options.table_factory.reset(NewBlockBasedTableFactory(table_options));
+    options.table_factory.reset(new BlockBasedTableFactory(table_options));
 
     DestroyAndReopen(options);
 
@@ -347,24 +347,23 @@ TEST_F(DBPropertiesTest, AggregatedTableProperties) {
     Random rnd(5632);
     for (int table = 1; table <= kTableCount; ++table) {
       for (int i = 0; i < kPutsPerTable; ++i) {
-        ASSERT_OK(db_->Put(WriteOptions(), rnd.RandomString(kKeySize),
-                           rnd.RandomString(kValueSize)));
+        db_->Put(WriteOptions(), rnd.RandomString(kKeySize),
+                 rnd.RandomString(kValueSize));
       }
       for (int i = 0; i < kDeletionsPerTable; i++) {
-        ASSERT_OK(db_->Delete(WriteOptions(), rnd.RandomString(kKeySize)));
+        db_->Delete(WriteOptions(), rnd.RandomString(kKeySize));
       }
       for (int i = 0; i < kMergeOperandsPerTable; i++) {
-        ASSERT_OK(db_->Merge(WriteOptions(), rnd.RandomString(kKeySize),
-                             rnd.RandomString(kValueSize)));
+        db_->Merge(WriteOptions(), rnd.RandomString(kKeySize),
+                   rnd.RandomString(kValueSize));
       }
       for (int i = 0; i < kRangeDeletionsPerTable; i++) {
         std::string start = rnd.RandomString(kKeySize);
         std::string end = start;
         end.resize(kValueSize);
-        ASSERT_OK(db_->DeleteRange(WriteOptions(), db_->DefaultColumnFamily(),
-                                   start, end));
+        db_->DeleteRange(WriteOptions(), db_->DefaultColumnFamily(), start, end);
       }
-      ASSERT_OK(db_->Flush(FlushOptions()));
+      db_->Flush(FlushOptions());
     }
     std::string property;
     db_->GetProperty(DB::Properties::kAggregatedTableProperties, &property);
@@ -411,11 +410,11 @@ TEST_F(DBPropertiesTest, ReadLatencyHistogramByLevel) {
   int key_index = 0;
   Random rnd(301);
   for (int num = 0; num < 8; num++) {
-    ASSERT_OK(Put("foo", "bar"));
+    Put("foo", "bar");
     GenerateNewFile(&rnd, &key_index);
-    ASSERT_OK(dbfull()->TEST_WaitForCompact());
+    dbfull()->TEST_WaitForCompact();
   }
-  ASSERT_OK(dbfull()->TEST_WaitForCompact());
+  dbfull()->TEST_WaitForCompact();
 
   std::string prop;
   ASSERT_TRUE(dbfull()->GetProperty("rocksdb.dbstats", &prop));
@@ -431,7 +430,7 @@ TEST_F(DBPropertiesTest, ReadLatencyHistogramByLevel) {
 
   // Reopen and issue Get(). See thee latency tracked
   ReopenWithColumnFamilies({"default", "pikachu"}, options);
-  ASSERT_OK(dbfull()->TEST_WaitForCompact());
+  dbfull()->TEST_WaitForCompact();
   for (int key = 0; key < key_index; key++) {
     Get(Key(key));
   }
@@ -459,7 +458,6 @@ TEST_F(DBPropertiesTest, ReadLatencyHistogramByLevel) {
     std::unique_ptr<Iterator> iter(db_->NewIterator(ReadOptions()));
     for (iter->Seek(Key(0)); iter->Valid(); iter->Next()) {
     }
-    ASSERT_OK(iter->status());
   }
   ASSERT_TRUE(dbfull()->GetProperty("rocksdb.cf-file-histogram", &prop));
   ASSERT_NE(std::string::npos, prop.find("** Level 0 read latency histogram"));
@@ -473,9 +471,9 @@ TEST_F(DBPropertiesTest, ReadLatencyHistogramByLevel) {
   ASSERT_EQ(std::string::npos, prop.find("** Level 1 read latency histogram"));
   ASSERT_EQ(std::string::npos, prop.find("** Level 2 read latency histogram"));
   // put something and read it back , CF 1 should show histogram.
-  ASSERT_OK(Put(1, "foo", "bar"));
-  ASSERT_OK(Flush(1));
-  ASSERT_OK(dbfull()->TEST_WaitForCompact());
+  Put(1, "foo", "bar");
+  Flush(1);
+  dbfull()->TEST_WaitForCompact();
   ASSERT_EQ("bar", Get(1, "foo"));
 
   ASSERT_TRUE(
@@ -501,7 +499,7 @@ TEST_F(DBPropertiesTest, ReadLatencyHistogramByLevel) {
   ASSERT_EQ(std::string::npos, prop.find("** Level 2 read latency histogram"));
 
   // Clear internal stats
-  ASSERT_OK(dbfull()->ResetStats());
+  dbfull()->ResetStats();
   ASSERT_TRUE(dbfull()->GetProperty("rocksdb.cfstats", &prop));
   ASSERT_EQ(std::string::npos, prop.find("** Level 0 read latency histogram"));
   ASSERT_EQ(std::string::npos, prop.find("** Level 1 read latency histogram"));
@@ -536,7 +534,7 @@ TEST_F(DBPropertiesTest, AggregatedTablePropertiesAtLevel) {
   table_options.filter_policy.reset(
       NewBloomFilterPolicy(kBloomBitsPerKey, false));
   table_options.block_size = 1024;
-  options.table_factory.reset(NewBlockBasedTableFactory(table_options));
+  options.table_factory.reset(new BlockBasedTableFactory(table_options));
 
   DestroyAndReopen(options);
 
@@ -549,25 +547,24 @@ TEST_F(DBPropertiesTest, AggregatedTablePropertiesAtLevel) {
   TableProperties tp, sum_tp, expected_tp;
   for (int table = 1; table <= kTableCount; ++table) {
     for (int i = 0; i < kPutsPerTable; ++i) {
-      ASSERT_OK(db_->Put(WriteOptions(), rnd.RandomString(kKeySize),
-                         rnd.RandomString(kValueSize)));
+      db_->Put(WriteOptions(), rnd.RandomString(kKeySize),
+               rnd.RandomString(kValueSize));
     }
     for (int i = 0; i < kDeletionsPerTable; i++) {
-      ASSERT_OK(db_->Delete(WriteOptions(), rnd.RandomString(kKeySize)));
+      db_->Delete(WriteOptions(), rnd.RandomString(kKeySize));
     }
     for (int i = 0; i < kMergeOperandsPerTable; i++) {
-      ASSERT_OK(db_->Merge(WriteOptions(), rnd.RandomString(kKeySize),
-                           rnd.RandomString(kValueSize)));
+      db_->Merge(WriteOptions(), rnd.RandomString(kKeySize),
+                 rnd.RandomString(kValueSize));
     }
     for (int i = 0; i < kRangeDeletionsPerTable; i++) {
       std::string start = rnd.RandomString(kKeySize);
       std::string end = start;
       end.resize(kValueSize);
-      ASSERT_OK(db_->DeleteRange(WriteOptions(), db_->DefaultColumnFamily(),
-                                 start, end));
+      db_->DeleteRange(WriteOptions(), db_->DefaultColumnFamily(), start, end);
     }
-    ASSERT_OK(db_->Flush(FlushOptions()));
-    ASSERT_OK(db_->CompactRange(CompactRangeOptions(), nullptr, nullptr));
+    db_->Flush(FlushOptions());
+    db_->CompactRange(CompactRangeOptions(), nullptr, nullptr);
     ResetTableProperties(&sum_tp);
     for (int level = 0; level < kMaxLevel; ++level) {
       db_->GetProperty(
@@ -832,7 +829,7 @@ TEST_F(DBPropertiesTest, DISABLED_GetProperty) {
   // Wait for compaction to be done. This is important because otherwise RocksDB
   // might schedule a compaction when reopening the database, failing assertion
   // (A) as a result.
-  ASSERT_OK(dbfull()->TEST_WaitForCompact());
+  dbfull()->TEST_WaitForCompact();
   options.max_open_files = 10;
   Reopen(options);
   // After reopening, no table reader is loaded, so no memory for table readers
@@ -860,7 +857,7 @@ TEST_F(DBPropertiesTest, DISABLED_GetProperty) {
     std::unique_ptr<Iterator> iter1(dbfull()->NewIterator(ReadOptions()));
 
     ASSERT_OK(dbfull()->Put(writeOpt, "k6", big_value));
-    ASSERT_OK(Flush());
+    Flush();
     ASSERT_TRUE(
         dbfull()->GetIntProperty("rocksdb.num-live-versions", &int_num));
     ASSERT_EQ(int_num, 2U);
@@ -869,7 +866,7 @@ TEST_F(DBPropertiesTest, DISABLED_GetProperty) {
     std::unique_ptr<Iterator> iter2(dbfull()->NewIterator(ReadOptions()));
 
     ASSERT_OK(dbfull()->Put(writeOpt, "k7", big_value));
-    ASSERT_OK(Flush());
+    Flush();
     ASSERT_TRUE(
         dbfull()->GetIntProperty("rocksdb.num-live-versions", &int_num));
     ASSERT_EQ(int_num, 3U);
@@ -924,12 +921,11 @@ TEST_F(DBPropertiesTest, ApproximateMemoryUsage) {
   for (int r = 0; r < kNumRounds; ++r) {
     for (int f = 0; f < kFlushesPerRound; ++f) {
       for (int w = 0; w < kWritesPerFlush; ++w) {
-        ASSERT_OK(
-            Put(rnd.RandomString(kKeySize), rnd.RandomString(kValueSize)));
+        Put(rnd.RandomString(kKeySize), rnd.RandomString(kValueSize));
       }
     }
     // Make sure that there is no flush between getting the two properties.
-    ASSERT_OK(dbfull()->TEST_WaitForFlushMemTable());
+    dbfull()->TEST_WaitForFlushMemTable();
     dbfull()->GetIntProperty("rocksdb.cur-size-all-mem-tables", &unflushed_mem);
     dbfull()->GetIntProperty("rocksdb.size-all-mem-tables", &all_mem);
     // in no iterator case, these two number should be the same.
@@ -943,13 +939,12 @@ TEST_F(DBPropertiesTest, ApproximateMemoryUsage) {
     iters.push_back(db_->NewIterator(ReadOptions()));
     for (int f = 0; f < kFlushesPerRound; ++f) {
       for (int w = 0; w < kWritesPerFlush; ++w) {
-        ASSERT_OK(
-            Put(rnd.RandomString(kKeySize), rnd.RandomString(kValueSize)));
+        Put(rnd.RandomString(kKeySize), rnd.RandomString(kValueSize));
       }
     }
     // Force flush to prevent flush from happening between getting the
     // properties or after getting the properties and before the new round.
-    ASSERT_OK(Flush());
+    Flush();
 
     // In the second round, add iterators.
     dbfull()->GetIntProperty("rocksdb.cur-size-active-mem-table", &active_mem);
@@ -964,7 +959,6 @@ TEST_F(DBPropertiesTest, ApproximateMemoryUsage) {
   // Phase 3. Delete iterators and expect "size-all-mem-tables" shrinks
   // whenever we release an iterator.
   for (auto* iter : iters) {
-    ASSERT_OK(iter->status());
     delete iter;
     dbfull()->GetIntProperty("rocksdb.size-all-mem-tables", &all_mem);
     // Expect the size shrinking
@@ -1014,19 +1008,19 @@ TEST_F(DBPropertiesTest, EstimatePendingCompBytes) {
   uint64_t int_num;
 
   ASSERT_OK(dbfull()->Put(writeOpt, "k1", big_value));
-  ASSERT_OK(Flush());
+  Flush();
   ASSERT_TRUE(dbfull()->GetIntProperty(
       "rocksdb.estimate-pending-compaction-bytes", &int_num));
   ASSERT_EQ(int_num, 0U);
 
   ASSERT_OK(dbfull()->Put(writeOpt, "k2", big_value));
-  ASSERT_OK(Flush());
+  Flush();
   ASSERT_TRUE(dbfull()->GetIntProperty(
       "rocksdb.estimate-pending-compaction-bytes", &int_num));
   ASSERT_GT(int_num, 0U);
 
   ASSERT_OK(dbfull()->Put(writeOpt, "k3", big_value));
-  ASSERT_OK(Flush());
+  Flush();
   ASSERT_TRUE(dbfull()->GetIntProperty(
       "rocksdb.estimate-pending-compaction-bytes", &int_num));
   ASSERT_GT(int_num, 0U);
@@ -1034,7 +1028,7 @@ TEST_F(DBPropertiesTest, EstimatePendingCompBytes) {
   sleeping_task_low.WakeUp();
   sleeping_task_low.WaitUntilDone();
 
-  ASSERT_OK(dbfull()->TEST_WaitForCompact());
+  dbfull()->TEST_WaitForCompact();
   ASSERT_TRUE(dbfull()->GetIntProperty(
       "rocksdb.estimate-pending-compaction-bytes", &int_num));
   ASSERT_EQ(int_num, 0U);
@@ -1064,7 +1058,7 @@ TEST_F(DBPropertiesTest, EstimateCompressionRatio) {
       std::string key = ToString(i) + ToString(j) + "key";
       ASSERT_OK(dbfull()->Put(WriteOptions(), key, kVal));
     }
-    ASSERT_OK(Flush());
+    Flush();
   }
 
   // no compression at L0, so ratio is less than one
@@ -1072,7 +1066,7 @@ TEST_F(DBPropertiesTest, EstimateCompressionRatio) {
   ASSERT_GT(CompressionRatioAtLevel(0), 0.0);
   ASSERT_EQ(CompressionRatioAtLevel(1), -1.0);
 
-  ASSERT_OK(dbfull()->TEST_CompactRange(0, nullptr, nullptr));
+  dbfull()->TEST_CompactRange(0, nullptr, nullptr);
 
   ASSERT_EQ(CompressionRatioAtLevel(0), -1.0);
   // Data at L1 should be highly compressed thanks to Snappy and redundant data
@@ -1187,9 +1181,9 @@ TEST_F(DBPropertiesTest, GetUserDefinedTableProperties) {
   // Create 4 tables
   for (int table = 0; table < 4; ++table) {
     for (int i = 0; i < 10 + table; ++i) {
-      ASSERT_OK(db_->Put(WriteOptions(), ToString(table * 100 + i), "val"));
+      db_->Put(WriteOptions(), ToString(table * 100 + i), "val");
     }
-    ASSERT_OK(db_->Flush(FlushOptions()));
+    db_->Flush(FlushOptions());
   }
 
   TablePropertiesCollection props;
@@ -1211,7 +1205,7 @@ TEST_F(DBPropertiesTest, GetUserDefinedTableProperties) {
 
   ASSERT_GT(collector_factory->num_created_, 0U);
   collector_factory->num_created_ = 0;
-  ASSERT_OK(dbfull()->TEST_CompactRange(0, nullptr, nullptr));
+  dbfull()->TEST_CompactRange(0, nullptr, nullptr);
   ASSERT_GT(collector_factory->num_created_, 0U);
 }
 #endif  // ROCKSDB_LITE
@@ -1227,9 +1221,9 @@ TEST_F(DBPropertiesTest, UserDefinedTablePropertiesContext) {
   // Create 2 files
   for (int table = 0; table < 2; ++table) {
     for (int i = 0; i < 10 + table; ++i) {
-      ASSERT_OK(Put(1, ToString(table * 100 + i), "val"));
+      Put(1, ToString(table * 100 + i), "val");
     }
-    ASSERT_OK(Flush(1));
+    Flush(1);
   }
   ASSERT_GT(collector_factory->num_created_, 0U);
 
@@ -1237,15 +1231,15 @@ TEST_F(DBPropertiesTest, UserDefinedTablePropertiesContext) {
   // Trigger automatic compactions.
   for (int table = 0; table < 3; ++table) {
     for (int i = 0; i < 10 + table; ++i) {
-      ASSERT_OK(Put(1, ToString(table * 100 + i), "val"));
+      Put(1, ToString(table * 100 + i), "val");
     }
-    ASSERT_OK(Flush(1));
-    ASSERT_OK(dbfull()->TEST_WaitForCompact());
+    Flush(1);
+    dbfull()->TEST_WaitForCompact();
   }
   ASSERT_GT(collector_factory->num_created_, 0U);
 
   collector_factory->num_created_ = 0;
-  ASSERT_OK(dbfull()->TEST_CompactRange(0, nullptr, nullptr, handles_[1]));
+  dbfull()->TEST_CompactRange(0, nullptr, nullptr, handles_[1]);
   ASSERT_GT(collector_factory->num_created_, 0U);
 
   // Come back to write to default column family
@@ -1254,9 +1248,9 @@ TEST_F(DBPropertiesTest, UserDefinedTablePropertiesContext) {
   // Create 4 tables in default column family
   for (int table = 0; table < 2; ++table) {
     for (int i = 0; i < 10 + table; ++i) {
-      ASSERT_OK(Put(ToString(table * 100 + i), "val"));
+      Put(ToString(table * 100 + i), "val");
     }
-    ASSERT_OK(Flush());
+    Flush();
   }
   ASSERT_GT(collector_factory->num_created_, 0U);
 
@@ -1264,15 +1258,15 @@ TEST_F(DBPropertiesTest, UserDefinedTablePropertiesContext) {
   // Trigger automatic compactions.
   for (int table = 0; table < 3; ++table) {
     for (int i = 0; i < 10 + table; ++i) {
-      ASSERT_OK(Put(ToString(table * 100 + i), "val"));
+      Put(ToString(table * 100 + i), "val");
     }
-    ASSERT_OK(Flush());
-    ASSERT_OK(dbfull()->TEST_WaitForCompact());
+    Flush();
+    dbfull()->TEST_WaitForCompact();
   }
   ASSERT_GT(collector_factory->num_created_, 0U);
 
   collector_factory->num_created_ = 0;
-  ASSERT_OK(dbfull()->TEST_CompactRange(0, nullptr, nullptr));
+  dbfull()->TEST_CompactRange(0, nullptr, nullptr);
   ASSERT_GT(collector_factory->num_created_, 0U);
 }
 
@@ -1306,15 +1300,15 @@ TEST_F(DBPropertiesTest, TablePropertiesNeedCompactTest) {
     ASSERT_OK(Put(Key(i), rnd.RandomString(102)));
     ASSERT_OK(Put(Key(kMaxKey + i), rnd.RandomString(102)));
   }
-  ASSERT_OK(Flush());
-  ASSERT_OK(dbfull()->TEST_WaitForCompact());
+  Flush();
+  dbfull()->TEST_WaitForCompact();
   if (NumTableFilesAtLevel(0) == 1) {
     // Clear Level 0 so that when later flush a file with deletions,
     // we don't trigger an organic compaction.
     ASSERT_OK(Put(Key(0), ""));
     ASSERT_OK(Put(Key(kMaxKey * 2), ""));
-    ASSERT_OK(Flush());
-    ASSERT_OK(dbfull()->TEST_WaitForCompact());
+    Flush();
+    dbfull()->TEST_WaitForCompact();
   }
   ASSERT_EQ(NumTableFilesAtLevel(0), 0);
 
@@ -1326,18 +1320,17 @@ TEST_F(DBPropertiesTest, TablePropertiesNeedCompactTest) {
       iter->Next();
       ++c;
     }
-    ASSERT_OK(iter->status());
     ASSERT_EQ(c, 200);
   }
 
-  ASSERT_OK(Delete(Key(0)));
+  Delete(Key(0));
   for (int i = kMaxKey - 100; i < kMaxKey + 100; i++) {
-    ASSERT_OK(Delete(Key(i)));
+    Delete(Key(i));
   }
-  ASSERT_OK(Delete(Key(kMaxKey * 2)));
+  Delete(Key(kMaxKey * 2));
 
-  ASSERT_OK(Flush());
-  ASSERT_OK(dbfull()->TEST_WaitForCompact());
+  Flush();
+  dbfull()->TEST_WaitForCompact();
 
   {
     SetPerfLevel(kEnableCount);
@@ -1348,7 +1341,6 @@ TEST_F(DBPropertiesTest, TablePropertiesNeedCompactTest) {
     while (iter->Valid() && iter->key().compare(Key(kMaxKey + 100)) < 0) {
       iter->Next();
     }
-    ASSERT_OK(iter->status());
     ASSERT_EQ(c, 0);
     ASSERT_LT(get_perf_context()->internal_delete_skipped_count, 30u);
     ASSERT_LT(get_perf_context()->internal_key_skipped_count, 30u);
@@ -1379,14 +1371,14 @@ TEST_F(DBPropertiesTest, NeedCompactHintPersistentTest) {
   for (int i = 0; i < kMaxKey; i++) {
     ASSERT_OK(Put(Key(i), ""));
   }
-  ASSERT_OK(Flush());
-  ASSERT_OK(dbfull()->TEST_WaitForFlushMemTable());
+  Flush();
+  dbfull()->TEST_WaitForFlushMemTable();
 
   for (int i = 1; i < kMaxKey - 1; i++) {
-    ASSERT_OK(Delete(Key(i)));
+    Delete(Key(i));
   }
-  ASSERT_OK(Flush());
-  ASSERT_OK(dbfull()->TEST_WaitForFlushMemTable());
+  Flush();
+  dbfull()->TEST_WaitForFlushMemTable();
   ASSERT_EQ(NumTableFilesAtLevel(0), 2);
 
   // Restart the DB. Although number of files didn't reach
@@ -1394,7 +1386,7 @@ TEST_F(DBPropertiesTest, NeedCompactHintPersistentTest) {
   // still be triggered because of the need-compaction hint.
   options.disable_auto_compactions = false;
   Reopen(options);
-  ASSERT_OK(dbfull()->TEST_WaitForCompact());
+  dbfull()->TEST_WaitForCompact();
   ASSERT_EQ(NumTableFilesAtLevel(0), 0);
   {
     SetPerfLevel(kEnableCount);
@@ -1404,7 +1396,6 @@ TEST_F(DBPropertiesTest, NeedCompactHintPersistentTest) {
     for (iter->Seek(Key(0)); iter->Valid(); iter->Next()) {
       c++;
     }
-    ASSERT_OK(iter->status());
     ASSERT_EQ(c, 2);
     ASSERT_EQ(get_perf_context()->internal_delete_skipped_count, 0);
     // We iterate every key twice. Is it a bug?
@@ -1414,11 +1405,11 @@ TEST_F(DBPropertiesTest, NeedCompactHintPersistentTest) {
 }
 
 TEST_F(DBPropertiesTest, EstimateNumKeysUnderflow) {
-  Options options = CurrentOptions();
+  Options options;
   Reopen(options);
-  ASSERT_OK(Put("foo", "bar"));
-  ASSERT_OK(Delete("foo"));
-  ASSERT_OK(Delete("foo"));
+  Put("foo", "bar");
+  Delete("foo");
+  Delete("foo");
   uint64_t num_keys = 0;
   ASSERT_TRUE(dbfull()->GetIntProperty("rocksdb.estimate-num-keys", &num_keys));
   ASSERT_EQ(0, num_keys);
@@ -1524,7 +1515,6 @@ TEST_F(DBPropertiesTest, SstFilesSize) {
   std::shared_ptr<TestListener> listener = std::make_shared<TestListener>();
 
   Options options;
-  options.env = CurrentOptions().env;
   options.disable_auto_compactions = true;
   options.listeners.push_back(listener);
   Reopen(options);
@@ -1597,11 +1587,11 @@ TEST_F(DBPropertiesTest, MinObsoleteSstNumberToKeep) {
 
   for (int i = 0; i < kNumL0Files; ++i) {
     // Make sure they overlap in keyspace to prevent trivial move
-    ASSERT_OK(Put("key1", "val"));
-    ASSERT_OK(Put("key2", "val"));
-    ASSERT_OK(Flush());
+    Put("key1", "val");
+    Put("key2", "val");
+    Flush();
   }
-  ASSERT_OK(dbfull()->TEST_WaitForCompact());
+  dbfull()->TEST_WaitForCompact();
   ASSERT_TRUE(listener->Validated());
 }
 
@@ -1609,8 +1599,6 @@ TEST_F(DBPropertiesTest, BlockCacheProperties) {
   Options options;
   uint64_t value;
 
-  options.env = CurrentOptions().env;
-
   // Block cache properties are not available for tables other than
   // block-based table.
   options.table_factory.reset(NewPlainTableFactory());
@@ -1661,8 +1649,7 @@ TEST_F(DBPropertiesTest, BlockCacheProperties) {
 
   // Insert unpinned item to the cache and check size.
   constexpr size_t kSize1 = 50;
-  ASSERT_OK(block_cache->Insert("item1", nullptr /*value*/, kSize1,
-                                nullptr /*deleter*/));
+  block_cache->Insert("item1", nullptr /*value*/, kSize1, nullptr /*deleter*/);
   ASSERT_TRUE(db_->GetIntProperty(DB::Properties::kBlockCacheCapacity, &value));
   ASSERT_EQ(kCapacity, value);
   ASSERT_TRUE(db_->GetIntProperty(DB::Properties::kBlockCacheUsage, &value));
@@ -1674,8 +1661,8 @@ TEST_F(DBPropertiesTest, BlockCacheProperties) {
   // Insert pinned item to the cache and check size.
   constexpr size_t kSize2 = 30;
   Cache::Handle* item2 = nullptr;
-  ASSERT_OK(block_cache->Insert("item2", nullptr /*value*/, kSize2,
-                                nullptr /*deleter*/, &item2));
+  block_cache->Insert("item2", nullptr /*value*/, kSize2, nullptr /*deleter*/,
+                      &item2);
   ASSERT_NE(nullptr, item2);
   ASSERT_TRUE(db_->GetIntProperty(DB::Properties::kBlockCacheCapacity, &value));
   ASSERT_EQ(kCapacity, value);
@@ -1688,8 +1675,8 @@ TEST_F(DBPropertiesTest, BlockCacheProperties) {
   // Insert another pinned item to make the cache over-sized.
   constexpr size_t kSize3 = 80;
   Cache::Handle* item3 = nullptr;
-  ASSERT_OK(block_cache->Insert("item3", nullptr /*value*/, kSize3,
-                                nullptr /*deleter*/, &item3));
+  block_cache->Insert("item3", nullptr /*value*/, kSize3, nullptr /*deleter*/,
+                      &item3);
   ASSERT_NE(nullptr, item2);
   ASSERT_TRUE(db_->GetIntProperty(DB::Properties::kBlockCacheCapacity, &value));
   ASSERT_EQ(kCapacity, value);

db/db_range_del_test.cc

@@ -14,7 +14,7 @@ namespace ROCKSDB_NAMESPACE {
 
 class DBRangeDelTest : public DBTestBase {
  public:
-  DBRangeDelTest() : DBTestBase("/db_range_del_test", /*env_do_fsync=*/false) {}
+  DBRangeDelTest() : DBTestBase("/db_range_del_test", /*env_do_fsync=*/true) {}
 
   std::string GetNumericStr(int key) {
     uint64_t uint64_key = static_cast<uint64_t>(key);
@@ -159,7 +159,7 @@ TEST_F(DBRangeDelTest, MaxCompactionBytesCutsOutputFiles) {
   // Want max_compaction_bytes to trigger the end of compaction output file, not
   // target_file_size_base, so make the latter much bigger
   opts.target_file_size_base = 100 * opts.max_compaction_bytes;
-  DestroyAndReopen(opts);
+  Reopen(opts);
 
   // snapshot protects range tombstone from dropping due to becoming obsolete.
   const Snapshot* snapshot = db_->GetSnapshot();
@@ -269,7 +269,7 @@ TEST_F(DBRangeDelTest, FlushRemovesCoveredKeys) {
   const int kNum = 300, kRangeBegin = 50, kRangeEnd = 250;
   Options opts = CurrentOptions();
   opts.comparator = test::Uint64Comparator();
-  DestroyAndReopen(opts);
+  Reopen(opts);
 
   // Write a third before snapshot, a third between snapshot and tombstone, and
   // a third after the tombstone. Keys older than snapshot or newer than the
@@ -309,7 +309,7 @@ TEST_F(DBRangeDelTest, CompactionRemovesCoveredKeys) {
   opts.memtable_factory.reset(new SpecialSkipListFactory(kNumPerFile));
   opts.num_levels = 2;
   opts.statistics = CreateDBStatistics();
-  DestroyAndReopen(opts);
+  Reopen(opts);
 
   for (int i = 0; i < kNumFiles; ++i) {
     if (i > 0) {
@@ -603,7 +603,7 @@ TEST_F(DBRangeDelTest, TableEvictedDuringScan) {
   bbto.cache_index_and_filter_blocks = true;
   bbto.block_cache = NewLRUCache(8 << 20);
   opts.table_factory.reset(NewBlockBasedTableFactory(bbto));
-  DestroyAndReopen(opts);
+  Reopen(opts);
 
   // Hold a snapshot so range deletions can't become obsolete during compaction
   // to bottommost level (i.e., L1).
@@ -761,7 +761,7 @@ TEST_F(DBRangeDelTest, IteratorRemovesCoveredKeys) {
   Options opts = CurrentOptions();
   opts.comparator = test::Uint64Comparator();
   opts.memtable_factory.reset(new SpecialSkipListFactory(kNumPerFile));
-  DestroyAndReopen(opts);
+  Reopen(opts);
 
   // Write half of the keys before the tombstone and half after the tombstone.
   // Only covered keys (i.e., within the range and older than the tombstone)
@@ -794,7 +794,7 @@ TEST_F(DBRangeDelTest, IteratorOverUserSnapshot) {
   Options opts = CurrentOptions();
   opts.comparator = test::Uint64Comparator();
   opts.memtable_factory.reset(new SpecialSkipListFactory(kNumPerFile));
-  DestroyAndReopen(opts);
+  Reopen(opts);
 
   const Snapshot* snapshot = nullptr;
   // Put a snapshot before the range tombstone, verify an iterator using that

db/db_sst_test.cc

@@ -141,7 +141,6 @@ TEST_F(DBSSTTest, SkipCheckingSSTFileSizesOnDBOpen) {
 
   // Just open the DB with the option set to true and check that we don't crash.
   Options options;
-  options.env = env_;
   options.skip_checking_sst_file_sizes_on_db_open = true;
   Reopen(options);
 
@@ -305,14 +304,11 @@ TEST_F(DBSSTTest, DBWithSstFileManager) {
     dbfull()->TEST_WaitForFlushMemTable();
     dbfull()->TEST_WaitForCompact();
     // Verify that we are tracking all sst files in dbname_
-    std::unordered_map<std::string, uint64_t> files_in_db;
-    ASSERT_OK(GetAllSSTFiles(&files_in_db));
-    ASSERT_EQ(sfm->GetTrackedFiles(), files_in_db);
+    ASSERT_EQ(sfm->GetTrackedFiles(), GetAllSSTFiles());
   }
   ASSERT_OK(db_->CompactRange(CompactRangeOptions(), nullptr, nullptr));
 
-  std::unordered_map<std::string, uint64_t> files_in_db;
-  ASSERT_OK(GetAllSSTFiles(&files_in_db));
+  auto files_in_db = GetAllSSTFiles();
   // Verify that we are tracking all sst files in dbname_
   ASSERT_EQ(sfm->GetTrackedFiles(), files_in_db);
   // Verify the total files size
@@ -520,7 +516,7 @@ TEST_P(DBWALTestWithParam, WALTrashCleanupOnOpen) {
     bool fake_log_delete;
   };
 
-  std::unique_ptr<MyEnv> env(new MyEnv(env_));
+  std::unique_ptr<MyEnv> env(new MyEnv(Env::Default()));
   Destroy(last_options_);
 
   env->set_fake_log_delete(true);
@@ -766,8 +762,7 @@ TEST_F(DBSSTTest, DBWithMaxSpaceAllowed) {
   ASSERT_OK(Flush());
 
   uint64_t first_file_size = 0;
-  std::unordered_map<std::string, uint64_t> files_in_db;
-  ASSERT_OK(GetAllSSTFiles(&files_in_db, &first_file_size));
+  auto files_in_db = GetAllSSTFiles(&first_file_size);
   ASSERT_EQ(sfm->GetTotalSize(), first_file_size);
 
   // Set the maximum allowed space usage to the current total size
@@ -807,8 +802,7 @@ TEST_F(DBSSTTest, CancellingCompactionsWorks) {
   }
   ASSERT_OK(Flush());
   uint64_t total_file_size = 0;
-  std::unordered_map<std::string, uint64_t> files_in_db;
-  ASSERT_OK(GetAllSSTFiles(&files_in_db, &total_file_size));
+  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);
 
@@ -855,8 +849,7 @@ TEST_F(DBSSTTest, CancellingManualCompactionsWorks) {
   }
   ASSERT_OK(Flush());
   uint64_t total_file_size = 0;
-  std::unordered_map<std::string, uint64_t> files_in_db;
-  ASSERT_OK(GetAllSSTFiles(&files_in_db, &total_file_size));
+  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);
 
@@ -966,8 +959,7 @@ TEST_F(DBSSTTest, DBWithMaxSpaceAllowedRandomized) {
     }
     ASSERT_TRUE(bg_error_set);
     uint64_t total_sst_files_size = 0;
-    std::unordered_map<std::string, uint64_t> files_in_db;
-    ASSERT_OK(GetAllSSTFiles(&files_in_db, &total_sst_files_size));
+    GetAllSSTFiles(&total_sst_files_size);
     ASSERT_GE(total_sst_files_size, limit_mb * 1024 * 1024);
     ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->DisableProcessing();
   }

db/db_table_properties_test.cc

@@ -11,11 +11,9 @@
 #include <vector>
 
 #include "db/db_test_util.h"
-#include "port/port.h"
 #include "port/stack_trace.h"
 #include "rocksdb/db.h"
 #include "rocksdb/utilities/table_properties_collectors.h"
-#include "table/format.h"
 #include "test_util/testharness.h"
 #include "test_util/testutil.h"
 #include "util/random.h"
@@ -52,7 +50,7 @@ class DBTablePropertiesTest : public DBTestBase,
                               public testing::WithParamInterface<std::string> {
  public:
   DBTablePropertiesTest()
-      : DBTestBase("/db_table_properties_test", /*env_do_fsync=*/false) {}
+      : DBTestBase("/db_table_properties_test", /*env_do_fsync=*/true) {}
   TablePropertiesCollection TestGetPropertiesOfTablesInRange(
       std::vector<Range> ranges, std::size_t* num_properties = nullptr,
       std::size_t* num_files = nullptr);
@@ -276,55 +274,6 @@ TEST_F(DBTablePropertiesTest, GetDbIdentifiersProperty) {
   }
 }
 
-class DBTableHostnamePropertyTest
-    : public DBTestBase,
-      public ::testing::WithParamInterface<std::tuple<int, std::string>> {
- public:
-  DBTableHostnamePropertyTest()
-      : DBTestBase("/db_table_hostname_property_test",
-                   /*env_do_fsync=*/false) {}
-};
-
-TEST_P(DBTableHostnamePropertyTest, DbHostLocationProperty) {
-  option_config_ = std::get<0>(GetParam());
-  Options opts = CurrentOptions();
-  std::string expected_host_id = std::get<1>(GetParam());
-  ;
-  if (expected_host_id == kHostnameForDbHostId) {
-    ASSERT_OK(env_->GetHostNameString(&expected_host_id));
-  } else {
-    opts.db_host_id = expected_host_id;
-  }
-  CreateAndReopenWithCF({"goku"}, opts);
-
-  for (uint32_t cf = 0; cf < 2; ++cf) {
-    Put(cf, "key", "val");
-    Put(cf, "foo", "bar");
-    Flush(cf);
-
-    TablePropertiesCollection fname_to_props;
-    ASSERT_OK(db_->GetPropertiesOfAllTables(handles_[cf], &fname_to_props));
-    ASSERT_EQ(1U, fname_to_props.size());
-
-    ASSERT_EQ(fname_to_props.begin()->second->db_host_id, expected_host_id);
-  }
-}
-
-INSTANTIATE_TEST_CASE_P(
-    DBTableHostnamePropertyTest, DBTableHostnamePropertyTest,
-    ::testing::Values(
-        // OptionConfig, override db_host_location
-        std::make_tuple(DBTestBase::OptionConfig::kDefault,
-                        kHostnameForDbHostId),
-        std::make_tuple(DBTestBase::OptionConfig::kDefault, "foobar"),
-        std::make_tuple(DBTestBase::OptionConfig::kDefault, ""),
-        std::make_tuple(DBTestBase::OptionConfig::kPlainTableFirstBytePrefix,
-                        kHostnameForDbHostId),
-        std::make_tuple(DBTestBase::OptionConfig::kPlainTableFirstBytePrefix,
-                        "foobar"),
-        std::make_tuple(DBTestBase::OptionConfig::kPlainTableFirstBytePrefix,
-                        "")));
-
 class DeletionTriggeredCompactionTestListener : public EventListener {
  public:
   void OnCompactionBegin(DB* , const CompactionJobInfo& ci) override {
@@ -421,54 +370,6 @@ TEST_P(DBTablePropertiesTest, DeletionTriggeredCompactionMarking) {
   ASSERT_LT(0, opts.statistics->getTickerCount(COMPACT_READ_BYTES_MARKED));
 }
 
-TEST_P(DBTablePropertiesTest, RatioBasedDeletionTriggeredCompactionMarking) {
-  constexpr int kNumKeys = 1000;
-  constexpr int kWindowSize = 0;
-  constexpr int kNumDelsTrigger = 0;
-  constexpr double kDeletionRatio = 0.1;
-  std::shared_ptr<TablePropertiesCollectorFactory> compact_on_del =
-      NewCompactOnDeletionCollectorFactory(kWindowSize, kNumDelsTrigger,
-                                           kDeletionRatio);
-
-  Options opts = CurrentOptions();
-  opts.statistics = ROCKSDB_NAMESPACE::CreateDBStatistics();
-  opts.table_properties_collector_factories.emplace_back(compact_on_del);
-
-  Reopen(opts);
-
-  // Add an L2 file to prevent tombstones from dropping due to obsolescence
-  // during flush
-  Put(Key(0), "val");
-  Flush();
-  MoveFilesToLevel(2);
-
-  auto* listener = new DeletionTriggeredCompactionTestListener();
-  opts.listeners.emplace_back(listener);
-  Reopen(opts);
-
-  // Generate one L0 with kNumKeys Put.
-  for (int i = 0; i < kNumKeys; ++i) {
-    ASSERT_OK(Put(Key(i), "not important"));
-  }
-  ASSERT_OK(Flush());
-
-  // Generate another L0 with kNumKeys Delete.
-  // This file, due to deletion ratio, will trigger compaction: 2@0 files to L1.
-  // The resulting L1 file has only one tombstone for user key 'Key(0)'.
-  // Again, due to deletion ratio, a compaction will be triggered: 1@1 + 1@2
-  // files to L2. However, the resulting file is empty because the tombstone
-  // and value are both dropped.
-  for (int i = 0; i < kNumKeys; ++i) {
-    ASSERT_OK(Delete(Key(i)));
-  }
-  ASSERT_OK(Flush());
-
-  ASSERT_OK(dbfull()->TEST_WaitForCompact());
-  for (int i = 0; i < 3; ++i) {
-    ASSERT_EQ(0, NumTableFilesAtLevel(i));
-  }
-}
-
 INSTANTIATE_TEST_CASE_P(
     DBTablePropertiesTest,
     DBTablePropertiesTest,

db/db_test.cc

@@ -55,7 +55,9 @@
 #include "rocksdb/utilities/checkpoint.h"
 #include "rocksdb/utilities/optimistic_transaction_db.h"
 #include "rocksdb/utilities/write_batch_with_index.h"
+#include "table/block_based/block_based_table_factory.h"
 #include "table/mock_table.h"
+#include "table/plain/plain_table_factory.h"
 #include "table/scoped_arena_iterator.h"
 #include "test_util/sync_point.h"
 #include "test_util/testharness.h"
@@ -2391,7 +2393,6 @@ TEST_F(DBTest, PurgeInfoLogs) {
   Options options = CurrentOptions();
   options.keep_log_file_num = 5;
   options.create_if_missing = true;
-  options.env = env_;
   for (int mode = 0; mode <= 1; mode++) {
     if (mode == 1) {
       options.db_log_dir = dbname_ + "_logs";
@@ -3841,7 +3842,7 @@ TEST_F(DBTest, TableOptionsSanitizeTest) {
   DestroyAndReopen(options);
   ASSERT_EQ(db_->GetOptions().allow_mmap_reads, false);
 
-  options.table_factory.reset(NewPlainTableFactory());
+  options.table_factory.reset(new PlainTableFactory());
   options.prefix_extractor.reset(NewNoopTransform());
   Destroy(options);
   ASSERT_TRUE(!TryReopen(options).IsNotSupported());
@@ -3948,7 +3949,6 @@ TEST_F(DBTest, WriteSingleThreadEntry) {
 TEST_F(DBTest, ConcurrentFlushWAL) {
   const size_t cnt = 100;
   Options options;
-  options.env = env_;
   WriteOptions wopt;
   ReadOptions ropt;
   for (bool two_write_queues : {false, true}) {
@@ -4617,7 +4617,6 @@ TEST_F(DBTest, DynamicLevelCompressionPerLevel) {
 
   Random rnd(301);
   Options options;
-  options.env = env_;
   options.create_if_missing = true;
   options.db_write_buffer_size = 20480;
   options.write_buffer_size = 20480;
@@ -5020,7 +5019,6 @@ TEST_F(DBTest, DynamicFIFOCompactionOptions) {
   Options options;
   options.ttl = 0;
   options.create_if_missing = true;
-  options.env = env_;
   DestroyAndReopen(options);
 
   // Initial defaults
@@ -5082,7 +5080,6 @@ TEST_F(DBTest, DynamicFIFOCompactionOptions) {
 TEST_F(DBTest, DynamicUniversalCompactionOptions) {
   Options options;
   options.create_if_missing = true;
-  options.env = env_;
   DestroyAndReopen(options);
 
   // Initial defaults
@@ -5161,13 +5158,12 @@ TEST_F(DBTest, FileCreationRandomFailure) {
   DestroyAndReopen(options);
   Random rnd(301);
 
-  constexpr int kCDTKeysPerBuffer = 4;
-  constexpr int kTestSize = kCDTKeysPerBuffer * 4096;
-  constexpr int kTotalIteration = 20;
+  const int kCDTKeysPerBuffer = 4;
+  const int kTestSize = kCDTKeysPerBuffer * 4096;
+  const int kTotalIteration = 100;
   // the second half of the test involves in random failure
   // of file creation.
-  constexpr int kRandomFailureTest = kTotalIteration / 2;
-
+  const int kRandomFailureTest = kTotalIteration / 2;
   std::vector<std::string> values;
   for (int i = 0; i < kTestSize; ++i) {
     values.push_back("NOT_FOUND");
@@ -5297,13 +5293,6 @@ TEST_F(DBTest, DynamicMiscOptions) {
   ASSERT_OK(dbfull()->TEST_GetLatestMutableCFOptions(handles_[1],
                                                      &mutable_cf_options));
   ASSERT_TRUE(mutable_cf_options.report_bg_io_stats);
-  ASSERT_TRUE(mutable_cf_options.check_flush_compaction_key_order);
-
-  ASSERT_OK(dbfull()->SetOptions(
-      handles_[1], {{"check_flush_compaction_key_order", "false"}}));
-  ASSERT_OK(dbfull()->TEST_GetLatestMutableCFOptions(handles_[1],
-                                                     &mutable_cf_options));
-  ASSERT_FALSE(mutable_cf_options.check_flush_compaction_key_order);
 }
 #endif  // ROCKSDB_LITE
 

db/db_test2.cc

@@ -12,7 +12,6 @@
 
 #include "db/db_test_util.h"
 #include "db/read_callback.h"
-#include "options/options_helper.h"
 #include "port/port.h"
 #include "port/stack_trace.h"
 #include "rocksdb/persistent_cache.h"
@@ -105,7 +104,6 @@ class TestReadOnlyWithCompressedCache
 
 TEST_P(TestReadOnlyWithCompressedCache, ReadOnlyWithCompressedCache) {
   if (use_mmap_ && !IsMemoryMappedAccessSupported()) {
-    ROCKSDB_GTEST_SKIP("Test requires MMAP support");
     return;
   }
   ASSERT_OK(Put("foo", "bar"));
@@ -293,7 +291,7 @@ TEST_F(DBTest2, CacheIndexAndFilterWithDBRestart) {
   BlockBasedTableOptions table_options;
   table_options.cache_index_and_filter_blocks = true;
   table_options.filter_policy.reset(NewBloomFilterPolicy(20));
-  options.table_factory.reset(NewBlockBasedTableFactory(table_options));
+  options.table_factory.reset(new BlockBasedTableFactory(table_options));
   CreateAndReopenWithCF({"pikachu"}, options);
 
   Put(1, "a", "begin");
@@ -1346,7 +1344,7 @@ TEST_F(DBTest2, PresetCompressionDictLocality) {
   options.target_file_size_base = kNumEntriesPerFile * kNumBytesPerEntry;
   BlockBasedTableOptions table_options;
   table_options.cache_index_and_filter_blocks = true;
-  options.table_factory.reset(NewBlockBasedTableFactory(table_options));
+  options.table_factory.reset(new BlockBasedTableFactory(table_options));
   Reopen(options);
 
   Random rnd(301);
@@ -1391,178 +1389,6 @@ TEST_F(DBTest2, PresetCompressionDictLocality) {
   }
 }
 
-class PresetCompressionDictTest
-    : public DBTestBase,
-      public testing::WithParamInterface<std::tuple<CompressionType, bool>> {
- public:
-  PresetCompressionDictTest()
-      : DBTestBase("/db_test2", false /* env_do_fsync */),
-        compression_type_(std::get<0>(GetParam())),
-        bottommost_(std::get<1>(GetParam())) {}
-
- protected:
-  const CompressionType compression_type_;
-  const bool bottommost_;
-};
-
-INSTANTIATE_TEST_CASE_P(
-    DBTest2, PresetCompressionDictTest,
-    ::testing::Combine(::testing::ValuesIn(GetSupportedDictCompressions()),
-                       ::testing::Bool()));
-
-TEST_P(PresetCompressionDictTest, Flush) {
-  // Verifies that dictionary is generated and written during flush only when
-  // `ColumnFamilyOptions::compression` enables dictionary.
-  const size_t kValueLen = 256;
-  const size_t kKeysPerFile = 1 << 10;
-  const size_t kDictLen = 4 << 10;
-
-  Options options = CurrentOptions();
-  if (bottommost_) {
-    options.bottommost_compression = compression_type_;
-    options.bottommost_compression_opts.enabled = true;
-    options.bottommost_compression_opts.max_dict_bytes = kDictLen;
-  } else {
-    options.compression = compression_type_;
-    options.compression_opts.max_dict_bytes = kDictLen;
-  }
-  options.memtable_factory.reset(new SpecialSkipListFactory(kKeysPerFile));
-  options.statistics = CreateDBStatistics();
-  BlockBasedTableOptions bbto;
-  bbto.cache_index_and_filter_blocks = true;
-  options.table_factory.reset(NewBlockBasedTableFactory(bbto));
-  Reopen(options);
-
-  uint64_t prev_compression_dict_misses =
-      TestGetTickerCount(options, BLOCK_CACHE_COMPRESSION_DICT_MISS);
-  Random rnd(301);
-  for (size_t i = 0; i <= kKeysPerFile; ++i) {
-    ASSERT_OK(Put(Key(static_cast<int>(i)), rnd.RandomString(kValueLen)));
-  }
-  ASSERT_OK(dbfull()->TEST_WaitForFlushMemTable());
-
-  // If there's a compression dictionary, it should have been loaded when the
-  // flush finished, incurring a cache miss.
-  uint64_t expected_compression_dict_misses;
-  if (bottommost_) {
-    expected_compression_dict_misses = prev_compression_dict_misses;
-  } else {
-    expected_compression_dict_misses = prev_compression_dict_misses + 1;
-  }
-  ASSERT_EQ(expected_compression_dict_misses,
-            TestGetTickerCount(options, BLOCK_CACHE_COMPRESSION_DICT_MISS));
-}
-
-TEST_P(PresetCompressionDictTest, CompactNonBottommost) {
-  // Verifies that dictionary is generated and written during compaction to
-  // non-bottommost level only when `ColumnFamilyOptions::compression` enables
-  // dictionary.
-  const size_t kValueLen = 256;
-  const size_t kKeysPerFile = 1 << 10;
-  const size_t kDictLen = 4 << 10;
-
-  Options options = CurrentOptions();
-  if (bottommost_) {
-    options.bottommost_compression = compression_type_;
-    options.bottommost_compression_opts.enabled = true;
-    options.bottommost_compression_opts.max_dict_bytes = kDictLen;
-  } else {
-    options.compression = compression_type_;
-    options.compression_opts.max_dict_bytes = kDictLen;
-  }
-  options.disable_auto_compactions = true;
-  options.statistics = CreateDBStatistics();
-  BlockBasedTableOptions bbto;
-  bbto.cache_index_and_filter_blocks = true;
-  options.table_factory.reset(NewBlockBasedTableFactory(bbto));
-  Reopen(options);
-
-  Random rnd(301);
-  for (size_t j = 0; j <= kKeysPerFile; ++j) {
-    ASSERT_OK(Put(Key(static_cast<int>(j)), rnd.RandomString(kValueLen)));
-  }
-  ASSERT_OK(Flush());
-  MoveFilesToLevel(2);
-
-  for (int i = 0; i < 2; ++i) {
-    for (size_t j = 0; j <= kKeysPerFile; ++j) {
-      ASSERT_OK(Put(Key(static_cast<int>(j)), rnd.RandomString(kValueLen)));
-    }
-    ASSERT_OK(Flush());
-  }
-#ifndef ROCKSDB_LITE
-  ASSERT_EQ("2,0,1", FilesPerLevel(0));
-#endif  // ROCKSDB_LITE
-
-  uint64_t prev_compression_dict_misses =
-      TestGetTickerCount(options, BLOCK_CACHE_COMPRESSION_DICT_MISS);
-  // This L0->L1 compaction merges the two L0 files into L1. The produced L1
-  // file is not bottommost due to the existing L2 file covering the same key-
-  // range.
-  ASSERT_OK(dbfull()->TEST_CompactRange(0, nullptr, nullptr));
-#ifndef ROCKSDB_LITE
-  ASSERT_EQ("0,1,1", FilesPerLevel(0));
-#endif  // ROCKSDB_LITE
-  // If there's a compression dictionary, it should have been loaded when the
-  // compaction finished, incurring a cache miss.
-  uint64_t expected_compression_dict_misses;
-  if (bottommost_) {
-    expected_compression_dict_misses = prev_compression_dict_misses;
-  } else {
-    expected_compression_dict_misses = prev_compression_dict_misses + 1;
-  }
-  ASSERT_EQ(expected_compression_dict_misses,
-            TestGetTickerCount(options, BLOCK_CACHE_COMPRESSION_DICT_MISS));
-}
-
-TEST_P(PresetCompressionDictTest, CompactBottommost) {
-  // Verifies that dictionary is generated and written during compaction to
-  // non-bottommost level only when either `ColumnFamilyOptions::compression` or
-  // `ColumnFamilyOptions::bottommost_compression` enables dictionary.
-  const size_t kValueLen = 256;
-  const size_t kKeysPerFile = 1 << 10;
-  const size_t kDictLen = 4 << 10;
-
-  Options options = CurrentOptions();
-  if (bottommost_) {
-    options.bottommost_compression = compression_type_;
-    options.bottommost_compression_opts.enabled = true;
-    options.bottommost_compression_opts.max_dict_bytes = kDictLen;
-  } else {
-    options.compression = compression_type_;
-    options.compression_opts.max_dict_bytes = kDictLen;
-  }
-  options.disable_auto_compactions = true;
-  options.statistics = CreateDBStatistics();
-  BlockBasedTableOptions bbto;
-  bbto.cache_index_and_filter_blocks = true;
-  options.table_factory.reset(NewBlockBasedTableFactory(bbto));
-  Reopen(options);
-
-  Random rnd(301);
-  for (int i = 0; i < 2; ++i) {
-    for (size_t j = 0; j <= kKeysPerFile; ++j) {
-      ASSERT_OK(Put(Key(static_cast<int>(j)), rnd.RandomString(kValueLen)));
-    }
-    ASSERT_OK(Flush());
-  }
-#ifndef ROCKSDB_LITE
-  ASSERT_EQ("2", FilesPerLevel(0));
-#endif  // ROCKSDB_LITE
-
-  uint64_t prev_compression_dict_misses =
-      TestGetTickerCount(options, BLOCK_CACHE_COMPRESSION_DICT_MISS);
-  CompactRangeOptions cro;
-  ASSERT_OK(db_->CompactRange(cro, nullptr, nullptr));
-#ifndef ROCKSDB_LITE
-  ASSERT_EQ("0,1", FilesPerLevel(0));
-#endif  // ROCKSDB_LITE
-  // If there's a compression dictionary, it should have been loaded when the
-  // compaction finished, incurring a cache miss.
-  ASSERT_EQ(prev_compression_dict_misses + 1,
-            TestGetTickerCount(options, BLOCK_CACHE_COMPRESSION_DICT_MISS));
-}
-
 class CompactionCompressionListener : public EventListener {
  public:
   explicit CompactionCompressionListener(Options* db_options)
@@ -1644,7 +1470,7 @@ TEST_P(CompressionFailuresTest, CompressionFailures) {
   BlockBasedTableOptions table_options;
   table_options.block_size = 512;
   table_options.verify_compression = true;
-  options.table_factory.reset(NewBlockBasedTableFactory(table_options));
+  options.table_factory.reset(new BlockBasedTableFactory(table_options));
 
   options.compression = compression_type_;
   options.compression_opts.parallel_threads = compression_parallel_threads_;
@@ -1982,7 +1808,7 @@ class PinL0IndexAndFilterBlocksTest
     table_options.cache_index_and_filter_blocks = true;
     table_options.pin_l0_filter_and_index_blocks_in_cache = true;
     table_options.filter_policy.reset(NewBloomFilterPolicy(20));
-    options->table_factory.reset(NewBlockBasedTableFactory(table_options));
+    options->table_factory.reset(new BlockBasedTableFactory(table_options));
     CreateAndReopenWithCF({"pikachu"}, *options);
 
     Put(1, "a", "begin");
@@ -2022,7 +1848,7 @@ TEST_P(PinL0IndexAndFilterBlocksTest,
   table_options.cache_index_and_filter_blocks = true;
   table_options.pin_l0_filter_and_index_blocks_in_cache = true;
   table_options.filter_policy.reset(NewBloomFilterPolicy(20));
-  options.table_factory.reset(NewBlockBasedTableFactory(table_options));
+  options.table_factory.reset(new BlockBasedTableFactory(table_options));
   CreateAndReopenWithCF({"pikachu"}, options);
 
   ASSERT_OK(Put(1, "key", "val"));
@@ -2659,30 +2485,26 @@ TEST_F(DBTest2, ReadAmpBitmapLiveInCacheAfterDBClose) {
   {
     const int kIdBufLen = 100;
     char id_buf[kIdBufLen];
-    Status s = Status::NotSupported();
 #ifndef OS_WIN
     // You can't open a directory on windows using random access file
     std::unique_ptr<RandomAccessFile> file;
-    s = env_->NewRandomAccessFile(dbname_, &file, EnvOptions());
-    if (s.ok()) {
-      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;
-      }
+    ASSERT_OK(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
-    if (!s.ok()) {
-      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;
-      }
-    }
   }
   uint32_t bytes_per_bit[2] = {1, 16};
   for (size_t k = 0; k < 2; k++) {
@@ -3145,11 +2967,11 @@ TEST_F(DBTest2, OptimizeForSmallDB) {
   options.OptimizeForSmallDb();
 
   // Find the cache object
-  ASSERT_TRUE(options.table_factory->IsInstanceOf(
-      TableFactory::kBlockBasedTableName()));
-  auto table_options =
-      options.table_factory->GetOptions<BlockBasedTableOptions>();
-
+  ASSERT_EQ(std::string(BlockBasedTableFactory::kName),
+            std::string(options.table_factory->Name()));
+  BlockBasedTableOptions* table_options =
+      reinterpret_cast<BlockBasedTableOptions*>(
+          options.table_factory->GetOptions());
   ASSERT_TRUE(table_options != nullptr);
   std::shared_ptr<Cache> cache = table_options->block_cache;
 
@@ -3475,7 +3297,7 @@ TEST_F(DBTest2, RateLimitedCompactionReads) {
     BlockBasedTableOptions bbto;
     bbto.block_size = 16384;
     bbto.no_block_cache = true;
-    options.table_factory.reset(NewBlockBasedTableFactory(bbto));
+    options.table_factory.reset(new BlockBasedTableFactory(bbto));
     DestroyAndReopen(options);
 
     for (int i = 0; i < kNumL0Files; ++i) {
@@ -3520,7 +3342,6 @@ TEST_F(DBTest2, RateLimitedCompactionReads) {
 // is on levels higher than the new num_levels.
 TEST_F(DBTest2, ReduceLevel) {
   Options options;
-  options.env = env_;
   options.disable_auto_compactions = true;
   options.num_levels = 7;
   Reopen(options);
@@ -3549,7 +3370,6 @@ TEST_F(DBTest2, ReadCallbackTest) {
   Options options;
   options.disable_auto_compactions = true;
   options.num_levels = 7;
-  options.env = env_;
   Reopen(options);
   std::vector<const Snapshot*> snapshots;
   // Try to create a db with multiple layers and a memtable
@@ -3809,9 +3629,7 @@ TEST_F(DBTest2, TraceAndReplay) {
   column_families.push_back(
       ColumnFamilyDescriptor("pikachu", ColumnFamilyOptions()));
   std::vector<ColumnFamilyHandle*> handles;
-  DBOptions db_opts;
-  db_opts.env = env_;
-  ASSERT_OK(DB::Open(db_opts, dbname2, column_families, &handles, &db2));
+  ASSERT_OK(DB::Open(DBOptions(), dbname2, column_families, &handles, &db2));
 
   env_->SleepForMicroseconds(100);
   // Verify that the keys don't already exist
@@ -3886,9 +3704,7 @@ TEST_F(DBTest2, TraceWithLimit) {
   column_families.push_back(
       ColumnFamilyDescriptor("pikachu", ColumnFamilyOptions()));
   std::vector<ColumnFamilyHandle*> handles;
-  DBOptions db_opts;
-  db_opts.env = env_;
-  ASSERT_OK(DB::Open(db_opts, dbname2, column_families, &handles, &db2));
+  ASSERT_OK(DB::Open(DBOptions(), dbname2, column_families, &handles, &db2));
 
   env_->SleepForMicroseconds(100);
   // Verify that the keys don't already exist
@@ -3956,9 +3772,7 @@ TEST_F(DBTest2, TraceWithSampling) {
   column_families.push_back(
       ColumnFamilyDescriptor("pikachu", ColumnFamilyOptions()));
   std::vector<ColumnFamilyHandle*> handles;
-  DBOptions db_opts;
-  db_opts.env = env_;
-  ASSERT_OK(DB::Open(db_opts, dbname2, column_families, &handles, &db2));
+  ASSERT_OK(DB::Open(DBOptions(), dbname2, column_families, &handles, &db2));
 
   env_->SleepForMicroseconds(100);
   ASSERT_TRUE(db2->Get(ro, handles[0], "a", &value).IsNotFound());
@@ -4058,9 +3872,7 @@ TEST_F(DBTest2, TraceWithFilter) {
   column_families.push_back(
       ColumnFamilyDescriptor("pikachu", ColumnFamilyOptions()));
   std::vector<ColumnFamilyHandle*> handles;
-  DBOptions db_opts;
-  db_opts.env = env_;
-  ASSERT_OK(DB::Open(db_opts, dbname2, column_families, &handles, &db2));
+  ASSERT_OK(DB::Open(DBOptions(), dbname2, column_families, &handles, &db2));
 
   env_->SleepForMicroseconds(100);
   // Verify that the keys don't already exist
@@ -4106,7 +3918,7 @@ TEST_F(DBTest2, TraceWithFilter) {
   handles.clear();
 
   DB* db3 =  nullptr;
-  ASSERT_OK(DB::Open(db_opts, dbname3, column_families, &handles, &db3));
+  ASSERT_OK(DB::Open(DBOptions(), dbname3, column_families, &handles, &db3));
 
   env_->SleepForMicroseconds(100);
   // Verify that the keys don't already exist
@@ -4162,11 +3974,6 @@ TEST_F(DBTest2, TraceWithFilter) {
 
 TEST_F(DBTest2, PinnableSliceAndMmapReads) {
   Options options = CurrentOptions();
-  options.env = env_;
-  if (!IsMemoryMappedAccessSupported()) {
-    ROCKSDB_GTEST_SKIP("Test requires default environment");
-    return;
-  }
   options.allow_mmap_reads = true;
   options.max_open_files = 100;
   options.compression = kNoCompression;
@@ -4219,7 +4026,7 @@ TEST_F(DBTest2, DISABLED_IteratorPinnedMemory) {
   bbto.cache_index_and_filter_blocks = false;
   bbto.block_cache = NewLRUCache(100000);
   bbto.block_size = 400;  // small block size
-  options.table_factory.reset(NewBlockBasedTableFactory(bbto));
+  options.table_factory.reset(new BlockBasedTableFactory(bbto));
   Reopen(options);
 
   Random rnd(301);
@@ -4445,7 +4252,6 @@ TEST_F(DBTest2, TestCompactFiles) {
   SyncPoint::GetInstance()->EnableProcessing();
 
   Options options;
-  options.env = env_;
   options.num_levels = 2;
   options.disable_auto_compactions = true;
   Reopen(options);
@@ -4570,8 +4376,8 @@ class DummyOldStats : public Statistics {
   }
   bool HistEnabledForType(uint32_t /*type*/) const override { return false; }
   std::string ToString() const override { return ""; }
-  std::atomic<int> num_rt{0};
-  std::atomic<int> num_mt{0};
+  int num_rt = 0;
+  int num_mt = 0;
 };
 }  // namespace
 
@@ -4763,7 +4569,7 @@ TEST_F(DBTest2, CrashInRecoveryMultipleCF) {
     for (const auto& f : filenames) {
       uint64_t number;
       FileType type;
-      if (ParseFileName(f, &number, &type) && type == FileType::kWalFile) {
+      if (ParseFileName(f, &number, &type) && type == FileType::kLogFile) {
         std::string fname = dbname_ + "/" + f;
         std::string file_content;
         ASSERT_OK(ReadFileToString(env_, fname, &file_content));
@@ -5001,7 +4807,6 @@ TEST_F(DBTest2, BlockBasedTablePrefixIndexSeekForPrev) {
 
 TEST_F(DBTest2, PartitionedIndexPrefetchFailure) {
   Options options = last_options_;
-  options.env = env_;
   options.max_open_files = 20;
   BlockBasedTableOptions bbto;
   bbto.index_type = BlockBasedTableOptions::IndexType::kTwoLevelIndexSearch;

db/db_test_util.cc

@@ -10,7 +10,6 @@
 #include "db/db_test_util.h"
 
 #include "db/forward_iterator.h"
-#include "rocksdb/convenience.h"
 #include "rocksdb/env_encryption.h"
 #include "rocksdb/utilities/object_registry.h"
 #include "util/random.h"
@@ -54,6 +53,10 @@ SpecialEnv::SpecialEnv(Env* base, bool time_elapse_only_sleep)
   non_writable_count_ = 0;
   table_write_callback_ = nullptr;
 }
+#ifndef ROCKSDB_LITE
+ROT13BlockCipher rot13Cipher_(16);
+#endif  // ROCKSDB_LITE
+
 DBTestBase::DBTestBase(const std::string path, bool env_do_fsync)
     : mem_env_(nullptr), encrypted_env_(nullptr), option_config_(kDefault) {
   Env* base_env = Env::Default();
@@ -73,11 +76,8 @@ DBTestBase::DBTestBase(const std::string path, bool env_do_fsync)
   }
 #ifndef ROCKSDB_LITE
   if (getenv("ENCRYPTED_ENV")) {
-    std::shared_ptr<EncryptionProvider> provider;
-    Status s = EncryptionProvider::CreateFromString(
-        ConfigOptions(), std::string("test://") + getenv("ENCRYPTED_ENV"),
-        &provider);
-    encrypted_env_ = NewEncryptedEnv(mem_env_ ? mem_env_ : base_env, provider);
+    encrypted_env_ = NewEncryptedEnv(mem_env_ ? mem_env_ : base_env,
+                                     new CTREncryptionProvider(rot13Cipher_));
   }
 #endif  // !ROCKSDB_LITE
   env_ = new SpecialEnv(encrypted_env_ ? encrypted_env_
@@ -331,7 +331,7 @@ Options DBTestBase::CurrentOptions(
   return GetOptions(option_config_, default_options, options_override);
 }
 
-Options DBTestBase::GetDefaultOptions() const {
+Options DBTestBase::GetDefaultOptions() {
   Options options;
   options.write_buffer_size = 4090 * 4096;
   options.target_file_size_base = 2 * 1024 * 1024;
@@ -339,10 +339,6 @@ Options DBTestBase::GetDefaultOptions() const {
   options.max_open_files = 5000;
   options.wal_recovery_mode = WALRecoveryMode::kTolerateCorruptedTailRecords;
   options.compaction_pri = CompactionPri::kByCompensatedSize;
-  options.env = env_;
-  if (!env_->skip_fsync_) {
-    options.track_and_verify_wals_in_manifest = true;
-  }
   return options;
 }
 
@@ -371,28 +367,28 @@ Options DBTestBase::GetOptions(
       options.unordered_write = false;
       break;
     case kPlainTableFirstBytePrefix:
-      options.table_factory.reset(NewPlainTableFactory());
+      options.table_factory.reset(new PlainTableFactory());
       options.prefix_extractor.reset(NewFixedPrefixTransform(1));
       options.allow_mmap_reads = can_allow_mmap;
       options.max_sequential_skip_in_iterations = 999999;
       set_block_based_table_factory = false;
       break;
     case kPlainTableCappedPrefix:
-      options.table_factory.reset(NewPlainTableFactory());
+      options.table_factory.reset(new PlainTableFactory());
       options.prefix_extractor.reset(NewCappedPrefixTransform(8));
       options.allow_mmap_reads = can_allow_mmap;
       options.max_sequential_skip_in_iterations = 999999;
       set_block_based_table_factory = false;
       break;
     case kPlainTableCappedPrefixNonMmap:
-      options.table_factory.reset(NewPlainTableFactory());
+      options.table_factory.reset(new PlainTableFactory());
       options.prefix_extractor.reset(NewCappedPrefixTransform(8));
       options.allow_mmap_reads = false;
       options.max_sequential_skip_in_iterations = 999999;
       set_block_based_table_factory = false;
       break;
     case kPlainTableAllBytesPrefix:
-      options.table_factory.reset(NewPlainTableFactory());
+      options.table_factory.reset(new PlainTableFactory());
       options.prefix_extractor.reset(NewNoopTransform());
       options.allow_mmap_reads = can_allow_mmap;
       options.max_sequential_skip_in_iterations = 999999;
@@ -670,7 +666,7 @@ void DBTestBase::Reopen(const Options& options) {
 
 void DBTestBase::Close() {
   for (auto h : handles_) {
-    EXPECT_OK(db_->DestroyColumnFamilyHandle(h));
+    db_->DestroyColumnFamilyHandle(h);
   }
   handles_.clear();
   delete db_;
@@ -688,8 +684,7 @@ void DBTestBase::Destroy(const Options& options, bool delete_cf_paths) {
   if (delete_cf_paths) {
     for (size_t i = 0; i < handles_.size(); ++i) {
       ColumnFamilyDescriptor cfdescriptor;
-      // GetDescriptor is not implemented for ROCKSDB_LITE
-      handles_[i]->GetDescriptor(&cfdescriptor).PermitUncheckedError();
+      handles_[i]->GetDescriptor(&cfdescriptor);
       column_families.push_back(cfdescriptor);
     }
   }
@@ -708,9 +703,9 @@ Status DBTestBase::TryReopen(const Options& options) {
   // Note: operator= is an unsafe approach here since it destructs
   // std::shared_ptr in the same order of their creation, in contrast to
   // destructors which destructs them in the opposite order of creation. One
-  // particular problem is that the cache destructor might invoke callback
+  // particular problme is that the cache destructor might invoke callback
   // functions that use Option members such as statistics. To work around this
-  // problem, we manually call destructor of table_factory which eventually
+  // problem, we manually call destructor of table_facotry which eventually
   // clears the block cache.
   last_options_ = options;
   MaybeInstallTimeElapseOnlySleep(options);
@@ -967,8 +962,7 @@ std::string DBTestBase::AllEntriesFor(const Slice& user_key, int cf) {
     bool first = true;
     while (iter->Valid()) {
       ParsedInternalKey ikey(Slice(), 0, kTypeValue);
-      if (ParseInternalKey(iter->key(), &ikey, true /* log_err_key */) !=
-          Status::OK()) {
+      if (!ParseInternalKey(iter->key(), &ikey)) {
         result += "CORRUPTED";
       } else {
         if (!last_options_.comparator->Equal(ikey.user_key, user_key)) {
@@ -1188,9 +1182,9 @@ void DBTestBase::FillLevels(const std::string& smallest,
 void DBTestBase::MoveFilesToLevel(int level, int cf) {
   for (int l = 0; l < level; ++l) {
     if (cf > 0) {
-      EXPECT_OK(dbfull()->TEST_CompactRange(l, nullptr, nullptr, handles_[cf]));
+      dbfull()->TEST_CompactRange(l, nullptr, nullptr, handles_[cf]);
     } else {
-      EXPECT_OK(dbfull()->TEST_CompactRange(l, nullptr, nullptr));
+      dbfull()->TEST_CompactRange(l, nullptr, nullptr);
     }
   }
 }
@@ -1217,7 +1211,7 @@ std::string DBTestBase::DumpSSTableList() {
 
 void DBTestBase::GetSstFiles(Env* env, std::string path,
                              std::vector<std::string>* files) {
-  EXPECT_OK(env->GetChildren(path, files));
+  env->GetChildren(path, files);
 
   files->erase(
       std::remove_if(files->begin(), files->end(), [](std::string name) {
@@ -1241,8 +1235,8 @@ void DBTestBase::GenerateNewFile(int cf, Random* rnd, int* key_idx,
     (*key_idx)++;
   }
   if (!nowait) {
-    ASSERT_OK(dbfull()->TEST_WaitForFlushMemTable());
-    ASSERT_OK(dbfull()->TEST_WaitForCompact());
+    dbfull()->TEST_WaitForFlushMemTable();
+    dbfull()->TEST_WaitForCompact();
   }
 }
 
@@ -1253,8 +1247,8 @@ void DBTestBase::GenerateNewFile(Random* rnd, int* key_idx, bool nowait) {
     (*key_idx)++;
   }
   if (!nowait) {
-    ASSERT_OK(dbfull()->TEST_WaitForFlushMemTable());
-    ASSERT_OK(dbfull()->TEST_WaitForCompact());
+    dbfull()->TEST_WaitForFlushMemTable();
+    dbfull()->TEST_WaitForCompact();
   }
 }
 
@@ -1375,12 +1369,12 @@ void DBTestBase::validateNumberOfEntries(int numValues, int cf) {
                                            kMaxSequenceNumber));
   }
   iter->SeekToFirst();
-  ASSERT_OK(iter->status());
+  ASSERT_EQ(iter->status().ok(), true);
   int seq = numValues;
   while (iter->Valid()) {
     ParsedInternalKey ikey;
     ikey.clear();
-    ASSERT_OK(ParseInternalKey(iter->key(), &ikey, true /* log_err_key */));
+    ASSERT_EQ(ParseInternalKey(iter->key(), &ikey), true);
 
     // checks sequence number for updates
     ASSERT_EQ(ikey.sequence, (unsigned)seq--);
@@ -1413,40 +1407,36 @@ void DBTestBase::CopyFile(const std::string& source,
   ASSERT_OK(destfile->Close());
 }
 
-Status DBTestBase::GetAllSSTFiles(
-    std::unordered_map<std::string, uint64_t>* sst_files,
-    uint64_t* total_size /* = nullptr */) {
+std::unordered_map<std::string, uint64_t> DBTestBase::GetAllSSTFiles(
+    uint64_t* total_size) {
+  std::unordered_map<std::string, uint64_t> res;
+
   if (total_size) {
     *total_size = 0;
   }
   std::vector<std::string> files;
-  Status s = env_->GetChildren(dbname_, &files);
-  if (s.ok()) {
-    for (auto& file_name : files) {
-      uint64_t number;
-      FileType type;
-      if (ParseFileName(file_name, &number, &type) && type == kTableFile) {
-        std::string file_path = dbname_ + "/" + file_name;
-        uint64_t file_size = 0;
-        s = env_->GetFileSize(file_path, &file_size);
-        if (!s.ok()) {
-          break;
-        }
-        (*sst_files)[file_path] = file_size;
-        if (total_size) {
-          *total_size += file_size;
-        }
+  env_->GetChildren(dbname_, &files);
+  for (auto& file_name : files) {
+    uint64_t number;
+    FileType type;
+    std::string file_path = dbname_ + "/" + file_name;
+    if (ParseFileName(file_name, &number, &type) && type == kTableFile) {
+      uint64_t file_size = 0;
+      env_->GetFileSize(file_path, &file_size);
+      res[file_path] = file_size;
+      if (total_size) {
+        *total_size += file_size;
       }
     }
   }
-  return s;
+  return res;
 }
 
 std::vector<std::uint64_t> DBTestBase::ListTableFiles(Env* env,
                                                       const std::string& path) {
   std::vector<std::string> files;
   std::vector<uint64_t> file_numbers;
-  EXPECT_OK(env->GetChildren(path, &files));
+  env->GetChildren(path, &files);
   uint64_t number;
   FileType type;
   for (size_t i = 0; i < files.size(); ++i) {
@@ -1585,7 +1575,7 @@ void DBTestBase::VerifyDBInternal(
   for (auto p : true_data) {
     ASSERT_TRUE(iter->Valid());
     ParsedInternalKey ikey;
-    ASSERT_OK(ParseInternalKey(iter->key(), &ikey, true /* log_err_key */));
+    ASSERT_TRUE(ParseInternalKey(iter->key(), &ikey));
     ASSERT_EQ(p.first, ikey.user_key);
     ASSERT_EQ(p.second, iter->value());
     iter->Next();

db/db_test_util.h

@@ -38,7 +38,9 @@
 #include "rocksdb/statistics.h"
 #include "rocksdb/table.h"
 #include "rocksdb/utilities/checkpoint.h"
+#include "table/block_based/block_based_table_factory.h"
 #include "table/mock_table.h"
+#include "table/plain/plain_table_factory.h"
 #include "table/scoped_arena_iterator.h"
 #include "test_util/mock_time_env.h"
 #include "test_util/sync_point.h"
@@ -949,13 +951,10 @@ class DBTestBase : public testing::Test {
                          const anon::OptionsOverride& options_override =
                              anon::OptionsOverride()) const;
 
-  Options GetDefaultOptions() const;
+  static Options GetDefaultOptions();
 
-  Options GetOptions(int option_config) const {
-    return GetOptions(option_config, GetDefaultOptions());
-  }
-
-  Options GetOptions(int option_config, const Options& default_options,
+  Options GetOptions(int option_config,
+                     const Options& default_options = GetDefaultOptions(),
                      const anon::OptionsOverride& options_override =
                          anon::OptionsOverride()) const;
 
@@ -1148,8 +1147,8 @@ class DBTestBase : public testing::Test {
   void CopyFile(const std::string& source, const std::string& destination,
                 uint64_t size = 0);
 
-  Status GetAllSSTFiles(std::unordered_map<std::string, uint64_t>* sst_files,
-                        uint64_t* total_size = nullptr);
+  std::unordered_map<std::string, uint64_t> GetAllSSTFiles(
+      uint64_t* total_size = nullptr);
 
   std::vector<std::uint64_t> ListTableFiles(Env* env, const std::string& path);
 

db/db_universal_compaction_test.cc

@@ -27,7 +27,7 @@ class DBTestUniversalCompactionBase
       public ::testing::WithParamInterface<std::tuple<int, bool>> {
  public:
   explicit DBTestUniversalCompactionBase(const std::string& path)
-      : DBTestBase(path, /*env_do_fsync=*/false) {}
+      : DBTestBase(path, /*env_do_fsync=*/true) {}
   void SetUp() override {
     num_levels_ = std::get<0>(GetParam());
     exclusive_manual_compaction_ = std::get<1>(GetParam());
@@ -45,7 +45,7 @@ class DBTestUniversalCompaction : public DBTestUniversalCompactionBase {
 class DBTestUniversalCompaction2 : public DBTestBase {
  public:
   DBTestUniversalCompaction2()
-      : DBTestBase("/db_universal_compaction_test2", /*env_do_fsync=*/false) {}
+      : DBTestBase("/db_universal_compaction_test2", /*env_do_fsync=*/true) {}
 };
 
 namespace {
@@ -126,11 +126,11 @@ TEST_P(DBTestUniversalCompaction, UniversalCompactionSingleSortedRun) {
   for (int num = 0; num < 16; num++) {
     // Write 100KB file. And immediately it should be compacted to one file.
     GenerateNewFile(&rnd, &key_idx);
-    ASSERT_OK(dbfull()->TEST_WaitForCompact());
+    dbfull()->TEST_WaitForCompact();
     ASSERT_EQ(NumSortedRuns(0), 1);
   }
   ASSERT_OK(Put(Key(key_idx), ""));
-  ASSERT_OK(dbfull()->TEST_WaitForCompact());
+  dbfull()->TEST_WaitForCompact();
   ASSERT_EQ(NumSortedRuns(0), 1);
 }
 
@@ -162,15 +162,15 @@ TEST_P(DBTestUniversalCompaction, OptimizeFiltersForHits) {
                  Env::Priority::LOW);
 
   for (int num = 0; num < options.level0_file_num_compaction_trigger; num++) {
-    ASSERT_OK(Put(Key(num * 10), "val"));
+    Put(Key(num * 10), "val");
     if (num) {
-      ASSERT_OK(dbfull()->TEST_WaitForFlushMemTable());
+      dbfull()->TEST_WaitForFlushMemTable();
     }
-    ASSERT_OK(Put(Key(30 + num * 10), "val"));
-    ASSERT_OK(Put(Key(60 + num * 10), "val"));
+    Put(Key(30 + num * 10), "val");
+    Put(Key(60 + num * 10), "val");
   }
-  ASSERT_OK(Put("", ""));
-  ASSERT_OK(dbfull()->TEST_WaitForFlushMemTable());
+  Put("", "");
+  dbfull()->TEST_WaitForFlushMemTable();
 
   // Query set of non existing keys
   for (int i = 5; i < 90; i += 10) {
@@ -190,7 +190,7 @@ TEST_P(DBTestUniversalCompaction, OptimizeFiltersForHits) {
 
   // Unblock compaction and wait it for happening.
   sleeping_task_low.WakeUp();
-  ASSERT_OK(dbfull()->TEST_WaitForCompact());
+  dbfull()->TEST_WaitForCompact();
 
   // The same queries will not trigger bloom filter
   for (int i = 5; i < 90; i += 10) {
@@ -294,7 +294,7 @@ TEST_P(DBTestUniversalCompaction, UniversalCompactionTrigger) {
   //   Now we have 3 files at level 0, with size 4, 2.4, 2. Let's generate a
   //   new file of size 1.
   GenerateNewFile(1, &rnd, &key_idx);
-  ASSERT_OK(dbfull()->TEST_WaitForCompact());
+  dbfull()->TEST_WaitForCompact();
   // Level-0 compaction is triggered, but no file will be picked up.
   ASSERT_EQ(NumSortedRuns(1), 4);
 
@@ -303,7 +303,7 @@ TEST_P(DBTestUniversalCompaction, UniversalCompactionTrigger) {
   //   a new file of size 1.
   filter->expect_full_compaction_.store(true);
   GenerateNewFile(1, &rnd, &key_idx);
-  ASSERT_OK(dbfull()->TEST_WaitForCompact());
+  dbfull()->TEST_WaitForCompact();
   // All files at level 0 will be compacted into a single one.
   ASSERT_EQ(NumSortedRuns(1), 1);
 
@@ -336,7 +336,7 @@ TEST_P(DBTestUniversalCompaction, UniversalCompactionSizeAmplification) {
       ASSERT_OK(Put(1, Key(key_idx), rnd.RandomString(10000)));
       key_idx++;
     }
-    ASSERT_OK(dbfull()->TEST_WaitForFlushMemTable(handles_[1]));
+    dbfull()->TEST_WaitForFlushMemTable(handles_[1]);
     ASSERT_EQ(NumSortedRuns(1), num + 1);
   }
   ASSERT_EQ(NumSortedRuns(1), 2);
@@ -346,7 +346,7 @@ TEST_P(DBTestUniversalCompaction, UniversalCompactionSizeAmplification) {
   // but will instead trigger size amplification.
   ASSERT_OK(Flush(1));
 
-  ASSERT_OK(dbfull()->TEST_WaitForCompact());
+  dbfull()->TEST_WaitForCompact();
 
   // Verify that size amplification did occur
   ASSERT_EQ(NumSortedRuns(1), 1);
@@ -394,7 +394,7 @@ TEST_P(DBTestUniversalCompaction, DynamicUniversalCompactionSizeAmplification) {
       ASSERT_OK(Put(1, Key(key_idx), rnd.RandomString(10000)));
       key_idx++;
     }
-    ASSERT_OK(dbfull()->TEST_WaitForFlushMemTable(handles_[1]));
+    dbfull()->TEST_WaitForFlushMemTable(handles_[1]);
     ASSERT_EQ(NumSortedRuns(1), num + 1);
   }
   ASSERT_EQ(NumSortedRuns(1), 2);
@@ -404,7 +404,7 @@ TEST_P(DBTestUniversalCompaction, DynamicUniversalCompactionSizeAmplification) {
   // but could instead trigger size amplification if it's set
   // to 110.
   ASSERT_OK(Flush(1));
-  ASSERT_OK(dbfull()->TEST_WaitForCompact());
+  dbfull()->TEST_WaitForCompact();
   // Verify compaction did not happen
   ASSERT_EQ(NumSortedRuns(1), 3);
 
@@ -425,7 +425,7 @@ TEST_P(DBTestUniversalCompaction, DynamicUniversalCompactionSizeAmplification) {
   ASSERT_EQ(110u, mutable_cf_options.compaction_options_universal
                       .max_size_amplification_percent);
 
-  ASSERT_OK(dbfull()->TEST_WaitForCompact());
+  dbfull()->TEST_WaitForCompact();
   // Verify that size amplification did happen
   ASSERT_EQ(NumSortedRuns(1), 1);
   ASSERT_EQ(total_picked_compactions, 1);
@@ -473,7 +473,7 @@ TEST_P(DBTestUniversalCompaction, DynamicUniversalCompactionReadAmplification) {
       ASSERT_OK(Put(1, Key(key_idx), rnd.RandomString(10000)));
       key_idx++;
     }
-    ASSERT_OK(dbfull()->TEST_WaitForFlushMemTable(handles_[1]));
+    dbfull()->TEST_WaitForFlushMemTable(handles_[1]);
     ASSERT_EQ(NumSortedRuns(1), num + 1);
   }
   ASSERT_EQ(NumSortedRuns(1), options.level0_file_num_compaction_trigger);
@@ -481,7 +481,7 @@ TEST_P(DBTestUniversalCompaction, DynamicUniversalCompactionReadAmplification) {
   // Flush whatever is remaining in memtable. This is typically small, about
   // 30KB.
   ASSERT_OK(Flush(1));
-  ASSERT_OK(dbfull()->TEST_WaitForCompact());
+  dbfull()->TEST_WaitForCompact();
   // Verify compaction did not happen
   ASSERT_EQ(NumSortedRuns(1), options.level0_file_num_compaction_trigger + 1);
   ASSERT_EQ(total_picked_compactions, 0);
@@ -510,7 +510,7 @@ TEST_P(DBTestUniversalCompaction, DynamicUniversalCompactionReadAmplification) {
   ASSERT_EQ(mutable_cf_options.compaction_options_universal.max_merge_width,
             2u);
 
-  ASSERT_OK(dbfull()->TEST_WaitForCompact());
+  dbfull()->TEST_WaitForCompact();
 
   // Files in L0 are approx: 0.3 (30KB), 1, 1, 1.
   // On compaction: the files are below the size amp threshold, so we
@@ -550,8 +550,8 @@ TEST_P(DBTestUniversalCompaction, CompactFilesOnUniversalCompaction) {
   for (int key = 1024 * kEntriesPerBuffer; key >= 0; --key) {
     ASSERT_OK(Put(1, ToString(key), rnd.RandomString(kTestValueSize)));
   }
-  ASSERT_OK(dbfull()->TEST_WaitForFlushMemTable(handles_[1]));
-  ASSERT_OK(dbfull()->TEST_WaitForCompact());
+  dbfull()->TEST_WaitForFlushMemTable(handles_[1]);
+  dbfull()->TEST_WaitForCompact();
   ColumnFamilyMetaData cf_meta;
   dbfull()->GetColumnFamilyMetaData(handles_[1], &cf_meta);
   std::vector<std::string> compaction_input_file_names;
@@ -631,7 +631,7 @@ TEST_P(DBTestUniversalCompaction, UniversalCompactionTargetLevel) {
   compact_options.change_level = true;
   compact_options.target_level = 4;
   compact_options.exclusive_manual_compaction = exclusive_manual_compaction_;
-  ASSERT_OK(db_->CompactRange(compact_options, nullptr, nullptr));
+  db_->CompactRange(compact_options, nullptr, nullptr);
   ASSERT_EQ("0,0,0,0,1", FilesPerLevel(0));
 }
 
@@ -665,7 +665,7 @@ TEST_P(DBTestUniversalCompactionMultiLevels, UniversalCompactionMultiLevels) {
     ASSERT_OK(Put(1, Key(i % num_keys), Key(i)));
   }
 
-  ASSERT_OK(dbfull()->TEST_WaitForCompact());
+  dbfull()->TEST_WaitForCompact();
 
   for (int i = num_keys; i < num_keys * 2; i++) {
     ASSERT_EQ(Get(1, Key(i % num_keys)), Key(i));
@@ -712,7 +712,7 @@ TEST_P(DBTestUniversalCompactionMultiLevels, UniversalCompactionTrivialMove) {
   std::vector<std::string> values;
 
   ASSERT_OK(Flush(1));
-  ASSERT_OK(dbfull()->TEST_WaitForCompact());
+  dbfull()->TEST_WaitForCompact();
 
   ASSERT_GT(trivial_move, 0);
   ASSERT_GT(non_trivial_move, 0);
@@ -775,7 +775,7 @@ TEST_P(DBTestUniversalCompactionParallel, UniversalCompactionParallel) {
   for (int i = 0; i < num_keys * 2; i++) {
     ASSERT_OK(Put(1, Key(i % num_keys), Key(i)));
   }
-  ASSERT_OK(dbfull()->TEST_WaitForCompact());
+  dbfull()->TEST_WaitForCompact();
 
   ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->DisableProcessing();
   ASSERT_EQ(num_compactions_running.load(), 0);
@@ -853,7 +853,7 @@ TEST_P(DBTestUniversalCompactionParallel, PickByFileNumberBug) {
 
   // Hold the 1st compaction from finishing
   TEST_SYNC_POINT("DBTestUniversalCompactionParallel::PickByFileNumberBug:2");
-  ASSERT_OK(dbfull()->TEST_WaitForCompact());
+  dbfull()->TEST_WaitForCompact();
 
   // There should only be one picked compaction as the score drops below one
   // after the first one is picked.
@@ -901,7 +901,7 @@ TEST_P(DBTestUniversalCompactionParallel, PickByFileNumberBug) {
 
   // Hold the 1st and 2nd compaction from finishing
   TEST_SYNC_POINT("DBTestUniversalCompactionParallel::PickByFileNumberBug:2");
-  ASSERT_OK(dbfull()->TEST_WaitForCompact());
+  dbfull()->TEST_WaitForCompact();
 
   // This time we will trigger a compaction because of size ratio and
   // another compaction because of number of files that are not compacted
@@ -935,14 +935,14 @@ TEST_P(DBTestUniversalCompaction, UniversalCompactionOptions) {
       ASSERT_OK(Put(1, Key(key_idx), rnd.RandomString(990)));
       key_idx++;
     }
-    ASSERT_OK(dbfull()->TEST_WaitForFlushMemTable(handles_[1]));
+    dbfull()->TEST_WaitForFlushMemTable(handles_[1]);
 
     if (num < options.level0_file_num_compaction_trigger - 1) {
       ASSERT_EQ(NumSortedRuns(1), num + 1);
     }
   }
 
-  ASSERT_OK(dbfull()->TEST_WaitForCompact());
+  dbfull()->TEST_WaitForCompact();
   ASSERT_EQ(NumSortedRuns(1), 1);
 }
 
@@ -973,7 +973,7 @@ TEST_P(DBTestUniversalCompaction, UniversalCompactionStopStyleSimilarSize) {
       ASSERT_OK(Put(Key(key_idx), rnd.RandomString(990)));
       key_idx++;
     }
-    ASSERT_OK(dbfull()->TEST_WaitForFlushMemTable());
+    dbfull()->TEST_WaitForFlushMemTable();
     ASSERT_EQ(NumSortedRuns(), num + 1);
   }
 
@@ -983,7 +983,7 @@ TEST_P(DBTestUniversalCompaction, UniversalCompactionStopStyleSimilarSize) {
     ASSERT_OK(Put(Key(key_idx), rnd.RandomString(990)));
     key_idx++;
   }
-  ASSERT_OK(dbfull()->TEST_WaitForCompact());
+  dbfull()->TEST_WaitForCompact();
   // Suppose each file flushed from mem table has size 1. Now we compact
   // (level0_file_num_compaction_trigger+1)=4 files and should have a big
   // file of size 4.
@@ -1004,7 +1004,7 @@ TEST_P(DBTestUniversalCompaction, UniversalCompactionStopStyleSimilarSize) {
       ASSERT_OK(Put(Key(key_idx), rnd.RandomString(990)));
       key_idx++;
     }
-    ASSERT_OK(dbfull()->TEST_WaitForFlushMemTable());
+    dbfull()->TEST_WaitForFlushMemTable();
     ASSERT_EQ(NumSortedRuns(), num + 3);
   }
 
@@ -1014,7 +1014,7 @@ TEST_P(DBTestUniversalCompaction, UniversalCompactionStopStyleSimilarSize) {
     ASSERT_OK(Put(Key(key_idx), rnd.RandomString(990)));
     key_idx++;
   }
-  ASSERT_OK(dbfull()->TEST_WaitForCompact());
+  dbfull()->TEST_WaitForCompact();
   // Before compaction, we have 4 files at level 0, with size 4, 0.4, 1, 1.
   // After compaction, we should have 3 files, with size 4, 0.4, 2.
   ASSERT_EQ(NumSortedRuns(), 3);
@@ -1025,7 +1025,7 @@ TEST_P(DBTestUniversalCompaction, UniversalCompactionStopStyleSimilarSize) {
     ASSERT_OK(Put(Key(key_idx), rnd.RandomString(990)));
     key_idx++;
   }
-  ASSERT_OK(dbfull()->TEST_WaitForCompact());
+  dbfull()->TEST_WaitForCompact();
   // Level-0 compaction is triggered, but no file will be picked up.
   ASSERT_EQ(NumSortedRuns(), 4);
 }
@@ -1054,8 +1054,8 @@ TEST_P(DBTestUniversalCompaction, UniversalCompactionCompressRatio1) {
       ASSERT_OK(Put(Key(key_idx), CompressibleString(&rnd, 10000)));
       key_idx++;
     }
-    ASSERT_OK(dbfull()->TEST_WaitForFlushMemTable());
-    ASSERT_OK(dbfull()->TEST_WaitForCompact());
+    dbfull()->TEST_WaitForFlushMemTable();
+    dbfull()->TEST_WaitForCompact();
   }
   ASSERT_LT(TotalSize(), 110000U * 2 * 0.9);
 
@@ -1066,8 +1066,8 @@ TEST_P(DBTestUniversalCompaction, UniversalCompactionCompressRatio1) {
       ASSERT_OK(Put(Key(key_idx), CompressibleString(&rnd, 10000)));
       key_idx++;
     }
-    ASSERT_OK(dbfull()->TEST_WaitForFlushMemTable());
-    ASSERT_OK(dbfull()->TEST_WaitForCompact());
+    dbfull()->TEST_WaitForFlushMemTable();
+    dbfull()->TEST_WaitForCompact();
   }
   ASSERT_LT(TotalSize(), 110000 * 4 * 0.9);
 
@@ -1079,8 +1079,8 @@ TEST_P(DBTestUniversalCompaction, UniversalCompactionCompressRatio1) {
       ASSERT_OK(Put(Key(key_idx), CompressibleString(&rnd, 10000)));
       key_idx++;
     }
-    ASSERT_OK(dbfull()->TEST_WaitForFlushMemTable());
-    ASSERT_OK(dbfull()->TEST_WaitForCompact());
+    dbfull()->TEST_WaitForFlushMemTable();
+    dbfull()->TEST_WaitForCompact();
   }
   ASSERT_LT(TotalSize(), 110000 * 6 * 0.9);
 
@@ -1092,8 +1092,8 @@ TEST_P(DBTestUniversalCompaction, UniversalCompactionCompressRatio1) {
       ASSERT_OK(Put(Key(key_idx), CompressibleString(&rnd, 10000)));
       key_idx++;
     }
-    ASSERT_OK(dbfull()->TEST_WaitForFlushMemTable());
-    ASSERT_OK(dbfull()->TEST_WaitForCompact());
+    dbfull()->TEST_WaitForFlushMemTable();
+    dbfull()->TEST_WaitForCompact();
   }
   ASSERT_GT(TotalSize(), 110000 * 11 * 0.8 + 110000 * 2);
 }
@@ -1122,8 +1122,8 @@ TEST_P(DBTestUniversalCompaction, UniversalCompactionCompressRatio2) {
       ASSERT_OK(Put(Key(key_idx), CompressibleString(&rnd, 10000)));
       key_idx++;
     }
-    ASSERT_OK(dbfull()->TEST_WaitForFlushMemTable());
-    ASSERT_OK(dbfull()->TEST_WaitForCompact());
+    dbfull()->TEST_WaitForFlushMemTable();
+    dbfull()->TEST_WaitForCompact();
   }
   ASSERT_LT(TotalSize(), 120000U * 12 * 0.82 + 120000 * 2);
 }
@@ -1169,7 +1169,7 @@ TEST_P(DBTestUniversalCompaction, UniversalCompactionTrivialMoveTest1) {
   std::vector<std::string> values;
 
   ASSERT_OK(Flush(1));
-  ASSERT_OK(dbfull()->TEST_WaitForCompact());
+  dbfull()->TEST_WaitForCompact();
 
   ASSERT_GT(trivial_move, 0);
   ASSERT_GT(non_trivial_move, 0);
@@ -1215,7 +1215,7 @@ TEST_P(DBTestUniversalCompaction, UniversalCompactionTrivialMoveTest2) {
   std::vector<std::string> values;
 
   ASSERT_OK(Flush(1));
-  ASSERT_OK(dbfull()->TEST_WaitForCompact());
+  dbfull()->TEST_WaitForCompact();
 
   ASSERT_GT(trivial_move, 0);
 
@@ -1239,14 +1239,12 @@ TEST_P(DBTestUniversalCompaction, UniversalCompactionFourPaths) {
   options.num_levels = 1;
 
   std::vector<std::string> filenames;
-  if (env_->GetChildren(options.db_paths[1].path, &filenames).ok()) {
-    // Delete archival files.
-    for (size_t i = 0; i < filenames.size(); ++i) {
-      ASSERT_OK(
-          env_->DeleteFile(options.db_paths[1].path + "/" + filenames[i]));
-    }
-    ASSERT_OK(env_->DeleteDir(options.db_paths[1].path));
+  env_->GetChildren(options.db_paths[1].path, &filenames);
+  // Delete archival files.
+  for (size_t i = 0; i < filenames.size(); ++i) {
+    env_->DeleteFile(options.db_paths[1].path + "/" + filenames[i]);
   }
+  env_->DeleteDir(options.db_paths[1].path);
   Reopen(options);
 
   Random rnd(301);
@@ -1505,11 +1503,11 @@ TEST_P(DBTestUniversalCompaction, IncreaseUniversalCompactionNumLevels) {
   for (int i = 0; i <= max_key1; i++) {
     // each value is 10K
     ASSERT_OK(Put(1, Key(i), rnd.RandomString(10000)));
-    ASSERT_OK(dbfull()->TEST_WaitForFlushMemTable(handles_[1]));
-    ASSERT_OK(dbfull()->TEST_WaitForCompact());
+    dbfull()->TEST_WaitForFlushMemTable(handles_[1]);
+    dbfull()->TEST_WaitForCompact();
   }
   ASSERT_OK(Flush(1));
-  ASSERT_OK(dbfull()->TEST_WaitForCompact());
+  dbfull()->TEST_WaitForCompact();
 
   // Stage 2: reopen with universal compaction, num_levels=4
   options.compaction_style = kCompactionStyleUniversal;
@@ -1523,11 +1521,11 @@ TEST_P(DBTestUniversalCompaction, IncreaseUniversalCompactionNumLevels) {
   for (int i = max_key1 + 1; i <= max_key2; i++) {
     // each value is 10K
     ASSERT_OK(Put(1, Key(i), rnd.RandomString(10000)));
-    ASSERT_OK(dbfull()->TEST_WaitForFlushMemTable(handles_[1]));
-    ASSERT_OK(dbfull()->TEST_WaitForCompact());
+    dbfull()->TEST_WaitForFlushMemTable(handles_[1]);
+    dbfull()->TEST_WaitForCompact();
   }
   ASSERT_OK(Flush(1));
-  ASSERT_OK(dbfull()->TEST_WaitForCompact());
+  dbfull()->TEST_WaitForCompact();
 
   verify_func(max_key2);
   // Compaction to non-L0 has happened.
@@ -1542,8 +1540,7 @@ TEST_P(DBTestUniversalCompaction, IncreaseUniversalCompactionNumLevels) {
   compact_options.change_level = true;
   compact_options.target_level = 0;
   compact_options.exclusive_manual_compaction = exclusive_manual_compaction_;
-  ASSERT_OK(
-      dbfull()->CompactRange(compact_options, handles_[1], nullptr, nullptr));
+  dbfull()->CompactRange(compact_options, handles_[1], nullptr, nullptr);
   // Need to restart it once to remove higher level records in manifest.
   ReopenWithColumnFamilies({"default", "pikachu"}, options);
   // Final reopen
@@ -1556,11 +1553,11 @@ TEST_P(DBTestUniversalCompaction, IncreaseUniversalCompactionNumLevels) {
   for (int i = max_key2 + 1; i <= max_key3; i++) {
     // each value is 10K
     ASSERT_OK(Put(1, Key(i), rnd.RandomString(10000)));
-    ASSERT_OK(dbfull()->TEST_WaitForFlushMemTable(handles_[1]));
-    ASSERT_OK(dbfull()->TEST_WaitForCompact());
+    dbfull()->TEST_WaitForFlushMemTable(handles_[1]);
+    dbfull()->TEST_WaitForCompact();
   }
   ASSERT_OK(Flush(1));
-  ASSERT_OK(dbfull()->TEST_WaitForCompact());
+  dbfull()->TEST_WaitForCompact();
   verify_func(max_key3);
 }
 
@@ -1582,14 +1579,12 @@ TEST_P(DBTestUniversalCompaction, UniversalCompactionSecondPathRatio) {
       new SpecialSkipListFactory(KNumKeysByGenerateNewFile - 1));
 
   std::vector<std::string> filenames;
-  if (env_->GetChildren(options.db_paths[1].path, &filenames).ok()) {
-    // Delete archival files.
-    for (size_t i = 0; i < filenames.size(); ++i) {
-      ASSERT_OK(
-          env_->DeleteFile(options.db_paths[1].path + "/" + filenames[i]));
-    }
-    ASSERT_OK(env_->DeleteDir(options.db_paths[1].path));
+  env_->GetChildren(options.db_paths[1].path, &filenames);
+  // Delete archival files.
+  for (size_t i = 0; i < filenames.size(); ++i) {
+    env_->DeleteFile(options.db_paths[1].path + "/" + filenames[i]);
   }
+  env_->DeleteDir(options.db_paths[1].path);
   Reopen(options);
 
   Random rnd(301);
@@ -1704,14 +1699,14 @@ TEST_P(DBTestUniversalCompaction, ConcurrentBottomPriLowPriCompactions) {
       // use no_wait above because that one waits for flush and compaction. We
       // don't want to wait for compaction because the full compaction is
       // intentionally blocked while more files are flushed.
-      ASSERT_OK(dbfull()->TEST_WaitForFlushMemTable());
+      dbfull()->TEST_WaitForFlushMemTable();
     }
     if (i == 0) {
       TEST_SYNC_POINT(
           "DBTestUniversalCompaction:ConcurrentBottomPriLowPriCompactions:0");
     }
   }
-  ASSERT_OK(dbfull()->TEST_WaitForCompact());
+  dbfull()->TEST_WaitForCompact();
 
   // First compaction should output to bottom level. Second should output to L0
   // since older L0 files pending compaction prevent it from being placed lower.
@@ -1750,7 +1745,7 @@ TEST_P(DBTestUniversalCompaction, RecalculateScoreAfterPicking) {
     int key_idx = 0;
     GenerateNewFile(&rnd, &key_idx);
   }
-  ASSERT_OK(dbfull()->TEST_WaitForCompact());
+  dbfull()->TEST_WaitForCompact();
   // Compacting the first four files was enough to bring the score below one so
   // there's no need to schedule any more compactions.
   ASSERT_EQ(1, num_compactions_attempted);
@@ -1780,9 +1775,9 @@ TEST_P(DBTestUniversalCompaction, FinalSortedRunCompactFilesConflict) {
   auto stop_token =
       dbfull()->TEST_write_controler().GetCompactionPressureToken();
 
-  ASSERT_OK(Put("key", "val"));
+  Put("key", "val");
   Flush();
-  ASSERT_OK(dbfull()->CompactRange(CompactRangeOptions(), nullptr, nullptr));
+  dbfull()->CompactRange(CompactRangeOptions(), nullptr, nullptr);
   ASSERT_EQ(NumTableFilesAtLevel(num_levels_ - 1), 1);
   ColumnFamilyMetaData cf_meta;
   ColumnFamilyHandle* default_cfh = db_->DefaultColumnFamily();
@@ -1806,10 +1801,10 @@ TEST_P(DBTestUniversalCompaction, FinalSortedRunCompactFilesConflict) {
   TEST_SYNC_POINT(
       "DBTestUniversalCompaction:FinalSortedRunCompactFilesConflict:0");
   for (int i = 0; i < 2; ++i) {
-    ASSERT_OK(Put("key", "val"));
+    Put("key", "val");
     Flush();
   }
-  ASSERT_OK(dbfull()->TEST_WaitForCompact());
+  dbfull()->TEST_WaitForCompact();
 
   compact_files_thread.join();
 }
@@ -1840,7 +1835,7 @@ TEST_P(DBTestUniversalManualCompactionOutputPathId,
   DestroyAndReopen(options);
   CreateAndReopenWithCF({"pikachu"}, options);
   MakeTables(3, "p", "q", 1);
-  ASSERT_OK(dbfull()->TEST_WaitForCompact());
+  dbfull()->TEST_WaitForCompact();
   ASSERT_EQ(2, TotalLiveFiles(1));
   ASSERT_EQ(2, GetSstFileCount(options.db_paths[0].path));
   ASSERT_EQ(0, GetSstFileCount(options.db_paths[1].path));
@@ -1849,7 +1844,7 @@ TEST_P(DBTestUniversalManualCompactionOutputPathId,
   CompactRangeOptions compact_options;
   compact_options.target_path_id = 1;
   compact_options.exclusive_manual_compaction = exclusive_manual_compaction_;
-  ASSERT_OK(db_->CompactRange(compact_options, handles_[1], nullptr, nullptr));
+  db_->CompactRange(compact_options, handles_[1], nullptr, nullptr);
   ASSERT_EQ(1, TotalLiveFiles(1));
   ASSERT_EQ(0, GetSstFileCount(options.db_paths[0].path));
   ASSERT_EQ(1, GetSstFileCount(options.db_paths[1].path));
@@ -1872,7 +1867,7 @@ TEST_P(DBTestUniversalManualCompactionOutputPathId,
   // Full compaction to DB path 0
   compact_options.target_path_id = 0;
   compact_options.exclusive_manual_compaction = exclusive_manual_compaction_;
-  ASSERT_OK(db_->CompactRange(compact_options, handles_[1], nullptr, nullptr));
+  db_->CompactRange(compact_options, handles_[1], nullptr, nullptr);
   ASSERT_EQ(1, TotalLiveFiles(1));
   ASSERT_EQ(1, GetSstFileCount(options.db_paths[0].path));
   ASSERT_EQ(0, GetSstFileCount(options.db_paths[1].path));
@@ -1909,23 +1904,23 @@ TEST_F(DBTestUniversalCompaction2, BasicL0toL1) {
   // during flush
   int i;
   for (i = 0; i < 2000; ++i) {
-    ASSERT_OK(Put(Key(i), "val"));
+    Put(Key(i), "val");
   }
   Flush();
   //  MoveFilesToLevel(6);
-  ASSERT_OK(dbfull()->CompactRange(CompactRangeOptions(), nullptr, nullptr));
+  dbfull()->CompactRange(CompactRangeOptions(), nullptr, nullptr);
 
   for (i = 1999; i < kNumKeys; ++i) {
     if (i >= kNumKeys - kWindowSize &&
         i < kNumKeys - kWindowSize + kNumDelsTrigger) {
-      ASSERT_OK(Delete(Key(i)));
+      Delete(Key(i));
     } else {
-      ASSERT_OK(Put(Key(i), "val"));
+      Put(Key(i), "val");
     }
   }
   Flush();
 
-  ASSERT_OK(dbfull()->TEST_WaitForCompact());
+  dbfull()->TEST_WaitForCompact();
   ASSERT_EQ(0, NumTableFilesAtLevel(0));
   ASSERT_GT(NumTableFilesAtLevel(6), 0);
 }
@@ -1952,21 +1947,21 @@ TEST_F(DBTestUniversalCompaction2, SingleLevel) {
   // during flush
   int i;
   for (i = 0; i < 2000; ++i) {
-    ASSERT_OK(Put(Key(i), "val"));
+    Put(Key(i), "val");
   }
   Flush();
 
   for (i = 1999; i < kNumKeys; ++i) {
     if (i >= kNumKeys - kWindowSize &&
         i < kNumKeys - kWindowSize + kNumDelsTrigger) {
-      ASSERT_OK(Delete(Key(i)));
+      Delete(Key(i));
     } else {
-      ASSERT_OK(Put(Key(i), "val"));
+      Put(Key(i), "val");
     }
   }
   Flush();
 
-  ASSERT_OK(dbfull()->TEST_WaitForCompact());
+  dbfull()->TEST_WaitForCompact();
   ASSERT_EQ(1, NumTableFilesAtLevel(0));
 }
 #endif  // ENABLE_SINGLE_LEVEL_DTC
@@ -1990,50 +1985,50 @@ TEST_F(DBTestUniversalCompaction2, MultipleLevels) {
   // during flush
   int i;
   for (i = 0; i < 500; ++i) {
-    ASSERT_OK(Put(Key(i), "val"));
+    Put(Key(i), "val");
   }
   Flush();
   for (i = 500; i < 1000; ++i) {
-    ASSERT_OK(Put(Key(i), "val"));
+    Put(Key(i), "val");
   }
   Flush();
   for (i = 1000; i < 1500; ++i) {
-    ASSERT_OK(Put(Key(i), "val"));
+    Put(Key(i), "val");
   }
   Flush();
   for (i = 1500; i < 2000; ++i) {
-    ASSERT_OK(Put(Key(i), "val"));
+    Put(Key(i), "val");
   }
   Flush();
 
-  ASSERT_OK(dbfull()->TEST_WaitForCompact());
+  dbfull()->TEST_WaitForCompact();
   ASSERT_EQ(0, NumTableFilesAtLevel(0));
   ASSERT_GT(NumTableFilesAtLevel(6), 0);
 
   for (i = 1999; i < 2333; ++i) {
-    ASSERT_OK(Put(Key(i), "val"));
+    Put(Key(i), "val");
   }
   Flush();
   for (i = 2333; i < 2666; ++i) {
-    ASSERT_OK(Put(Key(i), "val"));
+    Put(Key(i), "val");
   }
   Flush();
   for (i = 2666; i < 2999; ++i) {
-    ASSERT_OK(Put(Key(i), "val"));
+    Put(Key(i), "val");
   }
   Flush();
 
-  ASSERT_OK(dbfull()->TEST_WaitForCompact());
+  dbfull()->TEST_WaitForCompact();
   ASSERT_EQ(0, NumTableFilesAtLevel(0));
   ASSERT_GT(NumTableFilesAtLevel(6), 0);
   ASSERT_GT(NumTableFilesAtLevel(5), 0);
 
   for (i = 1900; i < 2100; ++i) {
-    ASSERT_OK(Delete(Key(i)));
+    Delete(Key(i));
   }
   Flush();
 
-  ASSERT_OK(dbfull()->TEST_WaitForCompact());
+  dbfull()->TEST_WaitForCompact();
   ASSERT_EQ(0, NumTableFilesAtLevel(0));
   ASSERT_EQ(0, NumTableFilesAtLevel(1));
   ASSERT_EQ(0, NumTableFilesAtLevel(2));
@@ -2062,23 +2057,23 @@ TEST_F(DBTestUniversalCompaction2, OverlappingL0) {
   // during flush
   int i;
   for (i = 0; i < 2000; ++i) {
-    ASSERT_OK(Put(Key(i), "val"));
+    Put(Key(i), "val");
   }
   Flush();
   for (i = 2000; i < 3000; ++i) {
-    ASSERT_OK(Put(Key(i), "val"));
+    Put(Key(i), "val");
   }
   Flush();
   for (i = 3500; i < 4000; ++i) {
-    ASSERT_OK(Put(Key(i), "val"));
+    Put(Key(i), "val");
   }
   Flush();
   for (i = 2900; i < 3100; ++i) {
-    ASSERT_OK(Delete(Key(i)));
+    Delete(Key(i));
   }
   Flush();
 
-  ASSERT_OK(dbfull()->TEST_WaitForCompact());
+  dbfull()->TEST_WaitForCompact();
   ASSERT_EQ(2, NumTableFilesAtLevel(0));
   ASSERT_GT(NumTableFilesAtLevel(6), 0);
 }
@@ -2104,23 +2099,23 @@ TEST_F(DBTestUniversalCompaction2, IngestBehind) {
   // during flush
   int i;
   for (i = 0; i < 2000; ++i) {
-    ASSERT_OK(Put(Key(i), "val"));
+    Put(Key(i), "val");
   }
   Flush();
   //  MoveFilesToLevel(6);
-  ASSERT_OK(dbfull()->CompactRange(CompactRangeOptions(), nullptr, nullptr));
+  dbfull()->CompactRange(CompactRangeOptions(), nullptr, nullptr);
 
   for (i = 1999; i < kNumKeys; ++i) {
     if (i >= kNumKeys - kWindowSize &&
         i < kNumKeys - kWindowSize + kNumDelsTrigger) {
-      ASSERT_OK(Delete(Key(i)));
+      Delete(Key(i));
     } else {
-      ASSERT_OK(Put(Key(i), "val"));
+      Put(Key(i), "val");
     }
   }
   Flush();
 
-  ASSERT_OK(dbfull()->TEST_WaitForCompact());
+  dbfull()->TEST_WaitForCompact();
   ASSERT_EQ(0, NumTableFilesAtLevel(0));
   ASSERT_EQ(0, NumTableFilesAtLevel(6));
   ASSERT_GT(NumTableFilesAtLevel(5), 0);
@@ -2129,7 +2124,7 @@ TEST_F(DBTestUniversalCompaction2, IngestBehind) {
 TEST_F(DBTestUniversalCompaction2, PeriodicCompactionDefault) {
   Options options;
   options.compaction_style = kCompactionStyleUniversal;
-  options.env = env_;
+
   KeepFilterFactory* filter = new KeepFilterFactory(true);
   options.compaction_filter_factory.reset(filter);
   Reopen(options);
@@ -2193,7 +2188,7 @@ TEST_F(DBTestUniversalCompaction2, PeriodicCompaction) {
   // Another flush would trigger compaction the oldest file.
   ASSERT_OK(Put("foo", "bar2"));
   Flush();
-  ASSERT_OK(dbfull()->TEST_WaitForCompact());
+  dbfull()->TEST_WaitForCompact();
 
   ASSERT_EQ(1, periodic_compactions);
   ASSERT_EQ(0, start_level);
@@ -2204,7 +2199,7 @@ TEST_F(DBTestUniversalCompaction2, PeriodicCompaction) {
   // A flush doesn't trigger a periodic compaction when threshold not hit
   ASSERT_OK(Put("foo", "bar2"));
   Flush();
-  ASSERT_OK(dbfull()->TEST_WaitForCompact());
+  dbfull()->TEST_WaitForCompact();
   ASSERT_EQ(0, periodic_compactions);
 
   // After periodic compaction threshold hits, a flush will trigger
@@ -2212,7 +2207,7 @@ TEST_F(DBTestUniversalCompaction2, PeriodicCompaction) {
   ASSERT_OK(Put("foo", "bar2"));
   env_->MockSleepForSeconds(48 * 60 * 60 + 100);
   Flush();
-  ASSERT_OK(dbfull()->TEST_WaitForCompact());
+  dbfull()->TEST_WaitForCompact();
   ASSERT_EQ(1, periodic_compactions);
   ASSERT_EQ(0, start_level);
   ASSERT_EQ(4, output_level);

db/db_wal_test.cc

@@ -47,8 +47,8 @@ class EnrichedSpecialEnv : public SpecialEnv {
     InstrumentedMutexLock l(&env_mutex_);
     if (f == skipped_wal) {
       deleted_wal_reopened = true;
-      if (IsWAL(f) && largest_deleted_wal.size() != 0 &&
-          f.compare(largest_deleted_wal) <= 0) {
+      if (IsWAL(f) && largetest_deleted_wal.size() != 0 &&
+          f.compare(largetest_deleted_wal) <= 0) {
         gap_in_wals = true;
       }
     }
@@ -62,9 +62,9 @@ class EnrichedSpecialEnv : public SpecialEnv {
       // remember its name partly because the application might attempt to
       // delete the file again.
       if (skipped_wal.size() != 0 && skipped_wal != fname) {
-        if (largest_deleted_wal.size() == 0 ||
-            largest_deleted_wal.compare(fname) < 0) {
-          largest_deleted_wal = fname;
+        if (largetest_deleted_wal.size() == 0 ||
+            largetest_deleted_wal.compare(fname) < 0) {
+          largetest_deleted_wal = fname;
         }
       } else {
         skipped_wal = fname;
@@ -82,7 +82,7 @@ class EnrichedSpecialEnv : public SpecialEnv {
   // the wal whose actual delete was skipped by the env
   std::string skipped_wal = "";
   // the largest WAL that was requested to be deleted
-  std::string largest_deleted_wal = "";
+  std::string largetest_deleted_wal = "";
   // number of WALs that were successfully deleted
   std::atomic<size_t> deleted_wal_cnt = {0};
   // the WAL whose delete from fs was skipped is reopened during recovery
@@ -338,165 +338,6 @@ TEST_F(DBWALTest, RecoverWithTableHandle) {
   } while (ChangeWalOptions());
 }
 
-TEST_F(DBWALTest, RecoverWithBlob) {
-  // Write a value that's below the prospective size limit for blobs and another
-  // one that's above. Note that blob files are not actually enabled at this
-  // point.
-  constexpr uint64_t min_blob_size = 10;
-
-  constexpr char short_value[] = "short";
-  static_assert(sizeof(short_value) - 1 < min_blob_size,
-                "short_value too long");
-
-  constexpr char long_value[] = "long_value";
-  static_assert(sizeof(long_value) - 1 >= min_blob_size,
-                "long_value too short");
-
-  ASSERT_OK(Put("key1", short_value));
-  ASSERT_OK(Put("key2", long_value));
-
-  // There should be no files just yet since we haven't flushed.
-  {
-    VersionSet* const versions = dbfull()->TEST_GetVersionSet();
-    assert(versions);
-
-    ColumnFamilyData* const cfd = versions->GetColumnFamilySet()->GetDefault();
-    assert(cfd);
-
-    Version* const current = cfd->current();
-    assert(current);
-
-    const VersionStorageInfo* const storage_info = current->storage_info();
-    assert(storage_info);
-
-    ASSERT_EQ(storage_info->num_non_empty_levels(), 0);
-    ASSERT_TRUE(storage_info->GetBlobFiles().empty());
-  }
-
-  // Reopen the database with blob files enabled. A new table file/blob file
-  // pair should be written during recovery.
-  Options options;
-  options.enable_blob_files = true;
-  options.min_blob_size = min_blob_size;
-  options.avoid_flush_during_recovery = false;
-  options.disable_auto_compactions = true;
-  options.env = env_;
-
-  Reopen(options);
-
-  ASSERT_EQ(Get("key1"), short_value);
-  ASSERT_EQ(Get("key2"), long_value);
-
-  VersionSet* const versions = dbfull()->TEST_GetVersionSet();
-  assert(versions);
-
-  ColumnFamilyData* const cfd = versions->GetColumnFamilySet()->GetDefault();
-  assert(cfd);
-
-  Version* const current = cfd->current();
-  assert(current);
-
-  const VersionStorageInfo* const storage_info = current->storage_info();
-  assert(storage_info);
-
-  const auto& l0_files = storage_info->LevelFiles(0);
-  ASSERT_EQ(l0_files.size(), 1);
-
-  const FileMetaData* const table_file = l0_files[0];
-  assert(table_file);
-
-  const auto& blob_files = storage_info->GetBlobFiles();
-  ASSERT_EQ(blob_files.size(), 1);
-
-  const auto& blob_file = blob_files.begin()->second;
-  assert(blob_file);
-
-  ASSERT_EQ(table_file->smallest.user_key(), "key1");
-  ASSERT_EQ(table_file->largest.user_key(), "key2");
-  ASSERT_EQ(table_file->fd.smallest_seqno, 1);
-  ASSERT_EQ(table_file->fd.largest_seqno, 2);
-  ASSERT_EQ(table_file->oldest_blob_file_number,
-            blob_file->GetBlobFileNumber());
-
-  ASSERT_EQ(blob_file->GetTotalBlobCount(), 1);
-
-#ifndef ROCKSDB_LITE
-  const InternalStats* const internal_stats = cfd->internal_stats();
-  assert(internal_stats);
-
-  const uint64_t expected_bytes =
-      table_file->fd.GetFileSize() + blob_file->GetTotalBlobBytes();
-
-  const auto& compaction_stats = internal_stats->TEST_GetCompactionStats();
-  ASSERT_FALSE(compaction_stats.empty());
-  ASSERT_EQ(compaction_stats[0].bytes_written, expected_bytes);
-  ASSERT_EQ(compaction_stats[0].num_output_files, 2);
-
-  const uint64_t* const cf_stats_value = internal_stats->TEST_GetCFStatsValue();
-  ASSERT_EQ(cf_stats_value[InternalStats::BYTES_FLUSHED], expected_bytes);
-#endif  // ROCKSDB_LITE
-}
-
-class DBRecoveryTestBlobError
-    : public DBWALTest,
-      public testing::WithParamInterface<std::string> {
- public:
-  DBRecoveryTestBlobError()
-      : fault_injection_env_(env_), sync_point_(GetParam()) {}
-  ~DBRecoveryTestBlobError() { Close(); }
-
-  FaultInjectionTestEnv fault_injection_env_;
-  std::string sync_point_;
-};
-
-INSTANTIATE_TEST_CASE_P(DBRecoveryTestBlobError, DBRecoveryTestBlobError,
-                        ::testing::ValuesIn(std::vector<std::string>{
-                            "BlobFileBuilder::WriteBlobToFile:AddRecord",
-                            "BlobFileBuilder::WriteBlobToFile:AppendFooter"}));
-
-TEST_P(DBRecoveryTestBlobError, RecoverWithBlobError) {
-  // Write a value. Note that blob files are not actually enabled at this point.
-  ASSERT_OK(Put("key", "blob"));
-
-  // Reopen with blob files enabled but make blob file writing fail during
-  // recovery.
-  SyncPoint::GetInstance()->SetCallBack(sync_point_, [this](void* /* arg */) {
-    fault_injection_env_.SetFilesystemActive(false,
-                                             Status::IOError(sync_point_));
-  });
-  SyncPoint::GetInstance()->SetCallBack(
-      "BuildTable:BeforeDeleteFile", [this](void* /* arg */) {
-        fault_injection_env_.SetFilesystemActive(true);
-      });
-  SyncPoint::GetInstance()->EnableProcessing();
-
-  Options options;
-  options.enable_blob_files = true;
-  options.avoid_flush_during_recovery = false;
-  options.disable_auto_compactions = true;
-  options.env = &fault_injection_env_;
-
-  ASSERT_NOK(TryReopen(options));
-
-  SyncPoint::GetInstance()->DisableProcessing();
-  SyncPoint::GetInstance()->ClearAllCallBacks();
-
-  // Make sure the files generated by the failed recovery have been deleted.
-  std::vector<std::string> files;
-  ASSERT_OK(env_->GetChildren(dbname_, &files));
-  for (const auto& file : files) {
-    uint64_t number = 0;
-    FileType type = kTableFile;
-
-    if (!ParseFileName(file, &number, &type)) {
-      continue;
-    }
-
-    ASSERT_NE(type, kTableFile);
-    ASSERT_NE(type, kBlobFile);
-  }
-}
-
 TEST_F(DBWALTest, IgnoreRecoveredLog) {
   std::string backup_logs = dbname_ + "/backup_logs";
 
@@ -1181,13 +1022,32 @@ class RecoveryTestHelper {
     test->Close();
 #endif
     if (trunc) {
-      ASSERT_OK(
-          test::TruncateFile(env, fname, static_cast<uint64_t>(size * off)));
+      ASSERT_EQ(0, truncate(fname.c_str(), static_cast<int64_t>(size * off)));
     } else {
-      ASSERT_OK(test::CorruptFile(env, fname, static_cast<int>(size * off + 8),
-                                  static_cast<int>(size * len), false));
+      InduceCorruption(fname, static_cast<size_t>(size * off + 8),
+                       static_cast<size_t>(size * len));
     }
   }
+
+  // Overwrite data with 'a' from offset for length len
+  static void InduceCorruption(const std::string& filename, size_t offset,
+                               size_t len) {
+    ASSERT_GT(len, 0U);
+
+    int fd = open(filename.c_str(), O_RDWR);
+
+    // On windows long is 32-bit
+    ASSERT_LE(offset, std::numeric_limits<long>::max());
+
+    ASSERT_GT(fd, 0);
+    ASSERT_EQ(offset, lseek(fd, static_cast<long>(offset), SEEK_SET));
+
+    void* buf = alloca(len);
+    memset(buf, 'b', len);
+    ASSERT_EQ(len, write(fd, buf, static_cast<unsigned int>(len)));
+
+    close(fd);
+  }
 };
 
 class DBWALTestWithParams
@@ -1309,7 +1169,8 @@ TEST_F(DBWALTest, kPointInTimeRecoveryCFConsistency) {
 
   ASSERT_OK(Put(1, "key3", "val3"));
   // Corrupt WAL at location of key3
-  test::CorruptFile(env, fname, static_cast<int>(offset_to_corrupt), 4, false);
+  RecoveryTestHelper::InduceCorruption(
+      fname, static_cast<size_t>(offset_to_corrupt), static_cast<size_t>(4));
   ASSERT_OK(Put(2, "key4", "val4"));
   ASSERT_OK(Put(1, "key5", "val5"));
   Flush(2);
@@ -1348,19 +1209,13 @@ TEST_P(DBWALTestWithParams, kPointInTimeRecovery) {
   size_t recovered_row_count = RecoveryTestHelper::GetData(this);
   ASSERT_LT(recovered_row_count, row_count);
 
-  // Verify a prefix of keys were recovered. But not in the case of full WAL
-  // truncation, because we have no way to know there was a corruption when
-  // truncation happened on record boundaries (preventing recovery holes in
-  // that case requires using `track_and_verify_wals_in_manifest`).
-  if (!trunc || corrupt_offset != 0) {
-    bool expect_data = true;
-    for (size_t k = 0; k < maxkeys; ++k) {
-      bool found = Get("key" + ToString(k)) != "NOT_FOUND";
-      if (expect_data && !found) {
-        expect_data = false;
-      }
-      ASSERT_EQ(found, expect_data);
+  bool expect_data = true;
+  for (size_t k = 0; k < maxkeys; ++k) {
+    bool found = Get("key" + ToString(corrupt_offset)) != "NOT_FOUND";
+    if (expect_data && !found) {
+      expect_data = false;
     }
+    ASSERT_EQ(found, expect_data);
   }
 
   const size_t min = RecoveryTestHelper::kKeysPerWALFile *
@@ -1702,12 +1557,7 @@ TEST_F(DBWALTest, RestoreTotalLogSizeAfterRecoverWithoutFlush) {
 TEST_F(DBWALTest, TruncateLastLogAfterRecoverWithoutFlush) {
   constexpr size_t kKB = 1024;
   Options options = CurrentOptions();
-  options.env = env_;
   options.avoid_flush_during_recovery = true;
-  if (mem_env_) {
-    ROCKSDB_GTEST_SKIP("Test requires non-mem environment");
-    return;
-  }
   // Test fallocate support of running file system.
   // Skip this test if fallocate is not supported.
   std::string fname_test_fallocate = dbname_ + "/preallocate_testfile";

db/db_with_timestamp_basic_test.cc

@@ -141,8 +141,7 @@ class DBBasicTestWithTimestampBase : public DBTestBase {
     ukey_and_ts.assign(expected_ukey.data(), expected_ukey.size());
     ukey_and_ts.append(expected_ts.data(), expected_ts.size());
     ParsedInternalKey parsed_ikey;
-    ASSERT_OK(
-        ParseInternalKey(it->key(), &parsed_ikey, true /* log_err_key */));
+    ASSERT_TRUE(ParseInternalKey(it->key(), &parsed_ikey));
     ASSERT_EQ(ukey_and_ts, parsed_ikey.user_key);
     ASSERT_EQ(expected_val_type, parsed_ikey.type);
     ASSERT_EQ(expected_seq, parsed_ikey.sequence);
@@ -162,8 +161,7 @@ class DBBasicTestWithTimestampBase : public DBTestBase {
     ukey_and_ts.append(expected_ts.data(), expected_ts.size());
 
     ParsedInternalKey parsed_ikey;
-    ASSERT_OK(
-        ParseInternalKey(it->key(), &parsed_ikey, true /* log_err_key */));
+    ASSERT_TRUE(ParseInternalKey(it->key(), &parsed_ikey));
     ASSERT_EQ(expected_val_type, parsed_ikey.type);
     ASSERT_EQ(Slice(ukey_and_ts), parsed_ikey.user_key);
     if (expected_val_type == kTypeValue) {
@@ -244,103 +242,6 @@ TEST_F(DBBasicTestWithTimestamp, SimpleForwardIterate) {
   Close();
 }
 
-TEST_F(DBBasicTestWithTimestamp, SeekWithPrefixLessThanKey) {
-  Options options = CurrentOptions();
-  options.env = env_;
-  options.create_if_missing = true;
-  options.prefix_extractor.reset(NewFixedPrefixTransform(3));
-  BlockBasedTableOptions bbto;
-  bbto.filter_policy.reset(NewBloomFilterPolicy(10, false));
-  bbto.cache_index_and_filter_blocks = true;
-  bbto.whole_key_filtering = true;
-  options.table_factory.reset(NewBlockBasedTableFactory(bbto));
-  const size_t kTimestampSize = Timestamp(0, 0).size();
-  TestComparator test_cmp(kTimestampSize);
-  options.comparator = &test_cmp;
-  DestroyAndReopen(options);
-
-  WriteOptions write_opts;
-  std::string ts_str = Timestamp(1, 0);
-  Slice ts = ts_str;
-  write_opts.timestamp = &ts;
-
-  ASSERT_OK(db_->Put(write_opts, "foo1", "bar"));
-  Flush();
-
-  ASSERT_OK(db_->Put(write_opts, "foo2", "bar"));
-  Flush();
-
-  // Move sst file to next level
-  ASSERT_OK(db_->CompactRange(CompactRangeOptions(), nullptr, nullptr));
-
-  ASSERT_OK(db_->Put(write_opts, "foo3", "bar"));
-  Flush();
-
-  ReadOptions read_opts;
-  std::string read_ts = Timestamp(1, 0);
-  ts = read_ts;
-  read_opts.timestamp = &ts;
-  {
-    std::unique_ptr<Iterator> iter(db_->NewIterator(read_opts));
-    iter->Seek("foo");
-    ASSERT_TRUE(iter->Valid());
-    ASSERT_OK(iter->status());
-    iter->Seek("bbb");
-    ASSERT_FALSE(iter->Valid());
-    ASSERT_OK(iter->status());
-  }
-
-  Close();
-}
-
-TEST_F(DBBasicTestWithTimestamp, SeekWithPrefixLargerThanKey) {
-  Options options = CurrentOptions();
-  options.env = env_;
-  options.create_if_missing = true;
-  options.prefix_extractor.reset(NewFixedPrefixTransform(20));
-  BlockBasedTableOptions bbto;
-  bbto.filter_policy.reset(NewBloomFilterPolicy(10, false));
-  bbto.cache_index_and_filter_blocks = true;
-  bbto.whole_key_filtering = true;
-  options.table_factory.reset(NewBlockBasedTableFactory(bbto));
-  const size_t kTimestampSize = Timestamp(0, 0).size();
-  TestComparator test_cmp(kTimestampSize);
-  options.comparator = &test_cmp;
-  DestroyAndReopen(options);
-
-  WriteOptions write_opts;
-  std::string ts_str = Timestamp(1, 0);
-  Slice ts = ts_str;
-  write_opts.timestamp = &ts;
-
-  ASSERT_OK(db_->Put(write_opts, "foo1", "bar"));
-  Flush();
-
-  ASSERT_OK(db_->Put(write_opts, "foo2", "bar"));
-  Flush();
-
-  // Move sst file to next level
-  ASSERT_OK(db_->CompactRange(CompactRangeOptions(), nullptr, nullptr));
-
-  ASSERT_OK(db_->Put(write_opts, "foo3", "bar"));
-  Flush();
-
-  ReadOptions read_opts;
-  std::string read_ts = Timestamp(2, 0);
-  ts = read_ts;
-  read_opts.timestamp = &ts;
-  {
-    std::unique_ptr<Iterator> iter(db_->NewIterator(read_opts));
-    // Make sure the prefix extractor doesn't include timestamp, otherwise it
-    // may return invalid result.
-    iter->Seek("foo");
-    ASSERT_TRUE(iter->Valid());
-    ASSERT_OK(iter->status());
-  }
-
-  Close();
-}
-
 TEST_F(DBBasicTestWithTimestamp, SimpleForwardIterateLowerTsBound) {
   constexpr int kNumKeysPerFile = 128;
   constexpr uint64_t kMaxKey = 1024;
@@ -567,8 +468,8 @@ TEST_F(DBBasicTestWithTimestamp, ReseekToNextUserKey) {
   {
     std::string ts_str = Timestamp(static_cast<uint64_t>(kNumKeys + 1), 0);
     WriteBatch batch(0, 0, kTimestampSize);
-    ASSERT_OK(batch.Put("a", "new_value"));
-    ASSERT_OK(batch.Put("b", "new_value"));
+    batch.Put("a", "new_value");
+    batch.Put("b", "new_value");
     s = batch.AssignTimestamp(ts_str);
     ASSERT_OK(s);
     s = db_->Write(write_opts, &batch);
@@ -589,228 +490,6 @@ TEST_F(DBBasicTestWithTimestamp, ReseekToNextUserKey) {
   Close();
 }
 
-TEST_F(DBBasicTestWithTimestamp, MultiGetWithFastLocalBloom) {
-  Options options = CurrentOptions();
-  options.env = env_;
-  options.create_if_missing = true;
-  BlockBasedTableOptions bbto;
-  bbto.filter_policy.reset(NewBloomFilterPolicy(10, false));
-  bbto.cache_index_and_filter_blocks = true;
-  bbto.whole_key_filtering = true;
-  options.table_factory.reset(NewBlockBasedTableFactory(bbto));
-  const size_t kTimestampSize = Timestamp(0, 0).size();
-  TestComparator test_cmp(kTimestampSize);
-  options.comparator = &test_cmp;
-  DestroyAndReopen(options);
-
-  // Write any value
-  WriteOptions write_opts;
-  std::string ts_str = Timestamp(1, 0);
-  Slice ts = ts_str;
-  write_opts.timestamp = &ts;
-
-  ASSERT_OK(db_->Put(write_opts, "foo", "bar"));
-
-  Flush();
-
-  // Read with MultiGet
-  ReadOptions read_opts;
-  read_opts.timestamp = &ts;
-  size_t batch_size = 1;
-  std::vector<Slice> keys(batch_size);
-  std::vector<PinnableSlice> values(batch_size);
-  std::vector<Status> statuses(batch_size);
-  keys[0] = "foo";
-  ColumnFamilyHandle* cfh = db_->DefaultColumnFamily();
-  db_->MultiGet(read_opts, cfh, batch_size, keys.data(), values.data(),
-                statuses.data());
-
-  ASSERT_OK(statuses[0]);
-  Close();
-}
-
-TEST_F(DBBasicTestWithTimestamp, MultiGetWithPrefix) {
-  Options options = CurrentOptions();
-  options.env = env_;
-  options.create_if_missing = true;
-  options.prefix_extractor.reset(NewCappedPrefixTransform(5));
-  BlockBasedTableOptions bbto;
-  bbto.filter_policy.reset(NewBloomFilterPolicy(10, false));
-  bbto.cache_index_and_filter_blocks = true;
-  bbto.whole_key_filtering = false;
-  options.table_factory.reset(NewBlockBasedTableFactory(bbto));
-  const size_t kTimestampSize = Timestamp(0, 0).size();
-  TestComparator test_cmp(kTimestampSize);
-  options.comparator = &test_cmp;
-  DestroyAndReopen(options);
-
-  // Write any value
-  WriteOptions write_opts;
-  std::string ts_str = Timestamp(1, 0);
-  Slice ts = ts_str;
-  write_opts.timestamp = &ts;
-
-  ASSERT_OK(db_->Put(write_opts, "foo", "bar"));
-
-  Flush();
-
-  // Read with MultiGet
-  ReadOptions read_opts;
-  read_opts.timestamp = &ts;
-  size_t batch_size = 1;
-  std::vector<Slice> keys(batch_size);
-  std::vector<PinnableSlice> values(batch_size);
-  std::vector<Status> statuses(batch_size);
-  keys[0] = "foo";
-  ColumnFamilyHandle* cfh = db_->DefaultColumnFamily();
-  db_->MultiGet(read_opts, cfh, batch_size, keys.data(), values.data(),
-                statuses.data());
-
-  ASSERT_OK(statuses[0]);
-  Close();
-}
-
-TEST_F(DBBasicTestWithTimestamp, MultiGetWithMemBloomFilter) {
-  Options options = CurrentOptions();
-  options.env = env_;
-  options.create_if_missing = true;
-  options.prefix_extractor.reset(NewCappedPrefixTransform(5));
-  BlockBasedTableOptions bbto;
-  bbto.filter_policy.reset(NewBloomFilterPolicy(10, false));
-  bbto.cache_index_and_filter_blocks = true;
-  bbto.whole_key_filtering = false;
-  options.memtable_prefix_bloom_size_ratio = 0.1;
-  options.table_factory.reset(NewBlockBasedTableFactory(bbto));
-  const size_t kTimestampSize = Timestamp(0, 0).size();
-  TestComparator test_cmp(kTimestampSize);
-  options.comparator = &test_cmp;
-  DestroyAndReopen(options);
-
-  // Write any value
-  WriteOptions write_opts;
-  std::string ts_str = Timestamp(1, 0);
-  Slice ts = ts_str;
-  write_opts.timestamp = &ts;
-
-  ASSERT_OK(db_->Put(write_opts, "foo", "bar"));
-
-  // Read with MultiGet
-  ts_str = Timestamp(2, 0);
-  ts = ts_str;
-  ReadOptions read_opts;
-  read_opts.timestamp = &ts;
-  size_t batch_size = 1;
-  std::vector<Slice> keys(batch_size);
-  std::vector<PinnableSlice> values(batch_size);
-  std::vector<Status> statuses(batch_size);
-  keys[0] = "foo";
-  ColumnFamilyHandle* cfh = db_->DefaultColumnFamily();
-  db_->MultiGet(read_opts, cfh, batch_size, keys.data(), values.data(),
-                statuses.data());
-
-  ASSERT_OK(statuses[0]);
-  Close();
-}
-
-TEST_F(DBBasicTestWithTimestamp, MultiGetRangeFiltering) {
-  Options options = CurrentOptions();
-  options.env = env_;
-  options.create_if_missing = true;
-  BlockBasedTableOptions bbto;
-  bbto.filter_policy.reset(NewBloomFilterPolicy(10, false));
-  bbto.cache_index_and_filter_blocks = true;
-  bbto.whole_key_filtering = false;
-  options.memtable_prefix_bloom_size_ratio = 0.1;
-  options.table_factory.reset(NewBlockBasedTableFactory(bbto));
-  const size_t kTimestampSize = Timestamp(0, 0).size();
-  TestComparator test_cmp(kTimestampSize);
-  options.comparator = &test_cmp;
-  DestroyAndReopen(options);
-
-  // Write any value
-  WriteOptions write_opts;
-  std::string ts_str = Timestamp(1, 0);
-  Slice ts = ts_str;
-  write_opts.timestamp = &ts;
-
-  // random data
-  for (int i = 0; i < 3; i++) {
-    auto key = ToString(i * 10);
-    auto value = ToString(i * 10);
-    Slice key_slice = key;
-    Slice value_slice = value;
-    ASSERT_OK(db_->Put(write_opts, key_slice, value_slice));
-    Flush();
-  }
-
-  // Make num_levels to 2 to do key range filtering of sst files
-  ASSERT_OK(db_->CompactRange(CompactRangeOptions(), nullptr, nullptr));
-
-  ASSERT_OK(db_->Put(write_opts, "foo", "bar"));
-
-  Flush();
-
-  // Read with MultiGet
-  ts_str = Timestamp(2, 0);
-  ts = ts_str;
-  ReadOptions read_opts;
-  read_opts.timestamp = &ts;
-  size_t batch_size = 1;
-  std::vector<Slice> keys(batch_size);
-  std::vector<PinnableSlice> values(batch_size);
-  std::vector<Status> statuses(batch_size);
-  keys[0] = "foo";
-  ColumnFamilyHandle* cfh = db_->DefaultColumnFamily();
-  db_->MultiGet(read_opts, cfh, batch_size, keys.data(), values.data(),
-                statuses.data());
-
-  ASSERT_OK(statuses[0]);
-  Close();
-}
-
-TEST_F(DBBasicTestWithTimestamp, MultiGetPrefixFilter) {
-  Options options = CurrentOptions();
-  options.env = env_;
-  options.create_if_missing = true;
-  options.prefix_extractor.reset(NewCappedPrefixTransform(5));
-  BlockBasedTableOptions bbto;
-  bbto.filter_policy.reset(NewBloomFilterPolicy(10, false));
-  bbto.cache_index_and_filter_blocks = true;
-  bbto.whole_key_filtering = false;
-  options.memtable_prefix_bloom_size_ratio = 0.1;
-  options.table_factory.reset(NewBlockBasedTableFactory(bbto));
-  const size_t kTimestampSize = Timestamp(0, 0).size();
-  TestComparator test_cmp(kTimestampSize);
-  options.comparator = &test_cmp;
-  DestroyAndReopen(options);
-
-  WriteOptions write_opts;
-  std::string ts_str = Timestamp(1, 0);
-  Slice ts = ts_str;
-  write_opts.timestamp = &ts;
-
-  ASSERT_OK(db_->Put(write_opts, "foo", "bar"));
-
-  Flush();
-  // Read with MultiGet
-  ts_str = Timestamp(2, 0);
-  ts = ts_str;
-  ReadOptions read_opts;
-  read_opts.timestamp = &ts;
-  size_t batch_size = 1;
-  std::vector<Slice> keys(batch_size);
-  std::vector<std::string> values(batch_size);
-  std::vector<std::string> timestamps(batch_size);
-  keys[0] = "foo";
-  ColumnFamilyHandle* cfh = db_->DefaultColumnFamily();
-  std::vector<ColumnFamilyHandle*> cfhs(keys.size(), cfh);
-  std::vector<Status> statuses =
-      db_->MultiGet(read_opts, cfhs, keys, &values, &timestamps);
-
-  ASSERT_OK(statuses[0]);
-  Close();
-}
-
 TEST_F(DBBasicTestWithTimestamp, MaxKeysSkipped) {
   Options options = CurrentOptions();
   options.env = env_;
@@ -911,132 +590,8 @@ TEST_F(DBBasicTestWithTimestamp, CompactDeletionWithTimestampMarkerToBottom) {
 
 class DataVisibilityTest : public DBBasicTestWithTimestampBase {
  public:
-  DataVisibilityTest() : DBBasicTestWithTimestampBase("data_visibility_test") {
-    // Initialize test data
-    for (int i = 0; i < kTestDataSize; i++) {
-      test_data_[i].key = "key" + ToString(i);
-      test_data_[i].value = "value" + ToString(i);
-      test_data_[i].timestamp = Timestamp(i, 0);
-      test_data_[i].ts = i;
-      test_data_[i].seq_num = kMaxSequenceNumber;
-    }
-  }
-
- protected:
-  struct TestData {
-    std::string key;
-    std::string value;
-    int ts;
-    std::string timestamp;
-    SequenceNumber seq_num;
-  };
-
-  constexpr static int kTestDataSize = 3;
-  TestData test_data_[kTestDataSize];
-
-  void PutTestData(int index, ColumnFamilyHandle* cfh = nullptr) {
-    ASSERT_LE(index, kTestDataSize);
-    WriteOptions write_opts;
-    Slice ts_slice = test_data_[index].timestamp;
-    write_opts.timestamp = &ts_slice;
-
-    if (cfh == nullptr) {
-      ASSERT_OK(
-          db_->Put(write_opts, test_data_[index].key, test_data_[index].value));
-      const Snapshot* snap = db_->GetSnapshot();
-      test_data_[index].seq_num = snap->GetSequenceNumber();
-      if (index > 0) {
-        ASSERT_GT(test_data_[index].seq_num, test_data_[index - 1].seq_num);
-      }
-      db_->ReleaseSnapshot(snap);
-    } else {
-      ASSERT_OK(db_->Put(write_opts, cfh, test_data_[index].key,
-                         test_data_[index].value));
-    }
-  }
-
-  void AssertVisibility(int ts, SequenceNumber seq,
-                        std::vector<Status> statuses) {
-    ASSERT_EQ(kTestDataSize, statuses.size());
-    for (int i = 0; i < kTestDataSize; i++) {
-      if (test_data_[i].seq_num <= seq && test_data_[i].ts <= ts) {
-        ASSERT_OK(statuses[i]);
-      } else {
-        ASSERT_TRUE(statuses[i].IsNotFound());
-      }
-    }
-  }
-
-  std::vector<Slice> GetKeys() {
-    std::vector<Slice> ret(kTestDataSize);
-    for (int i = 0; i < kTestDataSize; i++) {
-      ret[i] = test_data_[i].key;
-    }
-    return ret;
-  }
-
-  void VerifyDefaultCF(int ts, const Snapshot* snap = nullptr) {
-    ReadOptions read_opts;
-    std::string read_ts = Timestamp(ts, 0);
-    Slice read_ts_slice = read_ts;
-    read_opts.timestamp = &read_ts_slice;
-    read_opts.snapshot = snap;
-
-    ColumnFamilyHandle* cfh = db_->DefaultColumnFamily();
-    std::vector<ColumnFamilyHandle*> cfs(kTestDataSize, cfh);
-    SequenceNumber seq =
-        snap ? snap->GetSequenceNumber() : kMaxSequenceNumber - 1;
-
-    // There're several MultiGet interfaces with not exactly the same
-    // implementations, query data with all of them.
-    auto keys = GetKeys();
-    std::vector<std::string> values;
-    auto s1 = db_->MultiGet(read_opts, cfs, keys, &values);
-    AssertVisibility(ts, seq, s1);
-
-    auto s2 = db_->MultiGet(read_opts, keys, &values);
-    AssertVisibility(ts, seq, s2);
-
-    std::vector<std::string> timestamps;
-    auto s3 = db_->MultiGet(read_opts, cfs, keys, &values, &timestamps);
-    AssertVisibility(ts, seq, s3);
-
-    auto s4 = db_->MultiGet(read_opts, keys, &values, &timestamps);
-    AssertVisibility(ts, seq, s4);
-
-    std::vector<PinnableSlice> values_ps5(kTestDataSize);
-    std::vector<Status> s5(kTestDataSize);
-    db_->MultiGet(read_opts, cfh, kTestDataSize, keys.data(), values_ps5.data(),
-                  s5.data());
-    AssertVisibility(ts, seq, s5);
-
-    std::vector<PinnableSlice> values_ps6(kTestDataSize);
-    std::vector<Status> s6(kTestDataSize);
-    std::vector<std::string> timestamps_array(kTestDataSize);
-    db_->MultiGet(read_opts, cfh, kTestDataSize, keys.data(), values_ps6.data(),
-                  timestamps_array.data(), s6.data());
-    AssertVisibility(ts, seq, s6);
-
-    std::vector<PinnableSlice> values_ps7(kTestDataSize);
-    std::vector<Status> s7(kTestDataSize);
-    db_->MultiGet(read_opts, kTestDataSize, cfs.data(), keys.data(),
-                  values_ps7.data(), s7.data());
-    AssertVisibility(ts, seq, s7);
-
-    std::vector<PinnableSlice> values_ps8(kTestDataSize);
-    std::vector<Status> s8(kTestDataSize);
-    db_->MultiGet(read_opts, kTestDataSize, cfs.data(), keys.data(),
-                  values_ps8.data(), timestamps_array.data(), s8.data());
-    AssertVisibility(ts, seq, s8);
-  }
-
-  void VerifyDefaultCF(const Snapshot* snap = nullptr) {
-    for (int i = 0; i <= kTestDataSize; i++) {
-      VerifyDefaultCF(i, snap);
-    }
-  }
+  DataVisibilityTest() : DBBasicTestWithTimestampBase("data_visibility_test") {}
 };
-constexpr int DataVisibilityTest::kTestDataSize;
 
 // Application specifies timestamp but not snapshot.
 //           reader              writer
@@ -1351,153 +906,6 @@ TEST_F(DataVisibilityTest, RangeScanWithSnapshot) {
   Close();
 }
 
-// Application specifies both timestamp and snapshot.
-// Query each combination and make sure for MultiGet key <k, t1, s1>, only
-// return keys that ts>=t1 AND seq>=s1.
-TEST_F(DataVisibilityTest, MultiGetWithTimestamp) {
-  Options options = CurrentOptions();
-  const size_t kTimestampSize = Timestamp(0, 0).size();
-  TestComparator test_cmp(kTimestampSize);
-  options.comparator = &test_cmp;
-  DestroyAndReopen(options);
-
-  const Snapshot* snap0 = db_->GetSnapshot();
-  PutTestData(0);
-  VerifyDefaultCF();
-  VerifyDefaultCF(snap0);
-
-  const Snapshot* snap1 = db_->GetSnapshot();
-  PutTestData(1);
-  VerifyDefaultCF();
-  VerifyDefaultCF(snap0);
-  VerifyDefaultCF(snap1);
-
-  Flush();
-
-  const Snapshot* snap2 = db_->GetSnapshot();
-  PutTestData(2);
-  VerifyDefaultCF();
-  VerifyDefaultCF(snap0);
-  VerifyDefaultCF(snap1);
-  VerifyDefaultCF(snap2);
-
-  db_->ReleaseSnapshot(snap0);
-  db_->ReleaseSnapshot(snap1);
-  db_->ReleaseSnapshot(snap2);
-
-  Close();
-}
-
-// Application specifies timestamp but not snapshot.
-//           reader              writer
-//                               ts'=0, 1
-//           ts=3
-//           seq=10
-//                               seq'=11, 12
-//                               write finishes
-//         MultiGet(ts,seq)
-// For MultiGet <k, t1, s1>, only return keys that ts>=t1 AND seq>=s1.
-TEST_F(DataVisibilityTest, MultiGetWithoutSnapshot) {
-  Options options = CurrentOptions();
-  const size_t kTimestampSize = Timestamp(0, 0).size();
-  TestComparator test_cmp(kTimestampSize);
-  options.comparator = &test_cmp;
-  DestroyAndReopen(options);
-
-  SyncPoint::GetInstance()->DisableProcessing();
-  SyncPoint::GetInstance()->LoadDependency({
-      {"DBImpl::MultiGet:AfterGetSeqNum1",
-       "DataVisibilityTest::MultiGetWithoutSnapshot:BeforePut"},
-      {"DataVisibilityTest::MultiGetWithoutSnapshot:AfterPut",
-       "DBImpl::MultiGet:AfterGetSeqNum2"},
-  });
-  SyncPoint::GetInstance()->EnableProcessing();
-  port::Thread writer_thread([this]() {
-    TEST_SYNC_POINT("DataVisibilityTest::MultiGetWithoutSnapshot:BeforePut");
-    PutTestData(0);
-    PutTestData(1);
-    TEST_SYNC_POINT("DataVisibilityTest::MultiGetWithoutSnapshot:AfterPut");
-  });
-
-  ReadOptions read_opts;
-  std::string read_ts = Timestamp(kTestDataSize, 0);
-  Slice read_ts_slice = read_ts;
-  read_opts.timestamp = &read_ts_slice;
-  auto keys = GetKeys();
-  std::vector<std::string> values;
-  auto ss = db_->MultiGet(read_opts, keys, &values);
-
-  writer_thread.join();
-  for (auto s : ss) {
-    ASSERT_TRUE(s.IsNotFound());
-  }
-  VerifyDefaultCF();
-  Close();
-}
-
-TEST_F(DataVisibilityTest, MultiGetCrossCF) {
-  Options options = CurrentOptions();
-  const size_t kTimestampSize = Timestamp(0, 0).size();
-  TestComparator test_cmp(kTimestampSize);
-  options.comparator = &test_cmp;
-  DestroyAndReopen(options);
-
-  CreateAndReopenWithCF({"second"}, options);
-  ColumnFamilyHandle* second_cf = handles_[1];
-
-  const Snapshot* snap0 = db_->GetSnapshot();
-  PutTestData(0);
-  PutTestData(0, second_cf);
-  VerifyDefaultCF();
-  VerifyDefaultCF(snap0);
-
-  const Snapshot* snap1 = db_->GetSnapshot();
-  PutTestData(1);
-  PutTestData(1, second_cf);
-  VerifyDefaultCF();
-  VerifyDefaultCF(snap0);
-  VerifyDefaultCF(snap1);
-
-  Flush();
-
-  const Snapshot* snap2 = db_->GetSnapshot();
-  PutTestData(2);
-  PutTestData(2, second_cf);
-  VerifyDefaultCF();
-  VerifyDefaultCF(snap0);
-  VerifyDefaultCF(snap1);
-  VerifyDefaultCF(snap2);
-
-  ReadOptions read_opts;
-  std::string read_ts = Timestamp(kTestDataSize, 0);
-  Slice read_ts_slice = read_ts;
-  read_opts.timestamp = &read_ts_slice;
-  read_opts.snapshot = snap1;
-  auto keys = GetKeys();
-  auto keys2 = GetKeys();
-  keys.insert(keys.end(), keys2.begin(), keys2.end());
-  std::vector<ColumnFamilyHandle*> cfs(kTestDataSize,
-                                       db_->DefaultColumnFamily());
-  std::vector<ColumnFamilyHandle*> cfs2(kTestDataSize, second_cf);
-  cfs.insert(cfs.end(), cfs2.begin(), cfs2.end());
-
-  std::vector<std::string> values;
-  auto ss = db_->MultiGet(read_opts, cfs, keys, &values);
-  for (int i = 0; i < 2 * kTestDataSize; i++) {
-    if (i % 3 == 0) {
-      // only the first key for each column family should be returned
-      ASSERT_OK(ss[i]);
-    } else {
-      ASSERT_TRUE(ss[i].IsNotFound());
-    }
-  }
-
-  db_->ReleaseSnapshot(snap0);
-  db_->ReleaseSnapshot(snap1);
-  db_->ReleaseSnapshot(snap2);
-  Close();
-}
-
 class DBBasicTestWithTimestampCompressionSettings
     : public DBBasicTestWithTimestampBase,
       public testing::WithParamInterface<
@@ -1806,9 +1214,9 @@ TEST_P(DBBasicTestWithTimestampCompressionSettings, PutAndGetWithCompaction) {
           // at higher levels.
           CompactionOptions compact_opt;
           compact_opt.compression = kNoCompression;
-          ASSERT_OK(db_->CompactFiles(compact_opt, handles_[cf],
-                                      collector->GetFlushedFiles(),
-                                      static_cast<int>(kNumTimestamps - i)));
+          db_->CompactFiles(compact_opt, handles_[cf],
+                            collector->GetFlushedFiles(),
+                            static_cast<int>(kNumTimestamps - i));
           collector->ClearFlushedFiles();
         }
       }
@@ -1897,7 +1305,7 @@ TEST_F(DBBasicTestWithTimestamp, BatchWriteAndMultiGet) {
             batch.Put(handles_[cf], Key1(j),
                       "value_" + std::to_string(j) + "_" + std::to_string(i)));
       }
-      ASSERT_OK(batch.AssignTimestamp(write_ts));
+      batch.AssignTimestamp(write_ts);
       ASSERT_OK(db_->Write(wopts, &batch));
 
       verify_records_func(i, handles_[cf]);

db/db_write_test.cc

@@ -168,8 +168,6 @@ TEST_P(DBWriteTest, WriteThreadHangOnWriteStall) {
   std::atomic<int> thread_num(0);
   port::Mutex mutex;
   port::CondVar cv(&mutex);
-  // Guarded by mutex
-  int writers = 0;
 
   Reopen(options);
 
@@ -189,7 +187,6 @@ TEST_P(DBWriteTest, WriteThreadHangOnWriteStall) {
   };
   std::function<void(void *)> unblock_main_thread_func = [&](void *) {
     mutex.Lock();
-    ++writers;
     cv.SignalAll();
     mutex.Unlock();
   };
@@ -228,18 +225,18 @@ TEST_P(DBWriteTest, WriteThreadHangOnWriteStall) {
   mutex.Lock();
   // First leader
   threads.emplace_back(write_slowdown_func);
-  while (writers != 1) {
-    cv.Wait();
-  }
+  cv.Wait();
   // Second leader. Will stall writes
   threads.emplace_back(write_slowdown_func);
+  cv.Wait();
   threads.emplace_back(write_no_slowdown_func);
+  cv.Wait();
   threads.emplace_back(write_slowdown_func);
+  cv.Wait();
   threads.emplace_back(write_no_slowdown_func);
+  cv.Wait();
   threads.emplace_back(write_slowdown_func);
-  while (writers != 6) {
-    cv.Wait();
-  }
+  cv.Wait();
   mutex.Unlock();
 
   TEST_SYNC_POINT("DBWriteTest::WriteThreadHangOnWriteStall:1");
@@ -253,14 +250,12 @@ TEST_P(DBWriteTest, WriteThreadHangOnWriteStall) {
   for (auto& t : threads) {
     t.join();
   }
-  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->DisableProcessing();
-  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->ClearAllCallBacks();
 }
 
 TEST_P(DBWriteTest, IOErrorOnWALWritePropagateToWriteThreadFollower) {
   constexpr int kNumThreads = 5;
   std::unique_ptr<FaultInjectionTestEnv> mock_env(
-      new FaultInjectionTestEnv(env_));
+      new FaultInjectionTestEnv(Env::Default()));
   Options options = GetOptions();
   options.env = mock_env.get();
   Reopen(options);
@@ -329,7 +324,7 @@ TEST_P(DBWriteTest, ManualWalFlushInEffect) {
 
 TEST_P(DBWriteTest, IOErrorOnWALWriteTriggersReadOnlyMode) {
   std::unique_ptr<FaultInjectionTestEnv> mock_env(
-      new FaultInjectionTestEnv(env_));
+      new FaultInjectionTestEnv(Env::Default()));
   Options options = GetOptions();
   options.env = mock_env.get();
   Reopen(options);
@@ -361,7 +356,7 @@ TEST_P(DBWriteTest, IOErrorOnWALWriteTriggersReadOnlyMode) {
 TEST_P(DBWriteTest, IOErrorOnSwitchMemtable) {
   Random rnd(301);
   std::unique_ptr<FaultInjectionTestEnv> mock_env(
-      new FaultInjectionTestEnv(env_));
+      new FaultInjectionTestEnv(Env::Default()));
   Options options = GetOptions();
   options.env = mock_env.get();
   options.writable_file_max_buffer_size = 4 * 1024 * 1024;

db/dbformat.cc

@@ -49,8 +49,7 @@ EntryType GetEntryType(ValueType value_type) {
 
 bool ParseFullKey(const Slice& internal_key, FullKey* fkey) {
   ParsedInternalKey ikey;
-  if (!ParseInternalKey(internal_key, &ikey, false /*log_err_key */)
-           .ok()) {  // TODO
+  if (!ParseInternalKey(internal_key, &ikey)) {
     return false;
   }
   fkey->user_key = ikey.user_key;
@@ -78,18 +77,12 @@ void AppendInternalKeyFooter(std::string* result, SequenceNumber s,
   PutFixed64(result, PackSequenceAndType(s, t));
 }
 
-std::string ParsedInternalKey::DebugString(bool log_err_key, bool hex) const {
-  std::string result = "'";
-  if (log_err_key) {
-    result += user_key.ToString(hex);
-  } else {
-    result += "<redacted>";
-  }
-
+std::string ParsedInternalKey::DebugString(bool hex) const {
   char buf[50];
   snprintf(buf, sizeof(buf), "' seq:%" PRIu64 ", type:%d", sequence,
            static_cast<int>(type));
-
+  std::string result = "'";
+  result += user_key.ToString(hex);
   result += buf;
   return result;
 }
@@ -97,8 +90,8 @@ std::string ParsedInternalKey::DebugString(bool log_err_key, bool hex) const {
 std::string InternalKey::DebugString(bool hex) const {
   std::string result;
   ParsedInternalKey parsed;
-  if (ParseInternalKey(rep_, &parsed, false /* log_err_key */).ok()) {
-    result = parsed.DebugString(true /* log_err_key */, hex);  // TODO
+  if (ParseInternalKey(rep_, &parsed)) {
+    result = parsed.DebugString(hex);
   } else {
     result = "(bad)";
     result.append(EscapeString(rep_));

db/dbformat.h

@@ -96,8 +96,6 @@ static const SequenceNumber kMaxSequenceNumber = ((0x1ull << 56) - 1);
 
 static const SequenceNumber kDisableGlobalSequenceNumber = port::kMaxUint64;
 
-constexpr uint64_t kNumInternalBytes = 8;
-
 // The data structure that represents an internal key in the way that user_key,
 // sequence number and type are stored in separated forms.
 struct ParsedInternalKey {
@@ -106,30 +104,23 @@ struct ParsedInternalKey {
   ValueType type;
 
   ParsedInternalKey()
-      : sequence(kMaxSequenceNumber),
-        type(kTypeDeletion)  // Make code analyzer happy
-  {}                         // Intentionally left uninitialized (for speed)
+      : sequence(kMaxSequenceNumber)  // Make code analyzer happy
+  {}  // Intentionally left uninitialized (for speed)
   // u contains timestamp if user timestamp feature is enabled.
   ParsedInternalKey(const Slice& u, const SequenceNumber& seq, ValueType t)
       : user_key(u), sequence(seq), type(t) {}
-  std::string DebugString(bool log_err_key, bool hex) const;
+  std::string DebugString(bool hex = false) const;
 
   void clear() {
     user_key.clear();
     sequence = 0;
     type = kTypeDeletion;
   }
-
-  void SetTimestamp(const Slice& ts) {
-    assert(ts.size() <= user_key.size());
-    const char* addr = user_key.data() - ts.size();
-    memcpy(const_cast<char*>(addr), ts.data(), ts.size());
-  }
 };
 
 // Return the length of the encoding of "key".
 inline size_t InternalKeyEncodingLength(const ParsedInternalKey& key) {
-  return key.user_key.size() + kNumInternalBytes;
+  return key.user_key.size() + 8;
 }
 
 // Pack a sequence number and a ValueType into a uint64_t
@@ -171,20 +162,19 @@ extern void AppendInternalKeyFooter(std::string* result, SequenceNumber s,
 // stores the parsed data in "*result", and returns true.
 //
 // On error, returns false, leaves "*result" in an undefined state.
-extern Status ParseInternalKey(const Slice& internal_key,
-                               ParsedInternalKey* result, bool log_err_key);
+extern bool ParseInternalKey(const Slice& internal_key,
+                             ParsedInternalKey* result);
 
 // Returns the user key portion of an internal key.
 inline Slice ExtractUserKey(const Slice& internal_key) {
-  assert(internal_key.size() >= kNumInternalBytes);
-  return Slice(internal_key.data(), internal_key.size() - kNumInternalBytes);
+  assert(internal_key.size() >= 8);
+  return Slice(internal_key.data(), internal_key.size() - 8);
 }
 
 inline Slice ExtractUserKeyAndStripTimestamp(const Slice& internal_key,
                                              size_t ts_sz) {
-  assert(internal_key.size() >= kNumInternalBytes + ts_sz);
-  return Slice(internal_key.data(),
-               internal_key.size() - kNumInternalBytes - ts_sz);
+  assert(internal_key.size() >= 8 + ts_sz);
+  return Slice(internal_key.data(), internal_key.size() - 8 - ts_sz);
 }
 
 inline Slice StripTimestampFromUserKey(const Slice& user_key, size_t ts_sz) {
@@ -198,9 +188,9 @@ inline Slice ExtractTimestampFromUserKey(const Slice& user_key, size_t ts_sz) {
 }
 
 inline uint64_t ExtractInternalKeyFooter(const Slice& internal_key) {
-  assert(internal_key.size() >= kNumInternalBytes);
+  assert(internal_key.size() >= 8);
   const size_t n = internal_key.size();
-  return DecodeFixed64(internal_key.data() + n - kNumInternalBytes);
+  return DecodeFixed64(internal_key.data() + n - 8);
 }
 
 inline ValueType ExtractValueType(const Slice& internal_key) {
@@ -291,8 +281,7 @@ class InternalKey {
 
   bool Valid() const {
     ParsedInternalKey parsed;
-    return (ParseInternalKey(Slice(rep_), &parsed, false /* log_err_key */)
-                .ok());  // TODO
+    return ParseInternalKey(Slice(rep_), &parsed);
   }
 
   void DecodeFrom(const Slice& s) { rep_.assign(s.data(), s.size()); }
@@ -325,7 +314,7 @@ class InternalKey {
     AppendInternalKeyFooter(&rep_, s, t);
   }
 
-  std::string DebugString(bool hex) const;
+  std::string DebugString(bool hex = false) const;
 };
 
 inline int InternalKeyComparator::Compare(const InternalKey& a,
@@ -333,47 +322,36 @@ inline int InternalKeyComparator::Compare(const InternalKey& a,
   return Compare(a.Encode(), b.Encode());
 }
 
-inline Status ParseInternalKey(const Slice& internal_key,
-                               ParsedInternalKey* result, bool log_err_key) {
+inline bool ParseInternalKey(const Slice& internal_key,
+                             ParsedInternalKey* result) {
   const size_t n = internal_key.size();
-
-  if (n < kNumInternalBytes) {
-    return Status::Corruption("Corrupted Key: Internal Key too small. Size=" +
-                              std::to_string(n) + ". ");
-  }
-
-  uint64_t num = DecodeFixed64(internal_key.data() + n - kNumInternalBytes);
+  if (n < 8) return false;
+  uint64_t num = DecodeFixed64(internal_key.data() + n - 8);
   unsigned char c = num & 0xff;
   result->sequence = num >> 8;
   result->type = static_cast<ValueType>(c);
   assert(result->type <= ValueType::kMaxValue);
-  result->user_key = Slice(internal_key.data(), n - kNumInternalBytes);
-
-  if (IsExtendedValueType(result->type)) {
-    return Status::OK();
-  } else {
-    return Status::Corruption("Corrupted Key",
-                              result->DebugString(log_err_key, true));
-  }
+  result->user_key = Slice(internal_key.data(), n - 8);
+  return IsExtendedValueType(result->type);
 }
 
 // Update the sequence number in the internal key.
 // Guarantees not to invalidate ikey.data().
 inline void UpdateInternalKey(std::string* ikey, uint64_t seq, ValueType t) {
   size_t ikey_sz = ikey->size();
-  assert(ikey_sz >= kNumInternalBytes);
+  assert(ikey_sz >= 8);
   uint64_t newval = (seq << 8) | t;
 
   // Note: Since C++11, strings are guaranteed to be stored contiguously and
   // string::operator[]() is guaranteed not to change ikey.data().
-  EncodeFixed64(&(*ikey)[ikey_sz - kNumInternalBytes], newval);
+  EncodeFixed64(&(*ikey)[ikey_sz - 8], newval);
 }
 
 // Get the sequence number from the internal key
 inline uint64_t GetInternalKeySeqno(const Slice& internal_key) {
   const size_t n = internal_key.size();
-  assert(n >= kNumInternalBytes);
-  uint64_t num = DecodeFixed64(internal_key.data() + n - kNumInternalBytes);
+  assert(n >= 8);
+  uint64_t num = DecodeFixed64(internal_key.data() + n - 8);
   return num >> 8;
 }
 
@@ -412,8 +390,8 @@ class IterKey {
     if (IsUserKey()) {
       return Slice(key_, key_size_);
     } else {
-      assert(key_size_ >= kNumInternalBytes);
-      return Slice(key_, key_size_ - kNumInternalBytes);
+      assert(key_size_ >= 8);
+      return Slice(key_, key_size_ - 8);
     }
   }
 
@@ -471,9 +449,9 @@ class IterKey {
   // and returns a Slice referencing the new copy.
   Slice SetInternalKey(const Slice& key, ParsedInternalKey* ikey) {
     size_t key_n = key.size();
-    assert(key_n >= kNumInternalBytes);
+    assert(key_n >= 8);
     SetInternalKey(key);
-    ikey->user_key = Slice(key_, key_n - kNumInternalBytes);
+    ikey->user_key = Slice(key_, key_n - 8);
     return Slice(key_, key_n);
   }
 
@@ -488,16 +466,11 @@ class IterKey {
 
   // Update the sequence number in the internal key.  Guarantees not to
   // invalidate slices to the key (and the user key).
-  void UpdateInternalKey(uint64_t seq, ValueType t, const Slice* ts = nullptr) {
+  void UpdateInternalKey(uint64_t seq, ValueType t) {
     assert(!IsKeyPinned());
-    assert(key_size_ >= kNumInternalBytes);
-    if (ts) {
-      assert(key_size_ >= kNumInternalBytes + ts->size());
-      memcpy(&buf_[key_size_ - kNumInternalBytes - ts->size()], ts->data(),
-             ts->size());
-    }
+    assert(key_size_ >= 8);
     uint64_t newval = (seq << 8) | t;
-    EncodeFixed64(&buf_[key_size_ - kNumInternalBytes], newval);
+    EncodeFixed64(&buf_[key_size_ - 8], newval);
   }
 
   bool IsKeyPinned() const { return (key_ != buf_); }
@@ -702,10 +675,8 @@ inline int InternalKeyComparator::Compare(const Slice& akey,
   //    decreasing type (though sequence# should be enough to disambiguate)
   int r = user_comparator_.Compare(ExtractUserKey(akey), ExtractUserKey(bkey));
   if (r == 0) {
-    const uint64_t anum =
-        DecodeFixed64(akey.data() + akey.size() - kNumInternalBytes);
-    const uint64_t bnum =
-        DecodeFixed64(bkey.data() + bkey.size() - kNumInternalBytes);
+    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) {
@@ -723,10 +694,8 @@ inline int InternalKeyComparator::CompareKeySeq(const Slice& akey,
   int r = user_comparator_.Compare(ExtractUserKey(akey), ExtractUserKey(bkey));
   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() - kNumInternalBytes) >> 8;
-    const uint64_t bnum =
-        DecodeFixed64(bkey.data() + bkey.size() - kNumInternalBytes) >> 8;
+    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) {

db/dbformat_test.cc

@@ -8,6 +8,7 @@
 // found in the LICENSE file. See the AUTHORS file for names of contributors.
 
 #include "db/dbformat.h"
+#include "logging/logging.h"
 #include "test_util/testharness.h"
 
 namespace ROCKSDB_NAMESPACE {
@@ -40,12 +41,12 @@ static void TestKey(const std::string& key,
   Slice in(encoded);
   ParsedInternalKey decoded("", 0, kTypeValue);
 
-  ASSERT_OK(ParseInternalKey(in, &decoded, true /* log_err_key */));
+  ASSERT_TRUE(ParseInternalKey(in, &decoded));
   ASSERT_EQ(key, decoded.user_key.ToString());
   ASSERT_EQ(seq, decoded.sequence);
   ASSERT_EQ(vt, decoded.type);
 
-  ASSERT_NOK(ParseInternalKey(Slice("bar"), &decoded, true /* log_err_key */));
+  ASSERT_TRUE(!ParseInternalKey(Slice("bar"), &decoded));
 }
 
 class FormatTest : public testing::Test {};
@@ -185,7 +186,7 @@ TEST_F(FormatTest, UpdateInternalKey) {
 
   Slice in(ikey);
   ParsedInternalKey decoded;
-  ASSERT_OK(ParseInternalKey(in, &decoded, true /* log_err_key */));
+  ASSERT_TRUE(ParseInternalKey(in, &decoded));
   ASSERT_EQ(user_key, decoded.user_key.ToString());
   ASSERT_EQ(new_seq, decoded.sequence);
   ASSERT_EQ(new_val_type, decoded.type);

db/deletefile_test.cc

@@ -112,7 +112,7 @@ class DeleteFileTest : public DBTestBase {
       uint64_t number;
       FileType type;
       if (ParseFileName(file, &number, &type)) {
-        log_cnt += (type == kWalFile);
+        log_cnt += (type == kLogFile);
         sst_cnt += (type == kTableFile);
         manifest_cnt += (type == kDescriptorFile);
       }

db/error_handler.cc

@@ -338,14 +338,14 @@ Status ErrorHandler::SetBGError(const IOStatus& bg_io_err,
   }
   if (BackgroundErrorReason::kManifestWrite == reason) {
     // Always returns ok
-    db_->DisableFileDeletionsWithLock().PermitUncheckedError();
+    db_->DisableFileDeletionsWithLock();
   }
 
   Status new_bg_io_err = bg_io_err;
   Status s;
   DBRecoverContext context;
   if (bg_io_err.GetDataLoss()) {
-    // First, data loss is treated as unrecoverable error. So it can directly
+    // FIrst, data loss is treated as unrecoverable error. So it can directly
     // overwrite any existing bg_error_.
     bool auto_recovery = false;
     Status bg_err(new_bg_io_err, Status::Severity::kUnrecoverableError);