Merge #44473

44473: storage/engine: expose FailOnMoreRecent MVCC{Get/Scan}Option r=nvanbenschoten a=nvanbenschoten

Relates to #40205.

This change introduces a new option to `MVCCGetOptions` and `MVCCScanOptions` that causes reads to throw an error if they observe an MVCC version at a timestamp above their read timestamp. Specifically, when the option is enabled, a `WriteTooOldError` will be returned if a scan observes an MVCC version with a timestamp above the read. Similarly, a `WriteIntentError` will be returned if a scan observes another transaction's intent, even if that intent has a timestamp above the scan's read timestamp.

This option will be used in the future by `ScanRequests` and `ReverseScanRequests` that intend to acquire unreplicated key-level locks, which will power `SELECT FOR UPDATE`. These scans do not want to ignore existing MVCC versions at higher timestamps like traditional scans do. Instead, they want to throw errors and force their transaction to increase its timestamp through either a refresh or a retry. This was previously prototyped in 4a8e8dc.

Interestingly, this is not new logic to the MVCC layer. This behavior is exactly the same as that of the initial key-value lookup performed during MVCC writes (see `mvccPutInternal`). It's fitting that behavior needed for `SELECT FOR UPDATE` would mirror that already exhibited by the read portion of read-write operations. This also hints at an opportunity to potentially use this option to merge the two implementations and get rid of custom logic like `mvccGetInternal` that only exists on the write path. We'd need to be careful about doing so though, as this code is heavily tuned.

Release note: None

Co-authored-by: Nathan VanBenschoten <nvanbenschoten@gmail.com>

c-deps/libroach/batch.cc

@@ -587,14 +587,25 @@ DBStatus DBBatch::EnvDeleteDirAndFiles(DBSlice dir) { return FmtStatus("unsuppor
 
 DBStatus DBBatch::EnvLinkFile(DBSlice oldname, DBSlice newname) { return FmtStatus("unsupported"); }
 
-DBStatus DBBatch::EnvOpenReadableFile(DBSlice path, rocksdb::RandomAccessFile** file) { return FmtStatus("unsupported"); }
-DBStatus DBBatch::EnvReadAtFile(rocksdb::RandomAccessFile* file, DBSlice buffer, int64_t offset, int* n) { return FmtStatus("unsupported"); }
-DBStatus DBBatch::EnvCloseReadableFile(rocksdb::RandomAccessFile* file) { return FmtStatus("unsupported"); }
-DBStatus DBBatch::EnvOpenDirectory(DBSlice path, rocksdb::Directory** file) { return FmtStatus("unsupported"); }
+DBStatus DBBatch::EnvOpenReadableFile(DBSlice path, rocksdb::RandomAccessFile** file) {
+  return FmtStatus("unsupported");
+}
+DBStatus DBBatch::EnvReadAtFile(rocksdb::RandomAccessFile* file, DBSlice buffer, int64_t offset,
+                                int* n) {
+  return FmtStatus("unsupported");
+}
+DBStatus DBBatch::EnvCloseReadableFile(rocksdb::RandomAccessFile* file) {
+  return FmtStatus("unsupported");
+}
+DBStatus DBBatch::EnvOpenDirectory(DBSlice path, rocksdb::Directory** file) {
+  return FmtStatus("unsupported");
+}
 DBStatus DBBatch::EnvSyncDirectory(rocksdb::Directory* file) { return FmtStatus("unsupported"); }
 DBStatus DBBatch::EnvCloseDirectory(rocksdb::Directory* file) { return FmtStatus("unsupported"); }
-DBStatus DBBatch::EnvRenameFile(DBSlice oldname, DBSlice newname) { return FmtStatus("unsupported"); }
-
+DBStatus DBBatch::EnvRenameFile(DBSlice oldname, DBSlice newname) {
+  return FmtStatus("unsupported");
+}
+
 DBWriteOnlyBatch::DBWriteOnlyBatch(DBEngine* db) : DBEngine(db->rep, db->iters), updates(0) {}
 
 DBWriteOnlyBatch::~DBWriteOnlyBatch() {}
@@ -706,13 +717,28 @@ DBStatus DBWriteOnlyBatch::EnvLinkFile(DBSlice oldname, DBSlice newname) {
   return FmtStatus("unsupported");
 }
 
-DBStatus DBWriteOnlyBatch::EnvOpenReadableFile(DBSlice path, rocksdb::RandomAccessFile** file) { return FmtStatus("unsupported"); }
-DBStatus DBWriteOnlyBatch::EnvReadAtFile(rocksdb::RandomAccessFile* file, DBSlice buffer, int64_t offset, int* n) { return FmtStatus("unsupported"); }
-DBStatus DBWriteOnlyBatch::EnvCloseReadableFile(rocksdb::RandomAccessFile* file) { return FmtStatus("unsupported"); }
-DBStatus DBWriteOnlyBatch::EnvOpenDirectory(DBSlice path, rocksdb::Directory** file) { return FmtStatus("unsupported"); }
-DBStatus DBWriteOnlyBatch::EnvSyncDirectory(rocksdb::Directory* file) { return FmtStatus("unsupported"); }
-DBStatus DBWriteOnlyBatch::EnvCloseDirectory(rocksdb::Directory* file) { return FmtStatus("unsupported"); }
-DBStatus DBWriteOnlyBatch::EnvRenameFile(DBSlice oldname, DBSlice newname) { return FmtStatus("unsupported"); }
+DBStatus DBWriteOnlyBatch::EnvOpenReadableFile(DBSlice path, rocksdb::RandomAccessFile** file) {
+  return FmtStatus("unsupported");
+}
+DBStatus DBWriteOnlyBatch::EnvReadAtFile(rocksdb::RandomAccessFile* file, DBSlice buffer,
+                                         int64_t offset, int* n) {
+  return FmtStatus("unsupported");
+}
+DBStatus DBWriteOnlyBatch::EnvCloseReadableFile(rocksdb::RandomAccessFile* file) {
+  return FmtStatus("unsupported");
+}
+DBStatus DBWriteOnlyBatch::EnvOpenDirectory(DBSlice path, rocksdb::Directory** file) {
+  return FmtStatus("unsupported");
+}
+DBStatus DBWriteOnlyBatch::EnvSyncDirectory(rocksdb::Directory* file) {
+  return FmtStatus("unsupported");
+}
+DBStatus DBWriteOnlyBatch::EnvCloseDirectory(rocksdb::Directory* file) {
+  return FmtStatus("unsupported");
+}
+DBStatus DBWriteOnlyBatch::EnvRenameFile(DBSlice oldname, DBSlice newname) {
+  return FmtStatus("unsupported");
+}
 
 rocksdb::WriteBatch::Handler* GetDBBatchInserter(::rocksdb::WriteBatchBase* batch) {
   return new DBBatchInserter(batch);

c-deps/libroach/batch.h

@@ -50,7 +50,8 @@ struct DBBatch : public DBEngine {
   virtual DBStatus EnvDeleteDirAndFiles(DBSlice dir);
   virtual DBStatus EnvLinkFile(DBSlice oldname, DBSlice newname);
   virtual DBStatus EnvOpenReadableFile(DBSlice path, rocksdb::RandomAccessFile** file);
-  virtual DBStatus EnvReadAtFile(rocksdb::RandomAccessFile* file, DBSlice buffer, int64_t offset, int* n);
+  virtual DBStatus EnvReadAtFile(rocksdb::RandomAccessFile* file, DBSlice buffer, int64_t offset,
+                                 int* n);
   virtual DBStatus EnvCloseReadableFile(rocksdb::RandomAccessFile* file);
   virtual DBStatus EnvOpenDirectory(DBSlice path, rocksdb::Directory** file);
   virtual DBStatus EnvSyncDirectory(rocksdb::Directory* file);
@@ -90,7 +91,8 @@ struct DBWriteOnlyBatch : public DBEngine {
   virtual DBStatus EnvDeleteDirAndFiles(DBSlice dir);
   virtual DBStatus EnvLinkFile(DBSlice oldname, DBSlice newname);
   virtual DBStatus EnvOpenReadableFile(DBSlice path, rocksdb::RandomAccessFile** file);
-  virtual DBStatus EnvReadAtFile(rocksdb::RandomAccessFile* file, DBSlice buffer, int64_t offset, int* n);
+  virtual DBStatus EnvReadAtFile(rocksdb::RandomAccessFile* file, DBSlice buffer, int64_t offset,
+                                 int* n);
   virtual DBStatus EnvCloseReadableFile(rocksdb::RandomAccessFile* file);
   virtual DBStatus EnvOpenDirectory(DBSlice path, rocksdb::Directory** file);
   virtual DBStatus EnvSyncDirectory(rocksdb::Directory* file);

c-deps/libroach/ccl/db_test.cc

@@ -167,8 +167,7 @@ TEST_F(CCLTest, ReadOnly) {
     free(ro_value.data);
     // Try to write it again.
     auto ret = DBPut(db, ToDBKey("foo"), ToDBSlice("foo's value"));
-    EXPECT_EQ(ToString(ret),
-              "Not implemented: Not supported operation in read only mode.");
+    EXPECT_EQ(ToString(ret), "Not implemented: Not supported operation in read only mode.");
     free(ret.data);
 
     DBClose(db);
@@ -192,8 +191,7 @@ TEST_F(CCLTest, ReadOnly) {
     free(ro_value.data);
     // Try to write it again.
     auto ret = DBPut(db, ToDBKey("foo"), ToDBSlice("foo's value"));
-    EXPECT_EQ(ToString(ret),
-              "Not implemented: Not supported operation in read only mode.");
+    EXPECT_EQ(ToString(ret), "Not implemented: Not supported operation in read only mode.");
     free(ret.data);
 
     DBClose(db);

c-deps/libroach/chunked_buffer.cc

@@ -59,7 +59,7 @@ void chunkedBuffer::put(const char* data, int len, int next_size_hint) {
     data += avail;
     len -= avail;
 
-    const int max_size = 128 << 20; // 128 MB
+    const int max_size = 128 << 20;  // 128 MB
     size_t new_size = bufs_.empty() ? 16 : bufs_.back().len * 2;
     for (; new_size < len + next_size_hint && new_size < max_size; new_size *= 2) {
     }

c-deps/libroach/chunked_buffer_test.cc

@@ -15,8 +15,8 @@
 // writing in pieces that are smaller than the maximum chunk size (128
 // MB). See #32896.
 TEST(ChunkedBuffer, PutSmall) {
-  const std::string data(1 << 20, '.'); // 1 MB
-  const int64_t total = 3LL << 30;      // 3 GB
+  const std::string data(1 << 20, '.');  // 1 MB
+  const int64_t total = 3LL << 30;       // 3 GB
   cockroach::chunkedBuffer buf;
   for (int64_t sum = 0; sum < total; sum += data.size()) {
     buf.Put(data, data);
@@ -27,8 +27,8 @@ TEST(ChunkedBuffer, PutSmall) {
 // writing in pieces that are larger than the maximum chunk size (128
 // MB). See #32896.
 TEST(ChunkedBuffer, PutLarge) {
-  const std::string data(256 << 20, '.'); // 256 MB
-  const int64_t total = 3LL << 30;        // 3 GB
+  const std::string data(256 << 20, '.');  // 256 MB
+  const int64_t total = 3LL << 30;         // 3 GB
   cockroach::chunkedBuffer buf;
   for (int64_t sum = 0; sum < total; sum += data.size()) {
     buf.Put(data, data);

c-deps/libroach/comparator.cc

@@ -41,14 +41,13 @@ bool DBComparator::Equal(const rocksdb::Slice& a, const rocksdb::Slice& b) const
 
 namespace {
 
-void ShrinkSlice(rocksdb::Slice* a, size_t size) {
-  a->remove_suffix(a->size() - size);
-}
+void ShrinkSlice(rocksdb::Slice* a, size_t size) { a->remove_suffix(a->size() - size); }
 
 int SharedPrefixLen(const rocksdb::Slice& a, const rocksdb::Slice& b) {
   auto n = std::min(a.size(), b.size());
   int i = 0;
-  for (; i < n && a[i] == b[i]; ++i) {}
+  for (; i < n && a[i] == b[i]; ++i) {
+  }
   return i;
 }
 
@@ -68,7 +67,8 @@ bool FindSeparator(rocksdb::Slice* a, std::string* a_backing, const rocksdb::Sli
     // So b is smaller than a.
     return false;
   }
-  if ((prefix < b.size() - 1) || static_cast<unsigned char>((*a)[prefix]) + 1 < static_cast<unsigned char>(b[prefix])) {
+  if ((prefix < b.size() - 1) ||
+      static_cast<unsigned char>((*a)[prefix]) + 1 < static_cast<unsigned char>(b[prefix])) {
     // a and b do not have consecutive characters at prefix.
     (*a_backing)[prefix]++;
     ShrinkSlice(a, prefix + 1);
@@ -97,7 +97,8 @@ void DBComparator::FindShortestSeparator(std::string* start, const rocksdb::Slic
     return;
   }
   auto found = FindSeparator(&key_s, start, key_l);
-  if (!found) return;
+  if (!found)
+    return;
   start->resize(key_s.size() + 1);
   (*start)[key_s.size()] = 0x00;
 }

c-deps/libroach/comparator_test.cc

@@ -40,39 +40,39 @@ DBKey makeKey(const char* s, int64_t wall_time = 0, int32_t logical = 0) {
 TEST(Libroach, Comparator) {
   DBComparator comp;
   std::vector<SeparatorTestCase> sepCases = {
-    // Many cases here are adapted from a Pebble unit test.
+      // Many cases here are adapted from a Pebble unit test.
 
-    // Non-empty b values.
-    {makeKey("black"), makeKey("blue"), makeKey("blb")},
-    {makeKey(""), makeKey("2"), makeKey("")},
-    {makeKey("1"), makeKey("2"), makeKey("1")},
-    {makeKey("1"), makeKey("29"), makeKey("2")},
-    {makeKey("13"), makeKey("19"), makeKey("14")},
-    {makeKey("13"), makeKey("99"), makeKey("2")},
-    {makeKey("135"), makeKey("19"), makeKey("14")},
-    {makeKey("1357"), makeKey("19"), makeKey("14")},
-    {makeKey("1357"), makeKey("2"), makeKey("14")},
-    {makeKey("13\xff"), makeKey("14"), makeKey("13\xff")},
-    {makeKey("13\xff"), makeKey("19"), makeKey("14")},
-    {makeKey("1\xff\xff"), makeKey("19"), makeKey("1\xff\xff")},
-    {makeKey("1\xff\xff"), makeKey("2"), makeKey("1\xff\xff")},
-    {makeKey("1\xff\xff"), makeKey("9"), makeKey("2")},
-    {makeKey("1\xfd\xff"), makeKey("1\xff"), makeKey("1\xfe")},
-    {makeKey("1\xff\xff", 20, 3), makeKey("9"), makeKey("2")},
-    {makeKey("1\xff\xff", 20, 3), makeKey("19"), makeKey("1\xff\xff", 20, 3)},
+      // Non-empty b values.
+      {makeKey("black"), makeKey("blue"), makeKey("blb")},
+      {makeKey(""), makeKey("2"), makeKey("")},
+      {makeKey("1"), makeKey("2"), makeKey("1")},
+      {makeKey("1"), makeKey("29"), makeKey("2")},
+      {makeKey("13"), makeKey("19"), makeKey("14")},
+      {makeKey("13"), makeKey("99"), makeKey("2")},
+      {makeKey("135"), makeKey("19"), makeKey("14")},
+      {makeKey("1357"), makeKey("19"), makeKey("14")},
+      {makeKey("1357"), makeKey("2"), makeKey("14")},
+      {makeKey("13\xff"), makeKey("14"), makeKey("13\xff")},
+      {makeKey("13\xff"), makeKey("19"), makeKey("14")},
+      {makeKey("1\xff\xff"), makeKey("19"), makeKey("1\xff\xff")},
+      {makeKey("1\xff\xff"), makeKey("2"), makeKey("1\xff\xff")},
+      {makeKey("1\xff\xff"), makeKey("9"), makeKey("2")},
+      {makeKey("1\xfd\xff"), makeKey("1\xff"), makeKey("1\xfe")},
+      {makeKey("1\xff\xff", 20, 3), makeKey("9"), makeKey("2")},
+      {makeKey("1\xff\xff", 20, 3), makeKey("19"), makeKey("1\xff\xff", 20, 3)},
 
-    // Empty b values
-    {makeKey(""), makeKey(""), makeKey("")},
-    {makeKey("green"), makeKey(""), makeKey("green")},
-    {makeKey("1"), makeKey(""), makeKey("1")},
-    {makeKey("11\xff"), makeKey(""), makeKey("11\xff")},
-    {makeKey("1\xff"), makeKey(""), makeKey("1\xff")},
-    {makeKey("1\xff\xff"), makeKey(""), makeKey("1\xff\xff")},
-    {makeKey("\xff"), makeKey(""), makeKey("\xff")},
-    {makeKey("\xff\xff"), makeKey(""), makeKey("\xff\xff")},
+      // Empty b values
+      {makeKey(""), makeKey(""), makeKey("")},
+      {makeKey("green"), makeKey(""), makeKey("green")},
+      {makeKey("1"), makeKey(""), makeKey("1")},
+      {makeKey("11\xff"), makeKey(""), makeKey("11\xff")},
+      {makeKey("1\xff"), makeKey(""), makeKey("1\xff")},
+      {makeKey("1\xff\xff"), makeKey(""), makeKey("1\xff\xff")},
+      {makeKey("\xff"), makeKey(""), makeKey("\xff")},
+      {makeKey("\xff\xff"), makeKey(""), makeKey("\xff\xff")},
   };
-  
-  for (const auto& c: sepCases) {
+
+  for (const auto& c : sepCases) {
     auto a_str = EncodeKey(c.a);
     auto b_str = EncodeKey(c.b);
     std::printf("a_str: %s, b_str: %s\n", a_str.c_str(), b_str.c_str());
@@ -81,21 +81,21 @@ TEST(Libroach, Comparator) {
   }
 
   std::vector<SuccessorTestCase> succCases = {
-    {makeKey("black"), makeKey("c")},
-    {makeKey("green"), makeKey("h")},
-    {makeKey(""), makeKey("")},
-    {makeKey("13"), makeKey("2")},
-    {makeKey("135"), makeKey("2")},
-    {makeKey("13\xff"), makeKey("2")},
-    {makeKey("1\xff\xff", 20, 3), makeKey("2")},
-    {makeKey("\xff"), makeKey("\xff")},
-    {makeKey("\xff\xff"), makeKey("\xff\xff")},
-    {makeKey("\xff\xff\xff"), makeKey("\xff\xff\xff")},
-    {makeKey("\xfe\xff\xff"), makeKey("\xff")},
-    {makeKey("\xff\xff", 20, 3), makeKey("\xff\xff", 20, 3)},
+      {makeKey("black"), makeKey("c")},
+      {makeKey("green"), makeKey("h")},
+      {makeKey(""), makeKey("")},
+      {makeKey("13"), makeKey("2")},
+      {makeKey("135"), makeKey("2")},
+      {makeKey("13\xff"), makeKey("2")},
+      {makeKey("1\xff\xff", 20, 3), makeKey("2")},
+      {makeKey("\xff"), makeKey("\xff")},
+      {makeKey("\xff\xff"), makeKey("\xff\xff")},
+      {makeKey("\xff\xff\xff"), makeKey("\xff\xff\xff")},
+      {makeKey("\xfe\xff\xff"), makeKey("\xff")},
+      {makeKey("\xff\xff", 20, 3), makeKey("\xff\xff", 20, 3)},
   };
 
-  for (const auto& c: succCases) {
+  for (const auto& c : succCases) {
     auto a_str = EncodeKey(c.a);
     std::printf("a_str: %s\n", a_str.c_str());
     comp.FindShortSuccessor(&a_str);

c-deps/libroach/db.cc

@@ -940,7 +940,7 @@ DBSstFileWriter* DBSstFileWriterNew() {
   // This makes the sstables produced by Pebble and RocksDB byte-by-byte identical, which is
   // useful for testing.
   table_options.index_shortening =
-    rocksdb::BlockBasedTableOptions::IndexShorteningMode::kShortenSeparatorsAndSuccessor;
+      rocksdb::BlockBasedTableOptions::IndexShorteningMode::kShortenSeparatorsAndSuccessor;
 
   rocksdb::Options* options = new rocksdb::Options();
   options->comparator = &kComparator;
@@ -1102,7 +1102,7 @@ DBStatus DBExportToSst(DBKey start, DBKey end, bool export_all_revisions,
   std::string resume_key;
   // Seek to the MVCC metadata key for the provided start key and let the
   // incremental iterator find the appropriate version.
-  const DBKey seek_key = { .key = start.key };
+  const DBKey seek_key = {.key = start.key};
   for (state = iter.seek(seek_key);; state = iter.next(skip_current_key_versions)) {
     if (state.status.data != NULL) {
       DBSstFileWriterClose(writer);
@@ -1129,7 +1129,8 @@ DBStatus DBExportToSst(DBKey start, DBKey end, bool export_all_revisions,
 
     // Skip tombstone (len=0) records when start time is zero (non-incremental)
     // and we are not exporting all versions.
-    const bool is_skipping_deletes = start.wall_time == 0 && start.logical == 0 && !export_all_revisions;
+    const bool is_skipping_deletes =
+        start.wall_time == 0 && start.logical == 0 && !export_all_revisions;
     if (is_skipping_deletes && iter.value().size() == 0) {
       continue;
     }
@@ -1183,7 +1184,8 @@ DBStatus DBEnvOpenReadableFile(DBEngine* db, DBSlice path, DBReadableFile* file)
   return db->EnvOpenReadableFile(path, (rocksdb::RandomAccessFile**)file);
 }
 
-DBStatus DBEnvReadAtFile(DBEngine* db, DBReadableFile file, DBSlice buffer, int64_t offset, int* n) {
+DBStatus DBEnvReadAtFile(DBEngine* db, DBReadableFile file, DBSlice buffer, int64_t offset,
+                         int* n) {
   return db->EnvReadAtFile((rocksdb::RandomAccessFile*)file, buffer, offset, n);
 }
 

c-deps/libroach/engine.cc

@@ -467,7 +467,8 @@ DBStatus DBImpl::EnvCloseReadableFile(rocksdb::RandomAccessFile* file) {
   return kSuccess;
 }
 
-DBStatus DBImpl::EnvReadAtFile(rocksdb::RandomAccessFile* file, DBSlice buffer, int64_t offset, int* n) {
+DBStatus DBImpl::EnvReadAtFile(rocksdb::RandomAccessFile* file, DBSlice buffer, int64_t offset,
+                               int* n) {
   size_t max_bytes_to_read = buffer.len;
   char* scratch = buffer.data;
   rocksdb::Slice result;
@@ -488,9 +489,7 @@ DBStatus DBImpl::EnvOpenDirectory(DBSlice path, rocksdb::Directory** file) {
   return kSuccess;
 }
 
-DBStatus DBImpl::EnvSyncDirectory(rocksdb::Directory* file) {
-  return ToDBStatus(file->Fsync());
-}
+DBStatus DBImpl::EnvSyncDirectory(rocksdb::Directory* file) { return ToDBStatus(file->Fsync()); }
 
 DBStatus DBImpl::EnvCloseDirectory(rocksdb::Directory* file) {
   delete file;

c-deps/libroach/engine.h

@@ -51,13 +51,14 @@ struct DBEngine {
   virtual DBStatus EnvDeleteDirAndFiles(DBSlice dir) = 0;
   virtual DBStatus EnvLinkFile(DBSlice oldname, DBSlice newname) = 0;
   virtual DBStatus EnvOpenReadableFile(DBSlice path, rocksdb::RandomAccessFile** file) = 0;
-  virtual DBStatus EnvReadAtFile(rocksdb::RandomAccessFile* file, DBSlice buffer, int64_t offset, int* n) = 0;
+  virtual DBStatus EnvReadAtFile(rocksdb::RandomAccessFile* file, DBSlice buffer, int64_t offset,
+                                 int* n) = 0;
   virtual DBStatus EnvCloseReadableFile(rocksdb::RandomAccessFile* file) = 0;
   virtual DBStatus EnvOpenDirectory(DBSlice path, rocksdb::Directory** file) = 0;
   virtual DBStatus EnvSyncDirectory(rocksdb::Directory* file) = 0;
   virtual DBStatus EnvCloseDirectory(rocksdb::Directory* file) = 0;
   virtual DBStatus EnvRenameFile(DBSlice oldname, DBSlice newname) = 0;
-  
+
   DBSSTable* GetSSTables(int* n);
   DBStatus GetSortedWALFiles(DBWALFile** out_files, int* n);
   DBString GetUserProperties();
@@ -107,7 +108,8 @@ struct DBImpl : public DBEngine {
   virtual DBStatus EnvDeleteDirAndFiles(DBSlice dir);
   virtual DBStatus EnvLinkFile(DBSlice oldname, DBSlice newname);
   virtual DBStatus EnvOpenReadableFile(DBSlice path, rocksdb::RandomAccessFile** file);
-  virtual DBStatus EnvReadAtFile(rocksdb::RandomAccessFile* file, DBSlice buffer, int64_t offset, int* n);
+  virtual DBStatus EnvReadAtFile(rocksdb::RandomAccessFile* file, DBSlice buffer, int64_t offset,
+                                 int* n);
   virtual DBStatus EnvCloseReadableFile(rocksdb::RandomAccessFile* file);
   virtual DBStatus EnvOpenDirectory(DBSlice path, rocksdb::Directory** file);
   virtual DBStatus EnvSyncDirectory(rocksdb::Directory* file);