From e67b35c07625015e6510af3e655ff8f2365aa484 Mon Sep 17 00:00:00 2001 From: Siying Dong Date: Mon, 24 Jul 2017 10:28:17 -0700 Subject: [PATCH] Add Iterator::Refresh() Summary: Add and implement Iterator::Refresh(). When this function is called, if the super version doesn't change, update the sequence number of the iterator to the latest one and invalidate the iterator. If the super version changed, recreated the whole iterator. This can help users reuse the iterator more easily. Closes https://github.com/facebook/rocksdb/pull/2621 Differential Revision: D5464500 Pulled By: siying fbshipit-source-id: f548bd35e85c1efca2ea69273802f6704eba6ba9 --- HISTORY.md | 4 + db/db_impl.cc | 18 +-- db/db_impl.h | 13 +- db/db_impl_readonly.cc | 4 +- db/db_iter.cc | 96 +++++++++---- db/db_iter.h | 35 +++-- db/db_iter_test.cc | 138 +++++++++---------- db/db_iterator_test.cc | 59 ++++++++ include/rocksdb/iterator.h | 7 + utilities/date_tiered/date_tiered_db_impl.cc | 4 +- 10 files changed, 250 insertions(+), 128 deletions(-) diff --git a/HISTORY.md b/HISTORY.md index 3057684a0..7d9844372 100644 --- a/HISTORY.md +++ b/HISTORY.md @@ -1,4 +1,8 @@ # Rocksdb Change Log +## Unreleased +### New Features +* Add Iterator::Refresh(), which allows users to update the iterator state so that they can avoid some initialization costs of recreating iterators. + ## 5.7.0 (07/13/2017) ### Public API Change * DB property "rocksdb.sstables" now prints keys in hex form. diff --git a/db/db_impl.cc b/db/db_impl.cc index f770b51ae..bfe38302f 100644 --- a/db/db_impl.cc +++ b/db/db_impl.cc @@ -1402,8 +1402,7 @@ Iterator* DBImpl::NewIterator(const ReadOptions& read_options, return NewDBIterator( env_, read_options, *cfd->ioptions(), cfd->user_comparator(), iter, kMaxSequenceNumber, - sv->mutable_cf_options.max_sequential_skip_in_iterations, - sv->version_number); + sv->mutable_cf_options.max_sequential_skip_in_iterations); #endif } else { SequenceNumber latest_snapshot = versions_->LastSequence(); @@ -1458,9 +1457,10 @@ Iterator* DBImpl::NewIterator(const ReadOptions& read_options, // likely that any iterator pointer is close to the iterator it points to so // that they are likely to be in the same cache line and/or page. ArenaWrappedDBIter* db_iter = NewArenaWrappedDbIterator( - env_, read_options, *cfd->ioptions(), cfd->user_comparator(), snapshot, + env_, read_options, *cfd->ioptions(), snapshot, sv->mutable_cf_options.max_sequential_skip_in_iterations, - sv->version_number); + sv->version_number, + ((read_options.snapshot != nullptr) ? nullptr : this), cfd); InternalIterator* internal_iter = NewInternalIterator(read_options, cfd, sv, db_iter->GetArena(), @@ -1511,8 +1511,7 @@ Status DBImpl::NewIterators( iterators->push_back(NewDBIterator( env_, read_options, *cfd->ioptions(), cfd->user_comparator(), iter, kMaxSequenceNumber, - sv->mutable_cf_options.max_sequential_skip_in_iterations, - sv->version_number)); + sv->mutable_cf_options.max_sequential_skip_in_iterations)); } #endif } else { @@ -1530,9 +1529,10 @@ Status DBImpl::NewIterators( : latest_snapshot; ArenaWrappedDBIter* db_iter = NewArenaWrappedDbIterator( - env_, read_options, *cfd->ioptions(), cfd->user_comparator(), - snapshot, sv->mutable_cf_options.max_sequential_skip_in_iterations, - sv->version_number); + env_, read_options, *cfd->ioptions(), snapshot, + sv->mutable_cf_options.max_sequential_skip_in_iterations, + sv->version_number, + ((read_options.snapshot != nullptr) ? nullptr : this), cfd); InternalIterator* internal_iter = NewInternalIterator(read_options, cfd, sv, db_iter->GetArena(), db_iter->GetRangeDelAggregator()); diff --git a/db/db_impl.h b/db/db_impl.h index bc2072d7e..543d64ec8 100644 --- a/db/db_impl.h +++ b/db/db_impl.h @@ -494,6 +494,12 @@ class DBImpl : public DB { const WriteController& write_controller() { return write_controller_; } + InternalIterator* NewInternalIterator(const ReadOptions&, + ColumnFamilyData* cfd, + SuperVersion* super_version, + Arena* arena, + RangeDelAggregator* range_del_agg); + // hollow transactions shell used for recovery. // these will then be passed to TransactionDB so that // locks can be reacquired before writing can resume. @@ -552,6 +558,7 @@ class DBImpl : public DB { void AddToLogsToFreeQueue(log::Writer* log_writer) { logs_to_free_queue_.push_back(log_writer); } + InstrumentedMutex* mutex() { return &mutex_; } Status NewDB(); @@ -566,12 +573,6 @@ class DBImpl : public DB { std::unordered_map recovered_transactions_; - InternalIterator* NewInternalIterator(const ReadOptions&, - ColumnFamilyData* cfd, - SuperVersion* super_version, - Arena* arena, - RangeDelAggregator* range_del_agg); - // Except in DB::Open(), WriteOptionsFile can only be called when: // Persist options to options file. // If need_mutex_lock = false, the method will lock DB mutex. diff --git a/db/db_impl_readonly.cc b/db/db_impl_readonly.cc index d4fe7e702..d69eecb98 100644 --- a/db/db_impl_readonly.cc +++ b/db/db_impl_readonly.cc @@ -58,7 +58,7 @@ Iterator* DBImplReadOnly::NewIterator(const ReadOptions& read_options, SuperVersion* super_version = cfd->GetSuperVersion()->Ref(); SequenceNumber latest_snapshot = versions_->LastSequence(); auto db_iter = NewArenaWrappedDbIterator( - env_, read_options, *cfd->ioptions(), cfd->user_comparator(), + env_, read_options, *cfd->ioptions(), (read_options.snapshot != nullptr ? reinterpret_cast(read_options.snapshot) ->number_ @@ -87,7 +87,7 @@ Status DBImplReadOnly::NewIterators( auto* cfd = reinterpret_cast(cfh)->cfd(); auto* sv = cfd->GetSuperVersion()->Ref(); auto* db_iter = NewArenaWrappedDbIterator( - env_, read_options, *cfd->ioptions(), cfd->user_comparator(), + env_, read_options, *cfd->ioptions(), (read_options.snapshot != nullptr ? reinterpret_cast(read_options.snapshot) ->number_ diff --git a/db/db_iter.cc b/db/db_iter.cc index 7a22f573f..801b1102f 100644 --- a/db/db_iter.cc +++ b/db/db_iter.cc @@ -101,12 +101,12 @@ class DBIter: public Iterator { uint64_t bytes_read_; }; - DBIter(Env* env, const ReadOptions& read_options, + DBIter(Env* _env, const ReadOptions& read_options, const ImmutableCFOptions& cf_options, const Comparator* cmp, InternalIterator* iter, SequenceNumber s, bool arena_mode, - uint64_t max_sequential_skip_in_iterations, uint64_t version_number) + uint64_t max_sequential_skip_in_iterations) : arena_mode_(arena_mode), - env_(env), + env_(_env), logger_(cf_options.info_log), user_comparator_(cmp), merge_operator_(cf_options.merge_operator), @@ -116,7 +116,6 @@ class DBIter: public Iterator { valid_(false), current_entry_is_merged_(false), statistics_(cf_options.statistics), - version_number_(version_number), iterate_upper_bound_(read_options.iterate_upper_bound), prefix_same_as_start_(read_options.prefix_same_as_start), pin_thru_lifetime_(read_options.pin_data), @@ -188,10 +187,7 @@ class DBIter: public Iterator { } if (prop_name == "rocksdb.iterator.super-version-number") { // First try to pass the value returned from inner iterator. - if (!iter_->GetProperty(prop_name, prop).ok()) { - *prop = ToString(version_number_); - } - return Status::OK(); + return iter_->GetProperty(prop_name, prop); } else if (prop_name == "rocksdb.iterator.is-key-pinned") { if (valid_) { *prop = (pin_thru_lifetime_ && saved_key_.IsKeyPinned()) ? "1" : "0"; @@ -209,6 +205,9 @@ class DBIter: public Iterator { virtual void SeekForPrev(const Slice& target) override; virtual void SeekToFirst() override; virtual void SeekToLast() override; + Env* env() { return env_; } + void set_sequence(uint64_t s) { sequence_ = s; } + void set_valid(bool v) { valid_ = v; } private: void ReverseToForward(); @@ -260,7 +259,7 @@ class DBIter: public Iterator { const Comparator* const user_comparator_; const MergeOperator* const merge_operator_; InternalIterator* iter_; - SequenceNumber const sequence_; + SequenceNumber sequence_; Status status_; IterKey saved_key_; @@ -274,7 +273,6 @@ class DBIter: public Iterator { uint64_t max_skip_; uint64_t max_skippable_internal_keys_; uint64_t num_internal_keys_skipped_; - uint64_t version_number_; const Slice* iterate_upper_bound_; IterKey prefix_start_buf_; Slice prefix_start_key_; @@ -1157,18 +1155,15 @@ Iterator* NewDBIterator(Env* env, const ReadOptions& read_options, const Comparator* user_key_comparator, InternalIterator* internal_iter, const SequenceNumber& sequence, - uint64_t max_sequential_skip_in_iterations, - uint64_t version_number) { - DBIter* db_iter = new DBIter( - env, read_options, cf_options, user_key_comparator, internal_iter, - sequence, false, max_sequential_skip_in_iterations, version_number); + uint64_t max_sequential_skip_in_iterations) { + DBIter* db_iter = new DBIter(env, read_options, cf_options, + user_key_comparator, internal_iter, sequence, + false, max_sequential_skip_in_iterations); return db_iter; } ArenaWrappedDBIter::~ArenaWrappedDBIter() { db_iter_->~DBIter(); } -void ArenaWrappedDBIter::SetDBIter(DBIter* iter) { db_iter_ = iter; } - RangeDelAggregator* ArenaWrappedDBIter::GetRangeDelAggregator() { return db_iter_->GetRangeDelAggregator(); } @@ -1193,26 +1188,67 @@ inline Slice ArenaWrappedDBIter::value() const { return db_iter_->value(); } inline Status ArenaWrappedDBIter::status() const { return db_iter_->status(); } inline Status ArenaWrappedDBIter::GetProperty(std::string prop_name, 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()) { + *prop = ToString(sv_number_); + } + return Status::OK(); + } return db_iter_->GetProperty(prop_name, prop); } -void ArenaWrappedDBIter::RegisterCleanup(CleanupFunction function, void* arg1, - void* arg2) { - db_iter_->RegisterCleanup(function, arg1, arg2); + +void ArenaWrappedDBIter::Init(Env* env, const ReadOptions& read_options, + const ImmutableCFOptions& cf_options, + const SequenceNumber& sequence, + uint64_t max_sequential_skip_in_iteration, + uint64_t version_number) { + auto mem = arena_.AllocateAligned(sizeof(DBIter)); + db_iter_ = new (mem) + DBIter(env, read_options, cf_options, cf_options.user_comparator, nullptr, + sequence, true, max_sequential_skip_in_iteration); + sv_number_ = version_number; +} + +Status ArenaWrappedDBIter::Refresh() { + if (cfd_ == nullptr || db_impl_ == nullptr) { + return Status::NotSupported("Creating renew iterator is not allowed."); + } + assert(db_iter_ != nullptr); + SequenceNumber latest_seq = db_impl_->GetLatestSequenceNumber(); + uint64_t cur_sv_number = cfd_->GetSuperVersionNumber(); + if (sv_number_ != cur_sv_number) { + Env* env = db_iter_->env(); + db_iter_->~DBIter(); + arena_.~Arena(); + new (&arena_) Arena(); + + SuperVersion* sv = cfd_->GetReferencedSuperVersion(db_impl_->mutex()); + Init(env, read_options_, *(cfd_->ioptions()), latest_seq, + sv->mutable_cf_options.max_sequential_skip_in_iterations, + cur_sv_number); + + InternalIterator* internal_iter = db_impl_->NewInternalIterator( + read_options_, cfd_, sv, &arena_, db_iter_->GetRangeDelAggregator()); + SetIterUnderDBIter(internal_iter); + } else { + db_iter_->set_sequence(latest_seq); + db_iter_->set_valid(false); + } + return Status::OK(); } ArenaWrappedDBIter* NewArenaWrappedDbIterator( Env* env, const ReadOptions& read_options, - const ImmutableCFOptions& cf_options, const Comparator* user_key_comparator, - const SequenceNumber& sequence, uint64_t max_sequential_skip_in_iterations, - uint64_t version_number) { + const ImmutableCFOptions& cf_options, const SequenceNumber& sequence, + uint64_t max_sequential_skip_in_iterations, uint64_t version_number, + DBImpl* db_impl, ColumnFamilyData* cfd) { ArenaWrappedDBIter* iter = new ArenaWrappedDBIter(); - Arena* arena = iter->GetArena(); - auto mem = arena->AllocateAligned(sizeof(DBIter)); - DBIter* db_iter = new (mem) - DBIter(env, read_options, cf_options, user_key_comparator, nullptr, - sequence, true, max_sequential_skip_in_iterations, version_number); - - iter->SetDBIter(db_iter); + iter->Init(env, read_options, cf_options, sequence, + max_sequential_skip_in_iterations, version_number); + if (db_impl != nullptr && cfd != nullptr) { + iter->StoreRefreshInfo(read_options, db_impl, cfd); + } return iter; } diff --git a/db/db_iter.h b/db/db_iter.h index 833526440..ea98ff433 100644 --- a/db/db_iter.h +++ b/db/db_iter.h @@ -10,6 +10,7 @@ #pragma once #include #include +#include "db/db_impl.h" #include "db/dbformat.h" #include "db/range_del_aggregator.h" #include "options/cf_options.h" @@ -32,8 +33,7 @@ extern Iterator* NewDBIterator(Env* env, const ReadOptions& read_options, const Comparator* user_key_comparator, InternalIterator* internal_iter, const SequenceNumber& sequence, - uint64_t max_sequential_skip_in_iterations, - uint64_t version_number); + uint64_t max_sequential_skip_in_iterations); // A wrapper iterator which wraps DB Iterator and the arena, with which the DB // iterator is supposed be allocated. This class is used as an entry point of @@ -49,10 +49,6 @@ class ArenaWrappedDBIter : public Iterator { virtual Arena* GetArena() { return &arena_; } virtual RangeDelAggregator* GetRangeDelAggregator(); - // Set the DB Iterator to be wrapped - - virtual void SetDBIter(DBIter* iter); - // Set the internal iterator wrapped inside the DB Iterator. Usually it is // a merging iterator. virtual void SetIterUnderDBIter(InternalIterator* iter); @@ -66,20 +62,39 @@ class ArenaWrappedDBIter : public Iterator { virtual Slice key() const override; virtual Slice value() const override; virtual Status status() const override; + virtual Status Refresh() override; - void RegisterCleanup(CleanupFunction function, void* arg1, void* arg2); virtual Status GetProperty(std::string prop_name, std::string* prop) override; + void Init(Env* env, const ReadOptions& read_options, + const ImmutableCFOptions& cf_options, + const SequenceNumber& sequence, + uint64_t max_sequential_skip_in_iterations, + uint64_t version_number); + + void StoreRefreshInfo(const ReadOptions& read_options, DBImpl* db_impl, + ColumnFamilyData* cfd) { + read_options_ = read_options; + db_impl_ = db_impl; + cfd_ = cfd; + } + private: DBIter* db_iter_; Arena arena_; + uint64_t sv_number_; + ColumnFamilyData* cfd_ = nullptr; + DBImpl* db_impl_ = nullptr; + ReadOptions read_options_; }; // Generate the arena wrapped iterator class. +// `db_impl` and `cfd` are used for reneweal. If left null, renewal will not +// be supported. extern ArenaWrappedDBIter* NewArenaWrappedDbIterator( Env* env, const ReadOptions& read_options, - const ImmutableCFOptions& cf_options, const Comparator* user_key_comparator, - const SequenceNumber& sequence, uint64_t max_sequential_skip_in_iterations, - uint64_t version_number); + const ImmutableCFOptions& cf_options, const SequenceNumber& sequence, + uint64_t max_sequential_skip_in_iterations, uint64_t version_number, + DBImpl* db_impl = nullptr, ColumnFamilyData* cfd = nullptr); } // namespace rocksdb diff --git a/db/db_iter_test.cc b/db/db_iter_test.cc index 1b7c13b06..6db3b4a9b 100644 --- a/db/db_iter_test.cc +++ b/db/db_iter_test.cc @@ -193,7 +193,7 @@ TEST_F(DBIteratorTest, DBIteratorPrevNext) { ReadOptions ro; std::unique_ptr db_iter( NewDBIterator(env_, ro, cf_options, BytewiseComparator(), internal_iter, - 10, options.max_sequential_skip_in_iterations, 0)); + 10, options.max_sequential_skip_in_iterations)); db_iter->SeekToLast(); ASSERT_TRUE(db_iter->Valid()); @@ -225,7 +225,7 @@ TEST_F(DBIteratorTest, DBIteratorPrevNext) { ReadOptions ro; std::unique_ptr db_iter( NewDBIterator(env_, ro, cf_options, BytewiseComparator(), internal_iter, - 10, options.max_sequential_skip_in_iterations, 0)); + 10, options.max_sequential_skip_in_iterations)); db_iter->SeekToLast(); ASSERT_TRUE(db_iter->Valid()); @@ -251,7 +251,7 @@ TEST_F(DBIteratorTest, DBIteratorPrevNext) { std::unique_ptr db_iter( NewDBIterator(env_, ro, cf_options, BytewiseComparator(), internal_iter, - 10, options.max_sequential_skip_in_iterations, 0)); + 10, options.max_sequential_skip_in_iterations)); db_iter->SeekToLast(); ASSERT_TRUE(db_iter->Valid()); @@ -283,7 +283,7 @@ TEST_F(DBIteratorTest, DBIteratorPrevNext) { std::unique_ptr db_iter( NewDBIterator(env_, ro, cf_options, BytewiseComparator(), internal_iter, - 10, options.max_sequential_skip_in_iterations, 0)); + 10, options.max_sequential_skip_in_iterations)); db_iter->SeekToLast(); ASSERT_TRUE(db_iter->Valid()); @@ -318,7 +318,7 @@ TEST_F(DBIteratorTest, DBIteratorPrevNext) { std::unique_ptr db_iter( NewDBIterator(env_, ro, cf_options, BytewiseComparator(), internal_iter, - 10, options.max_sequential_skip_in_iterations, 0)); + 10, options.max_sequential_skip_in_iterations)); db_iter->SeekToLast(); ASSERT_TRUE(!db_iter->Valid()); @@ -347,7 +347,7 @@ TEST_F(DBIteratorTest, DBIteratorPrevNext) { std::unique_ptr db_iter( NewDBIterator(env_, ro, cf_options, BytewiseComparator(), internal_iter, - 7, options.max_sequential_skip_in_iterations, 0)); + 7, options.max_sequential_skip_in_iterations)); SetPerfLevel(kEnableCount); ASSERT_TRUE(GetPerfLevel() == kEnableCount); @@ -384,7 +384,7 @@ TEST_F(DBIteratorTest, DBIteratorPrevNext) { std::unique_ptr db_iter( NewDBIterator(env_, ro, cf_options, BytewiseComparator(), internal_iter, - 4, options.max_sequential_skip_in_iterations, 0)); + 4, options.max_sequential_skip_in_iterations)); db_iter->SeekToLast(); ASSERT_TRUE(db_iter->Valid()); @@ -409,7 +409,7 @@ TEST_F(DBIteratorTest, DBIteratorPrevNext) { std::unique_ptr db_iter( NewDBIterator(env_, ro, cf_options, BytewiseComparator(), internal_iter, - 10, options.max_sequential_skip_in_iterations, 0)); + 10, options.max_sequential_skip_in_iterations)); db_iter->SeekToLast(); ASSERT_TRUE(!db_iter->Valid()); @@ -431,7 +431,7 @@ TEST_F(DBIteratorTest, DBIteratorPrevNext) { std::unique_ptr db_iter( NewDBIterator(env_, ro, cf_options, BytewiseComparator(), internal_iter, - 10, options.max_sequential_skip_in_iterations, 0)); + 10, options.max_sequential_skip_in_iterations)); db_iter->SeekToLast(); ASSERT_TRUE(db_iter->Valid()); @@ -466,7 +466,7 @@ TEST_F(DBIteratorTest, DBIteratorPrevNext) { std::unique_ptr db_iter( NewDBIterator(env_, ro, cf_options, BytewiseComparator(), internal_iter, - 7, options.max_sequential_skip_in_iterations, 0)); + 7, options.max_sequential_skip_in_iterations)); SetPerfLevel(kEnableCount); ASSERT_TRUE(GetPerfLevel() == kEnableCount); @@ -495,7 +495,7 @@ TEST_F(DBIteratorTest, DBIteratorPrevNext) { ReadOptions ro; std::unique_ptr db_iter( NewDBIterator(env_, ro, cf_options, BytewiseComparator(), internal_iter, - 10, options.max_sequential_skip_in_iterations, 0)); + 10, options.max_sequential_skip_in_iterations)); db_iter->SeekToFirst(); ASSERT_TRUE(db_iter->Valid()); @@ -537,7 +537,7 @@ TEST_F(DBIteratorTest, DBIteratorPrevNext) { ReadOptions ro; std::unique_ptr db_iter( NewDBIterator(env_, ro, cf_options, BytewiseComparator(), internal_iter, - 2, options.max_sequential_skip_in_iterations, 0)); + 2, options.max_sequential_skip_in_iterations)); db_iter->SeekToLast(); ASSERT_TRUE(db_iter->Valid()); ASSERT_EQ(db_iter->key().ToString(), "b"); @@ -568,7 +568,7 @@ TEST_F(DBIteratorTest, DBIteratorPrevNext) { ReadOptions ro; std::unique_ptr db_iter( NewDBIterator(env_, ro, cf_options, BytewiseComparator(), internal_iter, - 10, options.max_sequential_skip_in_iterations, 0)); + 10, options.max_sequential_skip_in_iterations)); db_iter->SeekToLast(); ASSERT_TRUE(db_iter->Valid()); ASSERT_EQ(db_iter->key().ToString(), "c"); @@ -597,7 +597,7 @@ TEST_F(DBIteratorTest, DBIteratorEmpty) { std::unique_ptr db_iter( NewDBIterator(env_, ro, cf_options, BytewiseComparator(), internal_iter, - 0, options.max_sequential_skip_in_iterations, 0)); + 0, options.max_sequential_skip_in_iterations)); db_iter->SeekToLast(); ASSERT_TRUE(!db_iter->Valid()); } @@ -608,7 +608,7 @@ TEST_F(DBIteratorTest, DBIteratorEmpty) { std::unique_ptr db_iter( NewDBIterator(env_, ro, cf_options, BytewiseComparator(), internal_iter, - 0, options.max_sequential_skip_in_iterations, 0)); + 0, options.max_sequential_skip_in_iterations)); db_iter->SeekToFirst(); ASSERT_TRUE(!db_iter->Valid()); } @@ -630,7 +630,7 @@ TEST_F(DBIteratorTest, DBIteratorUseSkipCountSkips) { std::unique_ptr db_iter(NewDBIterator( env_, ro, ImmutableCFOptions(options), BytewiseComparator(), - internal_iter, 2, options.max_sequential_skip_in_iterations, 0)); + internal_iter, 2, options.max_sequential_skip_in_iterations)); db_iter->SeekToLast(); ASSERT_TRUE(db_iter->Valid()); ASSERT_EQ(db_iter->key().ToString(), "c"); @@ -673,7 +673,7 @@ TEST_F(DBIteratorTest, DBIteratorUseSkip) { options.statistics = rocksdb::CreateDBStatistics(); std::unique_ptr db_iter(NewDBIterator( env_, ro, cf_options, BytewiseComparator(), internal_iter, i + 2, - options.max_sequential_skip_in_iterations, 0)); + options.max_sequential_skip_in_iterations)); db_iter->SeekToLast(); ASSERT_TRUE(db_iter->Valid()); @@ -708,7 +708,7 @@ TEST_F(DBIteratorTest, DBIteratorUseSkip) { std::unique_ptr db_iter(NewDBIterator( env_, ro, cf_options, BytewiseComparator(), internal_iter, i + 2, - options.max_sequential_skip_in_iterations, 0)); + options.max_sequential_skip_in_iterations)); db_iter->SeekToLast(); ASSERT_TRUE(db_iter->Valid()); @@ -736,7 +736,7 @@ TEST_F(DBIteratorTest, DBIteratorUseSkip) { std::unique_ptr db_iter(NewDBIterator( env_, ro, cf_options, BytewiseComparator(), internal_iter, 202, - options.max_sequential_skip_in_iterations, 0)); + options.max_sequential_skip_in_iterations)); db_iter->SeekToLast(); ASSERT_TRUE(db_iter->Valid()); @@ -768,7 +768,7 @@ TEST_F(DBIteratorTest, DBIteratorUseSkip) { internal_iter->Finish(); std::unique_ptr db_iter(NewDBIterator( env_, ro, cf_options, BytewiseComparator(), internal_iter, i, - options.max_sequential_skip_in_iterations, 0)); + options.max_sequential_skip_in_iterations)); db_iter->SeekToLast(); ASSERT_TRUE(!db_iter->Valid()); @@ -784,7 +784,7 @@ TEST_F(DBIteratorTest, DBIteratorUseSkip) { internal_iter->Finish(); std::unique_ptr db_iter( NewDBIterator(env_, ro, cf_options, BytewiseComparator(), internal_iter, - 200, options.max_sequential_skip_in_iterations, 0)); + 200, options.max_sequential_skip_in_iterations)); db_iter->SeekToLast(); ASSERT_TRUE(db_iter->Valid()); ASSERT_EQ(db_iter->key().ToString(), "c"); @@ -818,7 +818,7 @@ TEST_F(DBIteratorTest, DBIteratorUseSkip) { std::unique_ptr db_iter(NewDBIterator( env_, ro, cf_options, BytewiseComparator(), internal_iter, i + 2, - options.max_sequential_skip_in_iterations, 0)); + options.max_sequential_skip_in_iterations)); db_iter->SeekToLast(); ASSERT_TRUE(db_iter->Valid()); @@ -852,7 +852,7 @@ TEST_F(DBIteratorTest, DBIteratorUseSkip) { std::unique_ptr db_iter(NewDBIterator( env_, ro, cf_options, BytewiseComparator(), internal_iter, i + 2, - options.max_sequential_skip_in_iterations, 0)); + options.max_sequential_skip_in_iterations)); db_iter->SeekToLast(); ASSERT_TRUE(db_iter->Valid()); @@ -900,7 +900,7 @@ TEST_F(DBIteratorTest, DBIteratorSkipInternalKeys) { ro.max_skippable_internal_keys = 0; std::unique_ptr db_iter( NewDBIterator(env_, ro, cf_options, BytewiseComparator(), internal_iter, - 10, options.max_sequential_skip_in_iterations, 0)); + 10, options.max_sequential_skip_in_iterations)); db_iter->SeekToFirst(); ASSERT_TRUE(db_iter->Valid()); @@ -946,7 +946,7 @@ TEST_F(DBIteratorTest, DBIteratorSkipInternalKeys) { ro.max_skippable_internal_keys = 2; std::unique_ptr db_iter( NewDBIterator(env_, ro, cf_options, BytewiseComparator(), internal_iter, - 10, options.max_sequential_skip_in_iterations, 0)); + 10, options.max_sequential_skip_in_iterations)); db_iter->SeekToFirst(); ASSERT_TRUE(db_iter->Valid()); @@ -990,7 +990,7 @@ TEST_F(DBIteratorTest, DBIteratorSkipInternalKeys) { ro.max_skippable_internal_keys = 2; std::unique_ptr db_iter( NewDBIterator(env_, ro, cf_options, BytewiseComparator(), internal_iter, - 10, options.max_sequential_skip_in_iterations, 0)); + 10, options.max_sequential_skip_in_iterations)); db_iter->SeekToFirst(); ASSERT_TRUE(db_iter->Valid()); @@ -1028,7 +1028,7 @@ TEST_F(DBIteratorTest, DBIteratorSkipInternalKeys) { ro.max_skippable_internal_keys = 2; std::unique_ptr db_iter( NewDBIterator(env_, ro, cf_options, BytewiseComparator(), internal_iter, - 10, options.max_sequential_skip_in_iterations, 0)); + 10, options.max_sequential_skip_in_iterations)); db_iter->SeekToFirst(); ASSERT_TRUE(db_iter->Valid()); @@ -1063,7 +1063,7 @@ TEST_F(DBIteratorTest, DBIteratorSkipInternalKeys) { ro.max_skippable_internal_keys = 2; std::unique_ptr db_iter( NewDBIterator(env_, ro, cf_options, BytewiseComparator(), internal_iter, - 10, options.max_sequential_skip_in_iterations, 0)); + 10, options.max_sequential_skip_in_iterations)); db_iter->SeekToLast(); ASSERT_TRUE(db_iter->Valid()); @@ -1093,7 +1093,7 @@ TEST_F(DBIteratorTest, DBIteratorSkipInternalKeys) { ro.max_skippable_internal_keys = 2; std::unique_ptr db_iter( NewDBIterator(env_, ro, cf_options, BytewiseComparator(), internal_iter, - 10, options.max_sequential_skip_in_iterations, 0)); + 10, options.max_sequential_skip_in_iterations)); db_iter->SeekToFirst(); ASSERT_TRUE(db_iter->Valid()); @@ -1130,7 +1130,7 @@ TEST_F(DBIteratorTest, DBIteratorSkipInternalKeys) { ro.max_skippable_internal_keys = 2; std::unique_ptr db_iter( NewDBIterator(env_, ro, cf_options, BytewiseComparator(), internal_iter, - 10, options.max_sequential_skip_in_iterations, 0)); + 10, options.max_sequential_skip_in_iterations)); db_iter->SeekToFirst(); ASSERT_TRUE(db_iter->Valid()); @@ -1167,7 +1167,7 @@ TEST_F(DBIteratorTest, DBIteratorSkipInternalKeys) { ro.max_skippable_internal_keys = i; std::unique_ptr db_iter(NewDBIterator( env_, ro, cf_options, BytewiseComparator(), internal_iter, 2 * i + 1, - options.max_sequential_skip_in_iterations, 0)); + options.max_sequential_skip_in_iterations)); db_iter->SeekToFirst(); ASSERT_TRUE(db_iter->Valid()); @@ -1220,7 +1220,7 @@ TEST_F(DBIteratorTest, DBIteratorSkipInternalKeys) { ro.max_skippable_internal_keys = i; std::unique_ptr db_iter(NewDBIterator( env_, ro, cf_options, BytewiseComparator(), internal_iter, 2 * i + 1, - options.max_sequential_skip_in_iterations, 0)); + options.max_sequential_skip_in_iterations)); db_iter->SeekToFirst(); ASSERT_TRUE(db_iter->Valid()); @@ -1258,7 +1258,7 @@ TEST_F(DBIteratorTest, DBIterator1) { std::unique_ptr db_iter(NewDBIterator( env_, ro, ImmutableCFOptions(options), BytewiseComparator(), - internal_iter, 1, options.max_sequential_skip_in_iterations, 0)); + internal_iter, 1, options.max_sequential_skip_in_iterations)); db_iter->SeekToFirst(); ASSERT_TRUE(db_iter->Valid()); ASSERT_EQ(db_iter->key().ToString(), "a"); @@ -1285,7 +1285,7 @@ TEST_F(DBIteratorTest, DBIterator2) { std::unique_ptr db_iter(NewDBIterator( env_, ro, ImmutableCFOptions(options), BytewiseComparator(), - internal_iter, 0, options.max_sequential_skip_in_iterations, 0)); + internal_iter, 0, options.max_sequential_skip_in_iterations)); db_iter->SeekToFirst(); ASSERT_TRUE(db_iter->Valid()); ASSERT_EQ(db_iter->key().ToString(), "a"); @@ -1309,7 +1309,7 @@ TEST_F(DBIteratorTest, DBIterator3) { std::unique_ptr db_iter(NewDBIterator( env_, ro, ImmutableCFOptions(options), BytewiseComparator(), - internal_iter, 2, options.max_sequential_skip_in_iterations, 0)); + internal_iter, 2, options.max_sequential_skip_in_iterations)); db_iter->SeekToFirst(); ASSERT_TRUE(db_iter->Valid()); ASSERT_EQ(db_iter->key().ToString(), "a"); @@ -1333,7 +1333,7 @@ TEST_F(DBIteratorTest, DBIterator4) { std::unique_ptr db_iter(NewDBIterator( env_, ro, ImmutableCFOptions(options), BytewiseComparator(), - internal_iter, 4, options.max_sequential_skip_in_iterations, 0)); + internal_iter, 4, options.max_sequential_skip_in_iterations)); db_iter->SeekToFirst(); ASSERT_TRUE(db_iter->Valid()); ASSERT_EQ(db_iter->key().ToString(), "a"); @@ -1365,7 +1365,7 @@ TEST_F(DBIteratorTest, DBIterator5) { std::unique_ptr db_iter( NewDBIterator(env_, ro, cf_options, BytewiseComparator(), internal_iter, - 0, options.max_sequential_skip_in_iterations, 0)); + 0, options.max_sequential_skip_in_iterations)); db_iter->SeekToLast(); ASSERT_TRUE(db_iter->Valid()); ASSERT_EQ(db_iter->key().ToString(), "a"); @@ -1387,7 +1387,7 @@ TEST_F(DBIteratorTest, DBIterator5) { std::unique_ptr db_iter( NewDBIterator(env_, ro, cf_options, BytewiseComparator(), internal_iter, - 1, options.max_sequential_skip_in_iterations, 0)); + 1, options.max_sequential_skip_in_iterations)); db_iter->SeekToLast(); ASSERT_TRUE(db_iter->Valid()); ASSERT_EQ(db_iter->key().ToString(), "a"); @@ -1409,7 +1409,7 @@ TEST_F(DBIteratorTest, DBIterator5) { std::unique_ptr db_iter( NewDBIterator(env_, ro, cf_options, BytewiseComparator(), internal_iter, - 2, options.max_sequential_skip_in_iterations, 0)); + 2, options.max_sequential_skip_in_iterations)); db_iter->SeekToLast(); ASSERT_TRUE(db_iter->Valid()); ASSERT_EQ(db_iter->key().ToString(), "a"); @@ -1431,7 +1431,7 @@ TEST_F(DBIteratorTest, DBIterator5) { std::unique_ptr db_iter( NewDBIterator(env_, ro, cf_options, BytewiseComparator(), internal_iter, - 3, options.max_sequential_skip_in_iterations, 0)); + 3, options.max_sequential_skip_in_iterations)); db_iter->SeekToLast(); ASSERT_TRUE(db_iter->Valid()); ASSERT_EQ(db_iter->key().ToString(), "a"); @@ -1453,7 +1453,7 @@ TEST_F(DBIteratorTest, DBIterator5) { std::unique_ptr db_iter( NewDBIterator(env_, ro, cf_options, BytewiseComparator(), internal_iter, - 4, options.max_sequential_skip_in_iterations, 0)); + 4, options.max_sequential_skip_in_iterations)); db_iter->SeekToLast(); ASSERT_TRUE(db_iter->Valid()); ASSERT_EQ(db_iter->key().ToString(), "a"); @@ -1475,7 +1475,7 @@ TEST_F(DBIteratorTest, DBIterator5) { std::unique_ptr db_iter( NewDBIterator(env_, ro, cf_options, BytewiseComparator(), internal_iter, - 5, options.max_sequential_skip_in_iterations, 0)); + 5, options.max_sequential_skip_in_iterations)); db_iter->SeekToLast(); ASSERT_TRUE(db_iter->Valid()); ASSERT_EQ(db_iter->key().ToString(), "a"); @@ -1497,7 +1497,7 @@ TEST_F(DBIteratorTest, DBIterator5) { std::unique_ptr db_iter( NewDBIterator(env_, ro, cf_options, BytewiseComparator(), internal_iter, - 6, options.max_sequential_skip_in_iterations, 0)); + 6, options.max_sequential_skip_in_iterations)); db_iter->SeekToLast(); ASSERT_TRUE(db_iter->Valid()); ASSERT_EQ(db_iter->key().ToString(), "a"); @@ -1517,7 +1517,7 @@ TEST_F(DBIteratorTest, DBIterator5) { internal_iter->Finish(); std::unique_ptr db_iter( NewDBIterator(env_, ro, cf_options, BytewiseComparator(), internal_iter, - 10, options.max_sequential_skip_in_iterations, 0)); + 10, options.max_sequential_skip_in_iterations)); db_iter->Seek("b"); ASSERT_TRUE(db_iter->Valid()); ASSERT_EQ(db_iter->key().ToString(), "b"); @@ -1546,7 +1546,7 @@ TEST_F(DBIteratorTest, DBIterator6) { std::unique_ptr db_iter( NewDBIterator(env_, ro, cf_options, BytewiseComparator(), internal_iter, - 0, options.max_sequential_skip_in_iterations, 0)); + 0, options.max_sequential_skip_in_iterations)); db_iter->SeekToLast(); ASSERT_TRUE(db_iter->Valid()); ASSERT_EQ(db_iter->key().ToString(), "a"); @@ -1568,7 +1568,7 @@ TEST_F(DBIteratorTest, DBIterator6) { std::unique_ptr db_iter( NewDBIterator(env_, ro, cf_options, BytewiseComparator(), internal_iter, - 1, options.max_sequential_skip_in_iterations, 0)); + 1, options.max_sequential_skip_in_iterations)); db_iter->SeekToLast(); ASSERT_TRUE(db_iter->Valid()); ASSERT_EQ(db_iter->key().ToString(), "a"); @@ -1590,7 +1590,7 @@ TEST_F(DBIteratorTest, DBIterator6) { std::unique_ptr db_iter( NewDBIterator(env_, ro, cf_options, BytewiseComparator(), internal_iter, - 2, options.max_sequential_skip_in_iterations, 0)); + 2, options.max_sequential_skip_in_iterations)); db_iter->SeekToLast(); ASSERT_TRUE(db_iter->Valid()); ASSERT_EQ(db_iter->key().ToString(), "a"); @@ -1612,7 +1612,7 @@ TEST_F(DBIteratorTest, DBIterator6) { std::unique_ptr db_iter( NewDBIterator(env_, ro, cf_options, BytewiseComparator(), internal_iter, - 3, options.max_sequential_skip_in_iterations, 0)); + 3, options.max_sequential_skip_in_iterations)); db_iter->SeekToLast(); ASSERT_TRUE(!db_iter->Valid()); } @@ -1630,7 +1630,7 @@ TEST_F(DBIteratorTest, DBIterator6) { std::unique_ptr db_iter( NewDBIterator(env_, ro, cf_options, BytewiseComparator(), internal_iter, - 4, options.max_sequential_skip_in_iterations, 0)); + 4, options.max_sequential_skip_in_iterations)); db_iter->SeekToLast(); ASSERT_TRUE(db_iter->Valid()); ASSERT_EQ(db_iter->key().ToString(), "a"); @@ -1652,7 +1652,7 @@ TEST_F(DBIteratorTest, DBIterator6) { std::unique_ptr db_iter( NewDBIterator(env_, ro, cf_options, BytewiseComparator(), internal_iter, - 5, options.max_sequential_skip_in_iterations, 0)); + 5, options.max_sequential_skip_in_iterations)); db_iter->SeekToLast(); ASSERT_TRUE(db_iter->Valid()); ASSERT_EQ(db_iter->key().ToString(), "a"); @@ -1674,7 +1674,7 @@ TEST_F(DBIteratorTest, DBIterator6) { std::unique_ptr db_iter( NewDBIterator(env_, ro, cf_options, BytewiseComparator(), internal_iter, - 6, options.max_sequential_skip_in_iterations, 0)); + 6, options.max_sequential_skip_in_iterations)); db_iter->SeekToLast(); ASSERT_TRUE(db_iter->Valid()); ASSERT_EQ(db_iter->key().ToString(), "a"); @@ -1715,7 +1715,7 @@ TEST_F(DBIteratorTest, DBIterator7) { std::unique_ptr db_iter( NewDBIterator(env_, ro, cf_options, BytewiseComparator(), internal_iter, - 0, options.max_sequential_skip_in_iterations, 0)); + 0, options.max_sequential_skip_in_iterations)); db_iter->SeekToLast(); ASSERT_TRUE(db_iter->Valid()); ASSERT_EQ(db_iter->key().ToString(), "a"); @@ -1749,7 +1749,7 @@ TEST_F(DBIteratorTest, DBIterator7) { std::unique_ptr db_iter( NewDBIterator(env_, ro, cf_options, BytewiseComparator(), internal_iter, - 2, options.max_sequential_skip_in_iterations, 0)); + 2, options.max_sequential_skip_in_iterations)); db_iter->SeekToLast(); ASSERT_TRUE(db_iter->Valid()); @@ -1789,7 +1789,7 @@ TEST_F(DBIteratorTest, DBIterator7) { std::unique_ptr db_iter( NewDBIterator(env_, ro, cf_options, BytewiseComparator(), internal_iter, - 4, options.max_sequential_skip_in_iterations, 0)); + 4, options.max_sequential_skip_in_iterations)); db_iter->SeekToLast(); ASSERT_TRUE(db_iter->Valid()); @@ -1829,7 +1829,7 @@ TEST_F(DBIteratorTest, DBIterator7) { std::unique_ptr db_iter( NewDBIterator(env_, ro, cf_options, BytewiseComparator(), internal_iter, - 5, options.max_sequential_skip_in_iterations, 0)); + 5, options.max_sequential_skip_in_iterations)); db_iter->SeekToLast(); ASSERT_TRUE(db_iter->Valid()); @@ -1874,7 +1874,7 @@ TEST_F(DBIteratorTest, DBIterator7) { std::unique_ptr db_iter( NewDBIterator(env_, ro, cf_options, BytewiseComparator(), internal_iter, - 6, options.max_sequential_skip_in_iterations, 0)); + 6, options.max_sequential_skip_in_iterations)); db_iter->SeekToLast(); ASSERT_TRUE(db_iter->Valid()); @@ -1920,7 +1920,7 @@ TEST_F(DBIteratorTest, DBIterator7) { std::unique_ptr db_iter( NewDBIterator(env_, ro, cf_options, BytewiseComparator(), internal_iter, - 7, options.max_sequential_skip_in_iterations, 0)); + 7, options.max_sequential_skip_in_iterations)); db_iter->SeekToLast(); ASSERT_TRUE(db_iter->Valid()); @@ -1960,7 +1960,7 @@ TEST_F(DBIteratorTest, DBIterator7) { std::unique_ptr db_iter( NewDBIterator(env_, ro, cf_options, BytewiseComparator(), internal_iter, - 9, options.max_sequential_skip_in_iterations, 0)); + 9, options.max_sequential_skip_in_iterations)); db_iter->SeekToLast(); ASSERT_TRUE(db_iter->Valid()); @@ -2006,7 +2006,7 @@ TEST_F(DBIteratorTest, DBIterator7) { std::unique_ptr db_iter( NewDBIterator(env_, ro, cf_options, BytewiseComparator(), internal_iter, - 13, options.max_sequential_skip_in_iterations, 0)); + 13, options.max_sequential_skip_in_iterations)); db_iter->SeekToLast(); ASSERT_TRUE(db_iter->Valid()); @@ -2053,7 +2053,7 @@ TEST_F(DBIteratorTest, DBIterator7) { std::unique_ptr db_iter( NewDBIterator(env_, ro, cf_options, BytewiseComparator(), internal_iter, - 14, options.max_sequential_skip_in_iterations, 0)); + 14, options.max_sequential_skip_in_iterations)); db_iter->SeekToLast(); ASSERT_TRUE(db_iter->Valid()); @@ -2083,7 +2083,7 @@ TEST_F(DBIteratorTest, DBIterator8) { std::unique_ptr db_iter(NewDBIterator( env_, ro, ImmutableCFOptions(options), BytewiseComparator(), - internal_iter, 10, options.max_sequential_skip_in_iterations, 0)); + internal_iter, 10, options.max_sequential_skip_in_iterations)); db_iter->SeekToLast(); ASSERT_TRUE(db_iter->Valid()); ASSERT_EQ(db_iter->key().ToString(), "b"); @@ -2113,7 +2113,7 @@ TEST_F(DBIteratorTest, DBIterator9) { std::unique_ptr db_iter(NewDBIterator( env_, ro, ImmutableCFOptions(options), BytewiseComparator(), - internal_iter, 10, options.max_sequential_skip_in_iterations, 0)); + internal_iter, 10, options.max_sequential_skip_in_iterations)); db_iter->SeekToLast(); ASSERT_TRUE(db_iter->Valid()); @@ -2179,7 +2179,7 @@ TEST_F(DBIteratorTest, DBIterator10) { std::unique_ptr db_iter(NewDBIterator( env_, ro, ImmutableCFOptions(options), BytewiseComparator(), - internal_iter, 10, options.max_sequential_skip_in_iterations, 0)); + internal_iter, 10, options.max_sequential_skip_in_iterations)); db_iter->Seek("c"); ASSERT_TRUE(db_iter->Valid()); @@ -2218,7 +2218,7 @@ TEST_F(DBIteratorTest, SeekToLastOccurrenceSeq0) { std::unique_ptr db_iter( NewDBIterator(env_, ro, ImmutableCFOptions(options), BytewiseComparator(), - internal_iter, 10, 0 /* force seek */, 0)); + internal_iter, 10, 0 /* force seek */)); db_iter->SeekToFirst(); ASSERT_TRUE(db_iter->Valid()); ASSERT_EQ(db_iter->key().ToString(), "a"); @@ -2246,7 +2246,7 @@ TEST_F(DBIteratorTest, DBIterator11) { std::unique_ptr db_iter(NewDBIterator( env_, ro, ImmutableCFOptions(options), BytewiseComparator(), - internal_iter, 1, options.max_sequential_skip_in_iterations, 0)); + internal_iter, 1, options.max_sequential_skip_in_iterations)); db_iter->SeekToFirst(); ASSERT_TRUE(db_iter->Valid()); ASSERT_EQ(db_iter->key().ToString(), "a"); @@ -2272,7 +2272,7 @@ TEST_F(DBIteratorTest, DBIterator12) { std::unique_ptr db_iter( NewDBIterator(env_, ro, ImmutableCFOptions(options), BytewiseComparator(), - internal_iter, 10, 0, 0)); + internal_iter, 10, 0)); db_iter->SeekToLast(); ASSERT_TRUE(db_iter->Valid()); ASSERT_EQ(db_iter->key().ToString(), "c"); @@ -2309,7 +2309,7 @@ TEST_F(DBIteratorTest, DBIterator13) { std::unique_ptr db_iter( NewDBIterator(env_, ro, ImmutableCFOptions(options), BytewiseComparator(), - internal_iter, 2, 3, 0)); + internal_iter, 2, 3)); db_iter->Seek("b"); ASSERT_TRUE(db_iter->Valid()); ASSERT_EQ(db_iter->key().ToString(), key); @@ -2337,7 +2337,7 @@ TEST_F(DBIteratorTest, DBIterator14) { std::unique_ptr db_iter( NewDBIterator(env_, ro, ImmutableCFOptions(options), BytewiseComparator(), - internal_iter, 4, 1, 0)); + internal_iter, 4, 1)); db_iter->Seek("b"); ASSERT_TRUE(db_iter->Valid()); ASSERT_EQ(db_iter->key().ToString(), "b"); @@ -2376,7 +2376,7 @@ class DBIterWithMergeIterTest : public testing::Test { db_iter_.reset(NewDBIterator(env_, ro_, ImmutableCFOptions(options_), BytewiseComparator(), merge_iter, 8 /* read data earlier than seqId 8 */, - 3 /* max iterators before reseek */, 0)); + 3 /* max iterators before reseek */)); } Env* env_; diff --git a/db/db_iterator_test.cc b/db/db_iterator_test.cc index 90f43ea37..ea65f3a26 100644 --- a/db/db_iterator_test.cc +++ b/db/db_iterator_test.cc @@ -1909,6 +1909,65 @@ TEST_F(DBIteratorTest, DBIteratorSkipRecentDuplicatesTest) { NUMBER_OF_RESEEKS_IN_ITERATION)); } +TEST_F(DBIteratorTest, Refresh) { + ASSERT_OK(Put("x", "y")); + + std::unique_ptr iter(db_->NewIterator(ReadOptions())); + iter->Seek(Slice("a")); + ASSERT_TRUE(iter->Valid()); + ASSERT_EQ(iter->key().compare(Slice("x")), 0); + iter->Next(); + ASSERT_FALSE(iter->Valid()); + + ASSERT_OK(Put("c", "d")); + + iter->Seek(Slice("a")); + ASSERT_TRUE(iter->Valid()); + ASSERT_EQ(iter->key().compare(Slice("x")), 0); + iter->Next(); + ASSERT_FALSE(iter->Valid()); + + iter->Refresh(); + + iter->Seek(Slice("a")); + ASSERT_TRUE(iter->Valid()); + ASSERT_EQ(iter->key().compare(Slice("c")), 0); + iter->Next(); + ASSERT_TRUE(iter->Valid()); + ASSERT_EQ(iter->key().compare(Slice("x")), 0); + iter->Next(); + ASSERT_FALSE(iter->Valid()); + + dbfull()->Flush(FlushOptions()); + + ASSERT_OK(Put("m", "n")); + + iter->Seek(Slice("a")); + ASSERT_TRUE(iter->Valid()); + ASSERT_EQ(iter->key().compare(Slice("c")), 0); + iter->Next(); + ASSERT_TRUE(iter->Valid()); + ASSERT_EQ(iter->key().compare(Slice("x")), 0); + iter->Next(); + ASSERT_FALSE(iter->Valid()); + + iter->Refresh(); + + iter->Seek(Slice("a")); + ASSERT_TRUE(iter->Valid()); + ASSERT_EQ(iter->key().compare(Slice("c")), 0); + iter->Next(); + ASSERT_TRUE(iter->Valid()); + ASSERT_EQ(iter->key().compare(Slice("m")), 0); + iter->Next(); + ASSERT_TRUE(iter->Valid()); + ASSERT_EQ(iter->key().compare(Slice("x")), 0); + iter->Next(); + ASSERT_FALSE(iter->Valid()); + + iter.reset(); +} + } // namespace rocksdb int main(int argc, char** argv) { diff --git a/include/rocksdb/iterator.h b/include/rocksdb/iterator.h index 4e09f64e9..d4ac52818 100644 --- a/include/rocksdb/iterator.h +++ b/include/rocksdb/iterator.h @@ -80,6 +80,13 @@ class Iterator : public Cleanable { // satisfied without doing some IO, then this returns Status::Incomplete(). virtual Status status() const = 0; + // If supported, renew the iterator to represent the latest state. The + // iterator will be invalidated after the call. Not supported if + // ReadOptions.snapshot is given when creating the iterator. + virtual Status Refresh() { + return Status::NotSupported("Refresh() is not supported"); + } + // Property "rocksdb.iterator.is-key-pinned": // If returning "1", this means that the Slice returned by key() is valid // as long as the iterator is not deleted. diff --git a/utilities/date_tiered/date_tiered_db_impl.cc b/utilities/date_tiered/date_tiered_db_impl.cc index b75c077be..c1b1ceb5e 100644 --- a/utilities/date_tiered/date_tiered_db_impl.cc +++ b/utilities/date_tiered/date_tiered_db_impl.cc @@ -378,8 +378,8 @@ Iterator* DateTieredDBImpl::NewIterator(const ReadOptions& opts) { DBImpl* db_impl = reinterpret_cast(db_); auto db_iter = NewArenaWrappedDbIterator( - db_impl->GetEnv(), opts, ioptions_, cf_options_.comparator, - kMaxSequenceNumber, cf_options_.max_sequential_skip_in_iterations, 0); + db_impl->GetEnv(), opts, ioptions_, kMaxSequenceNumber, + cf_options_.max_sequential_skip_in_iterations, 0); auto arena = db_iter->GetArena(); MergeIteratorBuilder builder(cf_options_.comparator, arena);