andreacavalli/rocksdb
0
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Apply formatter on recent 45 commits. (#5827)

Browse Source 
Summary:
Some recent commits might not have passed through the formatter. I formatted recent 45 commits. The script hangs for more commits so I stopped there.
Pull Request resolved: https://github.com/facebook/rocksdb/pull/5827

Test Plan: Run all existing tests.

Differential Revision: D17483727

fbshipit-source-id: af23113ee63015d8a43d89a3bc2c1056189afe8f
This commit is contained in:
sdong 2019-09-19 12:32:33 -07:00 committed by Facebook Github Bot
parent 6ec6a4a9a4
commit c06b54d0c6
26 changed files with 271 additions and 280 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
db/arena_wrapped_db_iter.cc
View File

@ -19,7 +19,7 @@
namespace rocksdb {
Status ArenaWrappedDBIter::GetProperty(std::string prop_name,
std::string* prop) {
std::string* prop) {
if (prop_name == "rocksdb.iterator.super-version-number") {
// First try to pass the value returned from inner iterator.
if (!db_iter_->GetProperty(prop_name, prop).ok()) {

2
db/compaction/compaction_iterator.cc
View File

@ -230,7 +230,7 @@ void CompactionIterator::NextFromInput() {
valid_ = false;
while (!valid_ && input_->Valid() && !IsPausingManualCompaction() &&
!IsShuttingDown()) {
!IsShuttingDown()) {
key_ = input_->key();
value_ = input_->value();
iter_stats_.num_input_records++;

50
db/compaction/compaction_iterator.h
View File

@ -59,32 +59,32 @@ class CompactionIterator {
const Compaction* compaction_;
};
CompactionIterator(InternalIterator* input, const Comparator* cmp,
MergeHelper* merge_helper, SequenceNumber last_sequence,
std::vector<SequenceNumber>* snapshots,
SequenceNumber earliest_write_conflict_snapshot,
const SnapshotChecker* snapshot_checker, Env* env,
bool report_detailed_time, bool expect_valid_internal_key,
CompactionRangeDelAggregator* range_del_agg,
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<bool>* manual_compaction_paused = nullptr);
CompactionIterator(
InternalIterator* input, const Comparator* cmp, MergeHelper* merge_helper,
SequenceNumber last_sequence, std::vector<SequenceNumber>* snapshots,
SequenceNumber earliest_write_conflict_snapshot,
const SnapshotChecker* snapshot_checker, Env* env,
bool report_detailed_time, bool expect_valid_internal_key,
CompactionRangeDelAggregator* range_del_agg,
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<bool>* manual_compaction_paused = nullptr);
// Constructor with custom CompactionProxy, used for tests.
CompactionIterator(InternalIterator* input, const Comparator* cmp,
MergeHelper* merge_helper, SequenceNumber last_sequence,
std::vector<SequenceNumber>* snapshots,
SequenceNumber earliest_write_conflict_snapshot,
const SnapshotChecker* snapshot_checker, Env* env,
bool report_detailed_time, bool expect_valid_internal_key,
CompactionRangeDelAggregator* range_del_agg,
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<bool>* manual_compaction_paused = nullptr);
CompactionIterator(
InternalIterator* input, const Comparator* cmp, MergeHelper* merge_helper,
SequenceNumber last_sequence, std::vector<SequenceNumber>* snapshots,
SequenceNumber earliest_write_conflict_snapshot,
const SnapshotChecker* snapshot_checker, Env* env,
bool report_detailed_time, bool expect_valid_internal_key,
CompactionRangeDelAggregator* range_del_agg,
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<bool>* manual_compaction_paused = nullptr);
~CompactionIterator();
@ -231,7 +231,7 @@ class CompactionIterator {
bool IsPausingManualCompaction() {
// This is a best-effort facility, so memory_order_relaxed is sufficient.
return manual_compaction_paused_ &&
manual_compaction_paused_->load(std::memory_order_relaxed);
manual_compaction_paused_->load(std::memory_order_relaxed);
}
};
} // namespace rocksdb

14
db/compaction/compaction_job.cc
View File

@ -870,9 +870,10 @@ void CompactionJob::ProcessKeyValueCompaction(SubcompactionState* sub_compact) {
db_options_.statistics.get());
TEST_SYNC_POINT("CompactionJob::Run():Inprogress");
TEST_SYNC_POINT_CALLBACK("CompactionJob::Run():PausingManualCompaction:1",
reinterpret_cast<void *>(
const_cast<std::atomic<bool> *>(manual_compaction_paused_)));
TEST_SYNC_POINT_CALLBACK(
"CompactionJob::Run():PausingManualCompaction:1",
reinterpret_cast<void*>(
const_cast<std::atomic<bool>*>(manual_compaction_paused_)));
Slice* start = sub_compact->start;
Slice* end = sub_compact->end;
@ -954,9 +955,10 @@ void CompactionJob::ProcessKeyValueCompaction(SubcompactionState* sub_compact) {
input_status = input->status();
output_file_ended = true;
}
TEST_SYNC_POINT_CALLBACK("CompactionJob::Run():PausingManualCompaction:2",
reinterpret_cast<void *>(
const_cast<std::atomic<bool> *>(manual_compaction_paused_)));
TEST_SYNC_POINT_CALLBACK(
"CompactionJob::Run():PausingManualCompaction:2",
reinterpret_cast<void*>(
const_cast<std::atomic<bool>*>(manual_compaction_paused_)));
c_iter->Next();
if (c_iter->status().IsManualCompactionPaused()) {
break;

32
db/compaction/compaction_job.h
View File

@ -62,21 +62,23 @@ class VersionSet;
// if needed.
class CompactionJob {
public:
CompactionJob(
int job_id, Compaction* compaction, const ImmutableDBOptions& db_options,
const EnvOptions env_options, VersionSet* versions,
const std::atomic<bool>* shutting_down,
const SequenceNumber preserve_deletes_seqnum, LogBuffer* log_buffer,
Directory* db_directory, Directory* output_directory, Statistics* stats,
InstrumentedMutex* db_mutex, ErrorHandler* db_error_handler,
std::vector<SequenceNumber> existing_snapshots,
SequenceNumber earliest_write_conflict_snapshot,
const SnapshotChecker* snapshot_checker,
std::shared_ptr<Cache> table_cache, EventLogger* event_logger,
bool paranoid_file_checks, bool measure_io_stats,
const std::string& dbname, CompactionJobStats* compaction_job_stats,
Env::Priority thread_pri,
const std::atomic<bool>* manual_compaction_paused = nullptr);
CompactionJob(int job_id, Compaction* compaction,
const ImmutableDBOptions& db_options,
const EnvOptions env_options, VersionSet* versions,
const std::atomic<bool>* shutting_down,
const SequenceNumber preserve_deletes_seqnum,
LogBuffer* log_buffer, Directory* db_directory,
Directory* output_directory, Statistics* stats,
InstrumentedMutex* db_mutex, ErrorHandler* db_error_handler,
std::vector<SequenceNumber> existing_snapshots,
SequenceNumber earliest_write_conflict_snapshot,
const SnapshotChecker* snapshot_checker,
std::shared_ptr<Cache> table_cache, EventLogger* event_logger,
bool paranoid_file_checks, bool measure_io_stats,
const std::string& dbname,
CompactionJobStats* compaction_job_stats,
Env::Priority thread_pri,
const std::atomic<bool>* manual_compaction_paused = nullptr);
~CompactionJob();

17
db/db_impl/db_impl_compaction_flush.cc
View File

@ -983,8 +983,7 @@ Status DBImpl::CompactFilesImpl(
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,
&manual_compaction_paused_);
&compaction_job_stats, Env::Priority::USER, &manual_compaction_paused_);
// Creating a compaction influences the compaction score because the score
// takes running compactions into account (by skipping files that are already
@ -2313,8 +2312,7 @@ void DBImpl::BackgroundCallCompaction(PrepickedCompaction* prepicked_compaction,
env_->SleepForMicroseconds(10000); // prevent hot loop
mutex_.Lock();
} else if (!s.ok() && !s.IsShutdownInProgress() &&
!s.IsManualCompactionPaused() &&
!s.IsColumnFamilyDropped()) {
!s.IsManualCompactionPaused() && !s.IsColumnFamilyDropped()) {
// Wait a little bit before retrying background compaction in
// case this is an environmental problem and we do not want to
// chew up resources for failed compactions for the duration of
@ -2332,11 +2330,10 @@ void DBImpl::BackgroundCallCompaction(PrepickedCompaction* prepicked_compaction,
env_->SleepForMicroseconds(1000000);
mutex_.Lock();
} else if (s.IsManualCompactionPaused()) {
ManualCompactionState *m = prepicked_compaction->manual_compaction_state;
ManualCompactionState* m = prepicked_compaction->manual_compaction_state;
assert(m);
ROCKS_LOG_BUFFER(&log_buffer, "[%s] [JOB %d] Manual compaction paused",
m->cfd->GetName().c_str(),
job_context.job_id);
m->cfd->GetName().c_str(), job_context.job_id);
}
ReleaseFileNumberFromPendingOutputs(pending_outputs_inserted_elem);
@ -2345,8 +2342,8 @@ void DBImpl::BackgroundCallCompaction(PrepickedCompaction* prepicked_compaction,
// have created (they might not be all recorded in job_context in case of a
// failure). Thus, we force full scan in FindObsoleteFiles()
FindObsoleteFiles(&job_context, !s.ok() && !s.IsShutdownInProgress() &&
!s.IsManualCompactionPaused() &&
!s.IsColumnFamilyDropped());
!s.IsManualCompactionPaused() &&
!s.IsColumnFamilyDropped());
TEST_SYNC_POINT("DBImpl::BackgroundCallCompaction:FoundObsoleteFiles");
// delete unnecessary files if any, this is done outside the mutex
@ -2430,7 +2427,7 @@ Status DBImpl::BackgroundCompaction(bool* made_progress,
if (shutting_down_.load(std::memory_order_acquire)) {
status = Status::ShutdownInProgress();
} else if (is_manual &&
manual_compaction_paused_.load(std::memory_order_acquire)) {
manual_compaction_paused_.load(std::memory_order_acquire)) {
status = Status::Incomplete(Status::SubCode::kManualCompactionPaused);
}
} else {

2
db/db_impl/db_impl_readonly.cc
View File

@ -3,8 +3,8 @@
// COPYING file in the root directory) and Apache 2.0 License
// (found in the LICENSE.Apache file in the root directory).
#include "db/arena_wrapped_db_iter.h"
#include "db/db_impl/db_impl_readonly.h"
#include "db/arena_wrapped_db_iter.h"
#include "db/compacted_db_impl.h"
#include "db/db_impl/db_impl.h"

9
db/db_iter.h
View File

@ -53,7 +53,7 @@ namespace rocksdb {
// combines multiple entries for the same userkey found in the DB
// representation into a single entry while accounting for sequence
// numbers, deletion markers, overwrites, etc.
class DBIter final: public Iterator {
class DBIter final : public Iterator {
public:
// The following is grossly complicated. TODO: clean it up
// Which direction is the iterator currently moving?
@ -66,10 +66,7 @@ class DBIter final: public Iterator {
// this->key().
// (2) When moving backwards, the internal iterator is positioned
// just before all entries whose user key == this->key().
enum Direction {
kForward,
kReverse
};
enum Direction { kForward, kReverse };
// LocalStatistics contain Statistics counters that will be aggregated per
// each iterator instance and then will be sent to the global statistics when
@ -148,7 +145,7 @@ class DBIter final: public Iterator {
bool Valid() const override { return valid_; }
Slice key() const override {
assert(valid_);
if(start_seqnum_ > 0) {
if (start_seqnum_ > 0) {
return saved_key_.GetInternalKey();
} else {
return saved_key_.GetUserKey();

16
db/db_test2.cc
View File

@ -2458,8 +2458,7 @@ TEST_F(DBTest2, PausingManualCompaction1) {
manual_compactions_paused = 0;
// Now make sure CompactFiles also not run
dbfull()->CompactFiles(rocksdb::CompactionOptions(),
files_before_compact, 0);
dbfull()->CompactFiles(rocksdb::CompactionOptions(), files_before_compact, 0);
// Wait for manual compaction to get scheduled and finish
dbfull()->TEST_WaitForCompact(true);
@ -2510,14 +2509,14 @@ TEST_F(DBTest2, PausingManualCompaction3) {
Random rnd(301);
auto generate_files = [&]() {
for (int i = 0; i < options.num_levels; i++) {
for (int j = 0; j < options.num_levels-i+1; j++) {
for (int j = 0; j < options.num_levels - i + 1; j++) {
for (int k = 0; k < 1000; k++) {
ASSERT_OK(Put(Key(k + j * 1000), RandomString(&rnd, 50)));
}
Flush();
}
for (int l = 1; l < options.num_levels-i; l++) {
for (int l = 1; l < options.num_levels - i; l++) {
MoveFilesToLevel(l);
}
}
@ -2530,9 +2529,8 @@ TEST_F(DBTest2, PausingManualCompaction3) {
#endif // !ROCKSDB_LITE
int run_manual_compactions = 0;
rocksdb::SyncPoint::GetInstance()->SetCallBack(
"CompactionJob::Run():PausingManualCompaction:1", [&](void* /*arg*/) {
run_manual_compactions++;
});
"CompactionJob::Run():PausingManualCompaction:1",
[&](void* /*arg*/) { run_manual_compactions++; });
rocksdb::SyncPoint::GetInstance()->EnableProcessing();
dbfull()->DisableManualCompaction();
@ -2565,14 +2563,14 @@ TEST_F(DBTest2, PausingManualCompaction4) {
Random rnd(301);
auto generate_files = [&]() {
for (int i = 0; i < options.num_levels; i++) {
for (int j = 0; j < options.num_levels-i+1; j++) {
for (int j = 0; j < options.num_levels - i + 1; j++) {
for (int k = 0; k < 1000; k++) {
ASSERT_OK(Put(Key(k + j * 1000), RandomString(&rnd, 50)));
}
Flush();
}
for (int l = 1; l < options.num_levels-i; l++) {
for (int l = 1; l < options.num_levels - i; l++) {
MoveFilesToLevel(l);
}
}

42
java/benchmark/src/main/java/org/rocksdb/benchmark/DbBenchmark.java
View File

@ -646,8 +646,8 @@ public class DbBenchmark {
currentTaskId++, randSeed_, num_, num_, writeOpt, 1));
break;
case "fillbatch":
tasks.add(new WriteSequentialTask(
currentTaskId++, randSeed_, num_, num_, writeOpt, 1000));
tasks.add(
new WriteSequentialTask(currentTaskId++, randSeed_, num_, num_, writeOpt, 1000));
break;
case "fillrandom":
tasks.add(new WriteRandomTask(
@ -901,27 +901,23 @@ public class DbBenchmark {
}
private enum Flag {
benchmarks(
Arrays.asList(
"fillseq",
"readrandom",
"fillrandom"),
"Comma-separated list of operations to run in the specified order\n" +
"\tActual benchmarks:\n" +
"\t\tfillseq -- write N values in sequential key order in async mode.\n" +
"\t\tfillrandom -- write N values in random key order in async mode.\n" +
"\t\tfillbatch -- write N/1000 batch where each batch has 1000 values\n" +
"\t\t in sequential key order in sync mode.\n" +
"\t\tfillsync -- write N/100 values in random key order in sync mode.\n" +
"\t\tfill100K -- write N/1000 100K values in random order in async mode.\n" +
"\t\treadseq -- read N times sequentially.\n" +
"\t\treadrandom -- read N times in random order.\n" +
"\t\treadhot -- read N times in random order from 1% section of DB.\n" +
"\t\treadwhilewriting -- measure the read performance of multiple readers\n" +
"\t\t with a bg single writer. The write rate of the bg\n" +
"\t\t is capped by --writes_per_second.\n" +
"\tMeta Operations:\n" +
"\t\tdelete -- delete DB") {
benchmarks(Arrays.asList("fillseq", "readrandom", "fillrandom"),
"Comma-separated list of operations to run in the specified order\n"
+ "\tActual benchmarks:\n"
+ "\t\tfillseq -- write N values in sequential key order in async mode.\n"
+ "\t\tfillrandom -- write N values in random key order in async mode.\n"
+ "\t\tfillbatch -- write N/1000 batch where each batch has 1000 values\n"
+ "\t\t in sequential key order in sync mode.\n"
+ "\t\tfillsync -- write N/100 values in random key order in sync mode.\n"
+ "\t\tfill100K -- write N/1000 100K values in random order in async mode.\n"
+ "\t\treadseq -- read N times sequentially.\n"
+ "\t\treadrandom -- read N times in random order.\n"
+ "\t\treadhot -- read N times in random order from 1% section of DB.\n"
+ "\t\treadwhilewriting -- measure the read performance of multiple readers\n"
+ "\t\t with a bg single writer. The write rate of the bg\n"
+ "\t\t is capped by --writes_per_second.\n"
+ "\tMeta Operations:\n"
+ "\t\tdelete -- delete DB") {
@Override public Object parseValue(String value) {
return new ArrayList<String>(Arrays.asList(value.split(",")));
}

109
java/rocksjni/sst_file_reader_iterator.cc
View File

@ -6,13 +6,13 @@
// This file implements the "bridge" between Java and C++ and enables
// calling c++ rocksdb::Iterator methods from Java side.
#include <jni.h>
#include <stdio.h>
#include <stdlib.h>
#include <jni.h>
#include "include/org_rocksdb_SstFileReaderIterator.h"
#include "rocksjni/portal.h"
#include "rocksdb/iterator.h"
#include "rocksjni/portal.h"
/*
* Class: org_rocksdb_SstFileReaderIterator
@ -22,9 +22,9 @@
void Java_org_rocksdb_SstFileReaderIterator_disposeInternal(JNIEnv* /*env*/,
jobject /*jobj*/,
jlong handle) {
auto* it = reinterpret_cast<rocksdb::Iterator*>(handle);
assert(it != nullptr);
delete it;
auto* it = reinterpret_cast<rocksdb::Iterator*>(handle);
assert(it != nullptr);
delete it;
}
/*
@ -35,7 +35,7 @@ void Java_org_rocksdb_SstFileReaderIterator_disposeInternal(JNIEnv* /*env*/,
jboolean Java_org_rocksdb_SstFileReaderIterator_isValid0(JNIEnv* /*env*/,
jobject /*jobj*/,
jlong handle) {
return reinterpret_cast<rocksdb::Iterator*>(handle)->Valid();
return reinterpret_cast<rocksdb::Iterator*>(handle)->Valid();
}
/*
@ -46,7 +46,7 @@ jboolean Java_org_rocksdb_SstFileReaderIterator_isValid0(JNIEnv* /*env*/,
void Java_org_rocksdb_SstFileReaderIterator_seekToFirst0(JNIEnv* /*env*/,
jobject /*jobj*/,
jlong handle) {
reinterpret_cast<rocksdb::Iterator*>(handle)->SeekToFirst();
reinterpret_cast<rocksdb::Iterator*>(handle)->SeekToFirst();
}
/*
@ -57,7 +57,7 @@ void Java_org_rocksdb_SstFileReaderIterator_seekToFirst0(JNIEnv* /*env*/,
void Java_org_rocksdb_SstFileReaderIterator_seekToLast0(JNIEnv* /*env*/,
jobject /*jobj*/,
jlong handle) {
reinterpret_cast<rocksdb::Iterator*>(handle)->SeekToLast();
reinterpret_cast<rocksdb::Iterator*>(handle)->SeekToLast();
}
/*
@ -65,9 +65,10 @@ void Java_org_rocksdb_SstFileReaderIterator_seekToLast0(JNIEnv* /*env*/,
* Method: next0
* Signature: (J)V
*/
void Java_org_rocksdb_SstFileReaderIterator_next0(JNIEnv* /*env*/, jobject /*jobj*/,
void Java_org_rocksdb_SstFileReaderIterator_next0(JNIEnv* /*env*/,
jobject /*jobj*/,
jlong handle) {
reinterpret_cast<rocksdb::Iterator*>(handle)->Next();
reinterpret_cast<rocksdb::Iterator*>(handle)->Next();
}
/*
@ -75,9 +76,10 @@ void Java_org_rocksdb_SstFileReaderIterator_next0(JNIEnv* /*env*/, jobject /*job
* Method: prev0
* Signature: (J)V
*/
void Java_org_rocksdb_SstFileReaderIterator_prev0(JNIEnv* /*env*/, jobject /*jobj*/,
void Java_org_rocksdb_SstFileReaderIterator_prev0(JNIEnv* /*env*/,
jobject /*jobj*/,
jlong handle) {
reinterpret_cast<rocksdb::Iterator*>(handle)->Prev();
reinterpret_cast<rocksdb::Iterator*>(handle)->Prev();
}
/*
@ -86,21 +88,21 @@ void Java_org_rocksdb_SstFileReaderIterator_prev0(JNIEnv* /*env*/, jobject /*job
* Signature: (J[BI)V
*/
void Java_org_rocksdb_SstFileReaderIterator_seek0(JNIEnv* env, jobject /*jobj*/,
jlong handle, jbyteArray jtarget,
jlong handle,
jbyteArray jtarget,
jint jtarget_len) {
jbyte* target = env->GetByteArrayElements(jtarget, nullptr);
if(target == nullptr) {
// exception thrown: OutOfMemoryError
return;
}
jbyte* target = env->GetByteArrayElements(jtarget, nullptr);
if (target == nullptr) {
// exception thrown: OutOfMemoryError
return;
}
rocksdb::Slice target_slice(
reinterpret_cast<char*>(target), jtarget_len);
rocksdb::Slice target_slice(reinterpret_cast<char*>(target), jtarget_len);
auto* it = reinterpret_cast<rocksdb::Iterator*>(handle);
it->Seek(target_slice);
auto* it = reinterpret_cast<rocksdb::Iterator*>(handle);
it->Seek(target_slice);
env->ReleaseByteArrayElements(jtarget, target, JNI_ABORT);
env->ReleaseByteArrayElements(jtarget, target, JNI_ABORT);
}
/*
@ -108,23 +110,23 @@ void Java_org_rocksdb_SstFileReaderIterator_seek0(JNIEnv* env, jobject /*jobj*/,
* Method: seekForPrev0
* Signature: (J[BI)V
*/
void Java_org_rocksdb_SstFileReaderIterator_seekForPrev0(JNIEnv* env, jobject /*jobj*/,
void Java_org_rocksdb_SstFileReaderIterator_seekForPrev0(JNIEnv* env,
jobject /*jobj*/,
jlong handle,
jbyteArray jtarget,
jint jtarget_len) {
jbyte* target = env->GetByteArrayElements(jtarget, nullptr);
if(target == nullptr) {
// exception thrown: OutOfMemoryError
return;
}
jbyte* target = env->GetByteArrayElements(jtarget, nullptr);
if (target == nullptr) {
// exception thrown: OutOfMemoryError
return;
}
rocksdb::Slice target_slice(
reinterpret_cast<char*>(target), jtarget_len);
rocksdb::Slice target_slice(reinterpret_cast<char*>(target), jtarget_len);
auto* it = reinterpret_cast<rocksdb::Iterator*>(handle);
it->SeekForPrev(target_slice);
auto* it = reinterpret_cast<rocksdb::Iterator*>(handle);
it->SeekForPrev(target_slice);
env->ReleaseByteArrayElements(jtarget, target, JNI_ABORT);
env->ReleaseByteArrayElements(jtarget, target, JNI_ABORT);
}
/*
@ -132,16 +134,17 @@ void Java_org_rocksdb_SstFileReaderIterator_seekForPrev0(JNIEnv* env, jobject /*
* Method: status0
* Signature: (J)V
*/
void Java_org_rocksdb_SstFileReaderIterator_status0(JNIEnv* env, jobject /*jobj*/,
void Java_org_rocksdb_SstFileReaderIterator_status0(JNIEnv* env,
jobject /*jobj*/,
jlong handle) {
auto* it = reinterpret_cast<rocksdb::Iterator*>(handle);
rocksdb::Status s = it->status();
auto* it = reinterpret_cast<rocksdb::Iterator*>(handle);
rocksdb::Status s = it->status();
if (s.ok()) {
return;
}
if (s.ok()) {
return;
}
rocksdb::RocksDBExceptionJni::ThrowNew(env, s);
rocksdb::RocksDBExceptionJni::ThrowNew(env, s);
}
/*
@ -149,19 +152,21 @@ void Java_org_rocksdb_SstFileReaderIterator_status0(JNIEnv* env, jobject /*jobj*
* Method: key0
* Signature: (J)[B
*/
jbyteArray Java_org_rocksdb_SstFileReaderIterator_key0(JNIEnv* env, jobject /*jobj*/,
jbyteArray Java_org_rocksdb_SstFileReaderIterator_key0(JNIEnv* env,
jobject /*jobj*/,
jlong handle) {
auto* it = reinterpret_cast<rocksdb::Iterator*>(handle);
rocksdb::Slice key_slice = it->key();
auto* it = reinterpret_cast<rocksdb::Iterator*>(handle);
rocksdb::Slice key_slice = it->key();
jbyteArray jkey = env->NewByteArray(static_cast<jsize>(key_slice.size()));
if(jkey == nullptr) {
// exception thrown: OutOfMemoryError
return nullptr;
}
env->SetByteArrayRegion(jkey, 0, static_cast<jsize>(key_slice.size()),
const_cast<jbyte*>(reinterpret_cast<const jbyte*>(key_slice.data())));
return jkey;
jbyteArray jkey = env->NewByteArray(static_cast<jsize>(key_slice.size()));
if (jkey == nullptr) {
// exception thrown: OutOfMemoryError
return nullptr;
}
env->SetByteArrayRegion(
jkey, 0, static_cast<jsize>(key_slice.size()),
const_cast<jbyte*>(reinterpret_cast<const jbyte*>(key_slice.data())));
return jkey;
}
/*

44
java/rocksjni/sst_file_readerjni.cc
View File

@ -23,8 +23,8 @@
* Signature: (J)J
*/
jlong Java_org_rocksdb_SstFileReader_newSstFileReader(JNIEnv * /*env*/,
jclass /*jcls*/,
jlong joptions) {
jclass /*jcls*/,
jlong joptions) {
auto *options = reinterpret_cast<const rocksdb::Options *>(joptions);
rocksdb::SstFileReader *sst_file_reader =
new rocksdb::SstFileReader(*options);
@ -53,18 +53,18 @@ void Java_org_rocksdb_SstFileReader_open(JNIEnv *env, jobject /*jobj*/,
}
/*
* Class: org_rocksdb_SstFileReader
* Method: newIterator
* Signature: (JJ)J
*/
jlong Java_org_rocksdb_SstFileReader_newIterator(JNIEnv* /*env*/,
* Class: org_rocksdb_SstFileReader
* Method: newIterator
* Signature: (JJ)J
*/
jlong Java_org_rocksdb_SstFileReader_newIterator(JNIEnv * /*env*/,
jobject /*jobj*/,
jlong jhandle,
jlong jread_options_handle) {
auto* sst_file_reader = reinterpret_cast<rocksdb::SstFileReader*>(jhandle);
auto* read_options =
reinterpret_cast<rocksdb::ReadOptions*>(jread_options_handle);
return reinterpret_cast<jlong>(sst_file_reader->NewIterator(*read_options));
auto *sst_file_reader = reinterpret_cast<rocksdb::SstFileReader *>(jhandle);
auto *read_options =
reinterpret_cast<rocksdb::ReadOptions *>(jread_options_handle);
return reinterpret_cast<jlong>(sst_file_reader->NewIterator(*read_options));
}
/*
@ -75,7 +75,7 @@ jlong Java_org_rocksdb_SstFileReader_newIterator(JNIEnv* /*env*/,
void Java_org_rocksdb_SstFileReader_disposeInternal(JNIEnv * /*env*/,
jobject /*jobj*/,
jlong jhandle) {
delete reinterpret_cast<rocksdb::SstFileReader *>(jhandle);
delete reinterpret_cast<rocksdb::SstFileReader *>(jhandle);
}
/*
@ -84,9 +84,9 @@ void Java_org_rocksdb_SstFileReader_disposeInternal(JNIEnv * /*env*/,
* Signature: (J)V
*/
void Java_org_rocksdb_SstFileReader_verifyChecksum(JNIEnv *env,
jobject /*jobj*/,
jlong jhandle) {
auto* sst_file_reader = reinterpret_cast<rocksdb::SstFileReader*>(jhandle);
jobject /*jobj*/,
jlong jhandle) {
auto *sst_file_reader = reinterpret_cast<rocksdb::SstFileReader *>(jhandle);
auto s = sst_file_reader->VerifyChecksum();
if (!s.ok()) {
rocksdb::RocksDBExceptionJni::ThrowNew(env, s);
@ -99,12 +99,12 @@ void Java_org_rocksdb_SstFileReader_verifyChecksum(JNIEnv *env,
* Signature: (J)J
*/
jobject Java_org_rocksdb_SstFileReader_getTableProperties(JNIEnv *env,
jobject /*jobj*/,
jlong jhandle) {
auto* sst_file_reader = reinterpret_cast<rocksdb::SstFileReader*>(jhandle);
std::shared_ptr<const rocksdb::TableProperties> tp = sst_file_reader->GetTableProperties();
jobject jtable_properties = rocksdb::TablePropertiesJni::fromCppTableProperties(
env, *(tp.get()));
jobject /*jobj*/,
jlong jhandle) {
auto *sst_file_reader = reinterpret_cast<rocksdb::SstFileReader *>(jhandle);
std::shared_ptr<const rocksdb::TableProperties> tp =
sst_file_reader->GetTableProperties();
jobject jtable_properties =
rocksdb::TablePropertiesJni::fromCppTableProperties(env, *(tp.get()));
return jtable_properties;
}

25
java/src/main/java/org/rocksdb/SstFileReader.java
View File

@ -31,19 +31,18 @@ public class SstFileReader extends RocksObject {
* @return instance of iterator object.
*/
public SstFileReaderIterator newIterator(final ReadOptions readOptions) {
assert(isOwningHandle());
long iter = newIterator(nativeHandle_,
readOptions.nativeHandle_);
assert (isOwningHandle());
long iter = newIterator(nativeHandle_, readOptions.nativeHandle_);
return new SstFileReaderIterator(this, iter);
}
/**
* Prepare SstFileReader to read a file.
*
* @param filePath the location of file
*
* @throws RocksDBException thrown if error happens in underlying
* native library.
* Prepare SstFileReader to read a file.
*
* @param filePath the location of file
*
* @throws RocksDBException thrown if error happens in underlying
* native library.
*/
public void open(final String filePath) throws RocksDBException {
open(nativeHandle_, filePath);
@ -68,14 +67,10 @@ public class SstFileReader extends RocksObject {
return getTableProperties(nativeHandle_);
}
@Override protected final native void disposeInternal(final long handle);
private native long newIterator(final long handle,
final long readOptionsHandle);
private native long newIterator(final long handle, final long readOptionsHandle);
private native void open(final long handle, final String filePath)
throws RocksDBException;
private native void open(final long handle, final String filePath) throws RocksDBException;
private native static long newSstFileReader(final long optionsHandle);
private native void verifyChecksum(final long handle) throws RocksDBException;

4
java/src/main/java/org/rocksdb/SstFileReaderIterator.java
View File

@ -33,7 +33,7 @@ public class SstFileReaderIterator extends AbstractRocksIterator<SstFileReader>
* @return key for the current entry.
*/
public byte[] key() {
assert(isOwningHandle());
assert (isOwningHandle());
return key0(nativeHandle_);
}
@ -46,7 +46,7 @@ public class SstFileReaderIterator extends AbstractRocksIterator<SstFileReader>
* @return value for the current entry.
*/
public byte[] value() {
assert(isOwningHandle());
assert (isOwningHandle());
return value0(nativeHandle_);
}

18
java/src/test/java/org/rocksdb/SstFileReaderTest.java
View File

@ -48,9 +48,10 @@ public class SstFileReaderTest {
@Rule public TemporaryFolder parentFolder = new TemporaryFolder();
enum OpType { PUT, PUT_BYTES, MERGE, MERGE_BYTES, DELETE, DELETE_BYTES}
enum OpType { PUT, PUT_BYTES, MERGE, MERGE_BYTES, DELETE, DELETE_BYTES }
private File newSstFile(final List<KeyValueWithOp> keyValues) throws IOException, RocksDBException {
private File newSstFile(final List<KeyValueWithOp> keyValues)
throws IOException, RocksDBException {
final EnvOptions envOptions = new EnvOptions();
final StringAppendOperator stringAppendOperator = new StringAppendOperator();
final Options options = new Options().setMergeOperator(stringAppendOperator);
@ -105,15 +106,11 @@ public class SstFileReaderTest {
final List<KeyValueWithOp> keyValues = new ArrayList<>();
keyValues.add(new KeyValueWithOp("key1", "value1", OpType.PUT));
final File sstFile = newSstFile(keyValues);
try(final StringAppendOperator stringAppendOperator =
new StringAppendOperator();
final Options options = new Options()
.setCreateIfMissing(true)
.setMergeOperator(stringAppendOperator);
final SstFileReader reader = new SstFileReader(options)
) {
try (final StringAppendOperator stringAppendOperator = new StringAppendOperator();
final Options options =
new Options().setCreateIfMissing(true).setMergeOperator(stringAppendOperator);
final SstFileReader reader = new SstFileReader(options)) {
// Open the sst file and iterator
reader.open(sstFile.getAbsolutePath());
final ReadOptions readOptions = new ReadOptions();
@ -133,5 +130,4 @@ public class SstFileReaderTest {
assertThat(iterator.value()).isEqualTo("value1".getBytes());
}
}
}

3
options/options_settable_test.cc
View File

@ -356,8 +356,7 @@ TEST_F(OptionsSettableTest, ColumnFamilyOptionsAllFieldsSettable) {
{offset_of(&ColumnFamilyOptions::snap_refresh_nanos), sizeof(uint64_t)},
{offset_of(&ColumnFamilyOptions::table_factory),
sizeof(std::shared_ptr<TableFactory>)},
{offset_of(&ColumnFamilyOptions::cf_paths),
sizeof(std::vector<DbPath>)},
{offset_of(&ColumnFamilyOptions::cf_paths), sizeof(std::vector<DbPath>)},
{offset_of(&ColumnFamilyOptions::compaction_thread_limiter),
sizeof(std::shared_ptr<ConcurrentTaskLimiter>)},
};

6
tools/block_cache_analyzer/block_cache_trace_analyzer.cc
View File

@ -1830,8 +1830,10 @@ void BlockCacheTraceAnalyzer::PrintDataBlockAccessStats() const {
hist_naccess_per_key.Add(caller_access.second);
}
}
uint64_t avg_accesses = static_cast<uint64_t>(hist_naccess_per_key.Average());
uint64_t stdev_accesses = static_cast<uint64_t>(hist_naccess_per_key.StandardDeviation());
uint64_t avg_accesses =
static_cast<uint64_t>(hist_naccess_per_key.Average());
uint64_t stdev_accesses =
static_cast<uint64_t>(hist_naccess_per_key.StandardDeviation());
avg_naccesses_per_key_in_a_data_block.Add(avg_accesses);
cf_avg_naccesses_per_key_in_a_data_block[cf_name].Add(avg_accesses);
stdev_naccesses_per_key_in_a_data_block.Add(stdev_accesses);

5
tools/db_stress.cc
View File

@ -353,8 +353,9 @@ DEFINE_int32(bloom_bits, 10, "Bloom filter bits per key. "
DEFINE_bool(use_block_based_filter, false, "use block based filter"
"instead of full filter for block based table");
DEFINE_bool(partition_filters, false, "use partitioned filters "
"for block-based table");
DEFINE_bool(partition_filters, false,
"use partitioned filters "
"for block-based table");
DEFINE_int32(
index_type,

5
tools/sst_dump_tool.cc
View File

@ -405,8 +405,9 @@ Status SstFileDumper::ReadTableProperties(
namespace {
void print_help() {
fprintf(stderr,
R"(sst_dump --file=<data_dir_OR_sst_file> [--command=check|scan|raw|recompress]
fprintf(
stderr,
R"(sst_dump --file=<data_dir_OR_sst_file> [--command=check|scan|raw|recompress]
--file=<data_dir_OR_sst_file>
Path to SST file or directory containing SST files

30
util/bloom_impl.h
View File

@ -26,13 +26,13 @@ namespace rocksdb {
// See e.g. RocksDB DynamicBloom.
//
class LegacyNoLocalityBloomImpl {
public:
static inline void AddHash(uint32_t h, uint32_t total_bits,
int num_probes, char *data) {
public:
static inline void AddHash(uint32_t h, uint32_t total_bits, int num_probes,
char *data) {
const uint32_t delta = (h >> 17) | (h << 15); // Rotate right 17 bits
for (int i = 0; i < num_probes; i++) {
const uint32_t bitpos = h % total_bits;
data[bitpos/8] |= (1 << (bitpos % 8));
data[bitpos / 8] |= (1 << (bitpos % 8));
h += delta;
}
}
@ -42,7 +42,7 @@ public:
const uint32_t delta = (h >> 17) | (h << 15); // Rotate right 17 bits
for (int i = 0; i < num_probes; i++) {
const uint32_t bitpos = h % total_bits;
if ((data[bitpos/8] & (1 << (bitpos % 8))) == 0) {
if ((data[bitpos / 8] & (1 << (bitpos % 8))) == 0) {
return false;
}
h += delta;
@ -51,7 +51,6 @@ public:
}
};
// A legacy Bloom filter implementation with probes local to a single
// cache line (fast). Because SST files might be transported between
// platforms, the cache line size is a parameter rather than hard coded.
@ -72,15 +71,15 @@ public:
//
template <bool ExtraRotates>
class LegacyLocalityBloomImpl {
private:
private:
static inline uint32_t GetLine(uint32_t h, uint32_t num_lines) {
uint32_t offset_h = ExtraRotates ? (h >> 11) | (h << 21) : h;
return offset_h % num_lines;
}
public:
static inline void AddHash(uint32_t h, uint32_t num_lines,
int num_probes, char *data,
int log2_cache_line_bytes) {
public:
static inline void AddHash(uint32_t h, uint32_t num_lines, int num_probes,
char *data, int log2_cache_line_bytes) {
const int log2_cache_line_bits = log2_cache_line_bytes + 3;
char *data_at_offset =
@ -99,12 +98,12 @@ public:
static inline void PrepareHashMayMatch(uint32_t h, uint32_t num_lines,
const char *data,
uint32_t /*out*/*byte_offset,
uint32_t /*out*/ *byte_offset,
int log2_cache_line_bytes) {
uint32_t b = GetLine(h, num_lines) << log2_cache_line_bytes;
PREFETCH(data + b, 0 /* rw */, 1 /* locality */);
PREFETCH(data + b + ((1 << log2_cache_line_bytes) - 1),
0 /* rw */, 1 /* locality */);
PREFETCH(data + b + ((1 << log2_cache_line_bytes) - 1), 0 /* rw */,
1 /* locality */);
*byte_offset = b;
}
@ -112,8 +111,7 @@ public:
int num_probes, const char *data,
int log2_cache_line_bytes) {
uint32_t b = GetLine(h, num_lines) << log2_cache_line_bytes;
return HashMayMatchPrepared(h, num_probes,
data + b, log2_cache_line_bytes);
return HashMayMatchPrepared(h, num_probes, data + b, log2_cache_line_bytes);
}
static inline bool HashMayMatchPrepared(uint32_t h, int num_probes,

4
util/concurrent_task_limiter_impl.h
View File

@ -24,8 +24,8 @@ class ConcurrentTaskLimiterImpl : public ConcurrentTaskLimiter {
int32_t max_outstanding_task);
// No copying allowed
ConcurrentTaskLimiterImpl(const ConcurrentTaskLimiterImpl&) = delete;
ConcurrentTaskLimiterImpl& operator=(
const ConcurrentTaskLimiterImpl&) = delete;
ConcurrentTaskLimiterImpl& operator=(const ConcurrentTaskLimiterImpl&) =
delete;
virtual ~ConcurrentTaskLimiterImpl();

24
util/crc32c_arm64.h
View File

@ -17,17 +17,21 @@
#define crc32c_u16(crc, v) __crc32ch(crc, v)
#define crc32c_u32(crc, v) __crc32cw(crc, v)
#define crc32c_u64(crc, v) __crc32cd(crc, v)
#define PREF4X64L1(buffer,PREF_OFFSET, ITR) \
__asm__("PRFM PLDL1KEEP, [%x[v],%[c]]"::[v]"r"(buffer), [c]"I"((PREF_OFFSET) + ((ITR) + 0)*64));\
__asm__("PRFM PLDL1KEEP, [%x[v],%[c]]"::[v]"r"(buffer), [c]"I"((PREF_OFFSET) + ((ITR) + 1)*64));\
__asm__("PRFM PLDL1KEEP, [%x[v],%[c]]"::[v]"r"(buffer), [c]"I"((PREF_OFFSET) + ((ITR) + 2)*64));\
__asm__("PRFM PLDL1KEEP, [%x[v],%[c]]"::[v]"r"(buffer), [c]"I"((PREF_OFFSET) + ((ITR) + 3)*64));
#define PREF4X64L1(buffer, PREF_OFFSET, ITR) \
__asm__("PRFM PLDL1KEEP, [%x[v],%[c]]" ::[v] "r"(buffer), \
[c] "I"((PREF_OFFSET) + ((ITR) + 0) * 64)); \
__asm__("PRFM PLDL1KEEP, [%x[v],%[c]]" ::[v] "r"(buffer), \
[c] "I"((PREF_OFFSET) + ((ITR) + 1) * 64)); \
__asm__("PRFM PLDL1KEEP, [%x[v],%[c]]" ::[v] "r"(buffer), \
[c] "I"((PREF_OFFSET) + ((ITR) + 2) * 64)); \
__asm__("PRFM PLDL1KEEP, [%x[v],%[c]]" ::[v] "r"(buffer), \
[c] "I"((PREF_OFFSET) + ((ITR) + 3) * 64));
#define PREF1KL1(buffer,PREF_OFFSET) \
PREF4X64L1(buffer,(PREF_OFFSET), 0) \
PREF4X64L1(buffer,(PREF_OFFSET), 4) \
PREF4X64L1(buffer,(PREF_OFFSET), 8) \
PREF4X64L1(buffer,(PREF_OFFSET), 12)
#define PREF1KL1(buffer, PREF_OFFSET) \
PREF4X64L1(buffer, (PREF_OFFSET), 0) \
PREF4X64L1(buffer, (PREF_OFFSET), 4) \
PREF4X64L1(buffer, (PREF_OFFSET), 8) \
PREF4X64L1(buffer, (PREF_OFFSET), 12)
extern uint32_t crc32c_arm64(uint32_t crc, unsigned char const *data, unsigned len);
extern uint32_t crc32c_runtime_check(void);

2
util/dynamic_bloom.cc
View File

@ -42,7 +42,7 @@ DynamicBloom::DynamicBloom(Allocator* allocator, uint32_t total_bits,
uint32_t block_bits = block_bytes * 8;
uint32_t blocks = (total_bits + block_bits - 1) / block_bits;
uint32_t sz = blocks * block_bytes;
kLen = sz / /*bytes/u64*/8;
kLen = sz / /*bytes/u64*/ 8;
assert(kLen > 0);
#ifndef NDEBUG
for (uint32_t i = 0; i < kNumDoubleProbes; ++i) {

72
util/dynamic_bloom_test.cc
View File

@ -134,41 +134,41 @@ TEST_F(DynamicBloomTest, VaryingLengths) {
// NB: FP rate impact of 32-bit hash is noticeable starting around 10M keys.
// But that effect is hidden if using sequential keys (unique hashes).
for (bool nonseq : {false, true}) {
const uint32_t max_num = FLAGS_enable_perf ? 40000000 : 400000;
for (uint32_t num = 1; num <= max_num; num = NextNum(num)) {
uint32_t bloom_bits = 0;
Arena arena;
bloom_bits = num * FLAGS_bits_per_key;
DynamicBloom bloom(&arena, bloom_bits, num_probes);
for (uint64_t i = 0; i < num; i++) {
bloom.Add(km.Key(i, nonseq));
ASSERT_TRUE(bloom.MayContain(km.Key(i, nonseq)));
}
// All added keys must match
for (uint64_t i = 0; i < num; i++) {
ASSERT_TRUE(bloom.MayContain(km.Key(i, nonseq)));
}
// Check false positive rate
int result = 0;
for (uint64_t i = 0; i < 30000; i++) {
if (bloom.MayContain(km.Key(i + 1000000000, nonseq))) {
result++;
const uint32_t max_num = FLAGS_enable_perf ? 40000000 : 400000;
for (uint32_t num = 1; num <= max_num; num = NextNum(num)) {
uint32_t bloom_bits = 0;
Arena arena;
bloom_bits = num * FLAGS_bits_per_key;
DynamicBloom bloom(&arena, bloom_bits, num_probes);
for (uint64_t i = 0; i < num; i++) {
bloom.Add(km.Key(i, nonseq));
ASSERT_TRUE(bloom.MayContain(km.Key(i, nonseq)));
}
// All added keys must match
for (uint64_t i = 0; i < num; i++) {
ASSERT_TRUE(bloom.MayContain(km.Key(i, nonseq)));
}
// Check false positive rate
int result = 0;
for (uint64_t i = 0; i < 30000; i++) {
if (bloom.MayContain(km.Key(i + 1000000000, nonseq))) {
result++;
}
}
double rate = result / 30000.0;
fprintf(stderr,
"False positives (%s keys): "
"%5.2f%% @ num = %6u, bloom_bits = %6u\n",
nonseq ? "nonseq" : "seq", rate * 100.0, num, bloom_bits);
if (rate > 0.0125)
mediocre_filters++; // Allowed, but not too often
else
good_filters++;
}
double rate = result / 30000.0;
fprintf(stderr,
"False positives (%s keys): "
"%5.2f%% @ num = %6u, bloom_bits = %6u\n",
nonseq ? "nonseq" : "seq", rate * 100.0, num, bloom_bits);
if (rate > 0.0125)
mediocre_filters++; // Allowed, but not too often
else
good_filters++;
}
}
fprintf(stderr, "Filters: %d good, %d mediocre\n", good_filters,
@ -263,8 +263,7 @@ TEST_F(DynamicBloomTest, concurrent_with_perf) {
StopWatchNano timer(Env::Default());
timer.Start();
for (uint64_t i = 1 + t; i <= num_keys; i += num_threads) {
bool f =
std_bloom.MayContain(km.Seq(i));
bool f = std_bloom.MayContain(km.Seq(i));
ASSERT_TRUE(f);
}
elapsed += timer.ElapsedNanos();
@ -289,8 +288,7 @@ TEST_F(DynamicBloomTest, concurrent_with_perf) {
timer.Start();
for (uint64_t i = num_keys + 1 + t; i <= 2 * num_keys;
i += num_threads) {
bool f =
std_bloom.MayContain(km.Seq(i));
bool f = std_bloom.MayContain(km.Seq(i));
if (f) {
++false_positives;
}

12
util/mutexlock.h
View File

@ -32,8 +32,8 @@ class MutexLock {
this->mu_->Lock();
}
// No copying allowed
MutexLock(const MutexLock&) = delete;
void operator=(const MutexLock&) = delete;
MutexLock(const MutexLock &) = delete;
void operator=(const MutexLock &) = delete;
~MutexLock() { this->mu_->Unlock(); }
@ -52,8 +52,8 @@ class ReadLock {
this->mu_->ReadLock();
}
// No copying allowed
ReadLock(const ReadLock&) = delete;
void operator=(const ReadLock&) = delete;
ReadLock(const ReadLock &) = delete;
void operator=(const ReadLock &) = delete;
~ReadLock() { this->mu_->ReadUnlock(); }
@ -88,8 +88,8 @@ class WriteLock {
this->mu_->WriteLock();
}
// No copying allowed
WriteLock(const WriteLock&) = delete;
void operator=(const WriteLock&) = delete;
WriteLock(const WriteLock &) = delete;
void operator=(const WriteLock &) = delete;
~WriteLock() { this->mu_->WriteUnlock(); }

2
utilities/transactions/write_unprepared_txn_db.cc
View File

@ -5,8 +5,8 @@
#ifndef ROCKSDB_LITE
#include "db/arena_wrapped_db_iter.h"
#include "utilities/transactions/write_unprepared_txn_db.h"
#include "db/arena_wrapped_db_iter.h"
#include "rocksdb/utilities/transaction_db.h"
#include "util/cast_util.h"