YugabyteDB (2.13.1.0-b60, 21121d69985fbf76aa6958d8f04a9bfa936293b5)

//  Copyright (c) 2011-present, Facebook, Inc.  All rights reserved.

//  This source code is licensed under the BSD-style license found in the

//  LICENSE file in the root directory of this source tree. An additional grant

//  of patent rights can be found in the PATENTS file in the same directory.

//

// The following only applies to changes made to this file as part of YugaByte development.

//

// Portions Copyright (c) YugaByte, Inc.

//

// Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except

// in compliance with the License.  You may obtain a copy of the License at

//

// http://www.apache.org/licenses/LICENSE-2.0

//

// Unless required by applicable law or agreed to in writing, software distributed under the License

// is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express

// or implied.  See the License for the specific language governing permissions and limitations

// under the License.

//

// Copyright (c) 2011 The LevelDB Authors. All rights reserved.

// Use of this source code is governed by a BSD-style license that can be

// found in the LICENSE file. See the AUTHORS file for names of contributors.

#include "yb/rocksdb/table/two_level_iterator.h"

#include "yb/rocksdb/table/iterator_wrapper.h"

#include "yb/rocksdb/util/arena.h"

namespace rocksdb {

namespace {

class TwoLevelIterator : public InternalIterator {

 public:

  explicit TwoLevelIterator(TwoLevelIteratorState* state,

                            InternalIterator* first_level_iter,

                            bool need_free_iter_and_state);

  virtual ~TwoLevelIterator() {

    first_level_iter_.DeleteIter(!need_free_iter_and_state_);

    second_level_iter_.DeleteIter(false);

    if (need_free_iter_and_state_) {

      delete state_;

    } else {

      state_->~TwoLevelIteratorState();

    }

  }

  void Seek(const Slice& target) override;

  void SeekToFirst() override;

  void SeekToLast() override;

  void Next() override;

  void Prev() override;

  bool Valid() const override { return second_level_iter_.Valid(); }

  Slice key() const override {

    assert(Valid());

    return second_level_iter_.key();

  }

  Slice value() const override {

    assert(Valid());

    return second_level_iter_.value();

  }

  Status status() const override {

    // It'd be nice if status() returned a const Status& instead of a Status

    if (!first_level_iter_.status().ok()) {

      return first_level_iter_.status();

    } else if (second_level_iter_.iter() != nullptr &&

               
!second_level_iter_.status().ok()3.15M
) {

      return second_level_iter_.status();

    } else {

      return status_;

    }

  }

  Status PinData() override { return second_level_iter_.PinData(); }

  Status ReleasePinnedData() override {

    return second_level_iter_.ReleasePinnedData();

  }

  bool IsKeyPinned() const override {

    return second_level_iter_.iter() ? second_level_iter_.IsKeyPinned() : 
false0
;

  }

 private:

  void SaveError(const Status& s) {

    if (
status_.ok()18.6M
 && !s.ok()) 
status_ = s1
;

  }

  void SkipEmptyDataBlocksForward();

  void SkipEmptyDataBlocksBackward();

  void SetSecondLevelIterator(InternalIterator* iter);

  void InitDataBlock();

  TwoLevelIteratorState* state_;

  IteratorWrapper first_level_iter_;

  IteratorWrapper second_level_iter_;  // May be nullptr

  bool need_free_iter_and_state_;

  Status status_;

  // If second_level_iter is non-nullptr, then "data_block_handle_" holds the

  // "index_value" passed to block_function_ to create the second_level_iter.

  std::string data_block_handle_;

};

TwoLevelIterator::TwoLevelIterator(TwoLevelIteratorState* state,

                                   InternalIterator* first_level_iter,

                                   bool need_free_iter_and_state)

    : state_(state),

      first_level_iter_(first_level_iter),

      need_free_iter_and_state_(need_free_iter_and_state) {}

void TwoLevelIterator::Seek(const Slice& target) {

  if (state_->check_prefix_may_match &&

      
!state_->PrefixMayMatch(target)15.8k
) {

    SetSecondLevelIterator(nullptr);

    return;

  }

  first_level_iter_.Seek(target);

  InitDataBlock();

  if (second_level_iter_.iter() != nullptr) {

    second_level_iter_.Seek(target);

  }

  SkipEmptyDataBlocksForward();

}

void TwoLevelIterator::SeekToFirst() {

  first_level_iter_.SeekToFirst();

  InitDataBlock();

  if (second_level_iter_.iter() != nullptr) {

    second_level_iter_.SeekToFirst();

  }

  SkipEmptyDataBlocksForward();

}

void TwoLevelIterator::SeekToLast() {

  first_level_iter_.SeekToLast();

  InitDataBlock();

  if (second_level_iter_.iter() != nullptr) {

    second_level_iter_.SeekToLast();

  }

  SkipEmptyDataBlocksBackward();

}

void TwoLevelIterator::Next() {

  assert(Valid());

  second_level_iter_.Next();

  SkipEmptyDataBlocksForward();

}

void TwoLevelIterator::Prev() {

  assert(Valid());

  second_level_iter_.Prev();

  SkipEmptyDataBlocksBackward();

}

void TwoLevelIterator::SkipEmptyDataBlocksForward() {

  while (second_level_iter_.iter() == nullptr ||

         
(829M
!second_level_iter_.Valid()829M
 &&

         
!second_level_iter_.status().IsIncomplete()4.39M
)) {

    // Move to next block

    if (!first_level_iter_.Valid()) {

      SetSecondLevelIterator(nullptr);

      return;

    }

    first_level_iter_.Next();

    InitDataBlock();

    if (second_level_iter_.iter() != nullptr) {

      second_level_iter_.SeekToFirst();

    }

  }

}

void TwoLevelIterator::SkipEmptyDataBlocksBackward() {

  while (second_level_iter_.iter() == nullptr ||

         
(8.16M
!second_level_iter_.Valid()8.16M
 &&

         
!second_level_iter_.status().IsIncomplete()282k
)) {

    // Move to next block

    if (!first_level_iter_.Valid()) {

      SetSecondLevelIterator(nullptr);

      return;

    }

    first_level_iter_.Prev();

    InitDataBlock();

    if (second_level_iter_.iter() != nullptr) {

      second_level_iter_.SeekToLast();

    }

  }

}

void TwoLevelIterator::SetSecondLevelIterator(InternalIterator* iter) {

  if (second_level_iter_.iter() != nullptr) {

    SaveError(second_level_iter_.status());

  }

  second_level_iter_.Set(iter);

}

void TwoLevelIterator::InitDataBlock() {

  if (!first_level_iter_.Valid()) {

    SetSecondLevelIterator(nullptr);

  } else {

    Slice handle = first_level_iter_.value();

    if (second_level_iter_.iter() != nullptr &&

        
!second_level_iter_.status().IsIncomplete()70.8M
 &&

        
handle.compare(data_block_handle_) == 070.8M
) {

      // second_level_iter is already constructed with this iterator, so

      // no need to change anything

    } else {

      InternalIterator* iter = state_->NewSecondaryIterator(handle);

      data_block_handle_.assign(handle.cdata(), handle.size());

      SetSecondLevelIterator(iter);

    }

  }

}

}  // namespace

InternalIterator* NewTwoLevelIterator(

    TwoLevelIteratorState* state, InternalIterator* first_level_iter, Arena* arena,

    bool need_free_iter_and_state) {

  if (arena == nullptr) {

    return new TwoLevelIterator(state, first_level_iter, need_free_iter_and_state);

  } else {

    auto mem = arena->AllocateAligned(sizeof(TwoLevelIterator));

    return new (mem)

        TwoLevelIterator(state, first_level_iter, need_free_iter_and_state);

  }

}

}  // namespace rocksdb