YugabyteDB (2.13.0.0-b42, bfc6a6643e7399ac8a0e81d06a3ee6d6571b33ab)

// 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.

//

#ifndef STORAGE_ROCKSDB_INCLUDE_TRANSACTION_LOG_ITERATOR_H_

#define STORAGE_ROCKSDB_INCLUDE_TRANSACTION_LOG_ITERATOR_H_

#include "yb/rocksdb/status.h"

#include "yb/rocksdb/types.h"

#include "yb/rocksdb/write_batch.h"

#include <memory>

#include <vector>

namespace rocksdb {

class LogFile;

typedef std::vector<std::unique_ptr<LogFile>> VectorLogPtr;

enum  WalFileType {

  /* Indicates that WAL file is in archive directory. WAL files are moved from

   * the main db directory to archive directory once they are not live and stay

   * there until cleaned up. Files are cleaned depending on archive size

   * (Options::WAL_size_limit_MB) and time since last cleaning

   * (Options::WAL_ttl_seconds).

   */

  kArchivedLogFile = 0,

  /* Indicates that WAL file is live and resides in the main db directory */

  kAliveLogFile = 1

} ;

class LogFile {

 public:

  LogFile() {}

  virtual ~LogFile() {}

  // Returns log file's pathname relative to the main db dir

  // Eg. For a live-log-file = /000003.log

  //     For an archived-log-file = /archive/000003.log

  virtual std::string PathName() const = 0;

  // Primary identifier for log file.

  // This is directly proportional to creation time of the log file

  virtual uint64_t LogNumber() const = 0;

  // Log file can be either alive or archived

  virtual WalFileType Type() const = 0;

  // Starting sequence number of writebatch written in this log file

  virtual SequenceNumber StartSequence() const = 0;

  // Size of log file on disk in Bytes

  virtual uint64_t SizeFileBytes() const = 0;

};

struct BatchResult {

  SequenceNumber sequence = 0;

  std::unique_ptr<WriteBatch> writeBatchPtr;

  // Add empty __ctor and __dtor for the rule of five

  // However, preserve the original semantics and prohibit copying

  // as the unique_ptr member does not copy.

  BatchResult() {}

  ~BatchResult() {}

  BatchResult(const BatchResult&) = delete;

  BatchResult& operator=(const BatchResult&) = delete;

  BatchResult(BatchResult&& bResult)

      : sequence(std::move(bResult.sequence)),

        writeBatchPtr(std::move(bResult.writeBatchPtr)) {}

  BatchResult& operator=(BatchResult&& bResult) {

    sequence = std::move(bResult.sequence);

    writeBatchPtr = std::move(bResult.writeBatchPtr);

    return *this;

  }

};

// A TransactionLogIterator is used to iterate over the transactions in a db.

// One run of the iterator is continuous, i.e. the iterator will stop at the

// beginning of any gap in sequences

class TransactionLogIterator {

 public:

  TransactionLogIterator() {}

  virtual ~TransactionLogIterator() {}

  // An iterator is either positioned at a WriteBatch or not valid.

  // This method returns true if the iterator is valid.

  // Can read data from a valid iterator.

  virtual bool Valid() = 0;

  // Moves the iterator to the next WriteBatch.

  // REQUIRES: Valid() to be true.

  virtual void Next() = 0;

  // Returns ok if the iterator is valid.

  // Returns the Error when something has gone wrong.

  virtual Status status() = 0;

  // If valid return's the current write_batch and the sequence number of the

  // earliest transaction contained in the batch.

  // ONLY use if Valid() is true and status() is OK.

  virtual BatchResult GetBatch() = 0;

  // The read options for TransactionLogIterator.

  struct ReadOptions {

    // If true, all data read from underlying storage will be

    // verified against corresponding checksums.

    // Default: true

    bool verify_checksums_;

    ReadOptions() : verify_checksums_(true) {}

    explicit ReadOptions(bool verify_checksums)

        : verify_checksums_(verify_checksums) {}

  };

};

} //  namespace rocksdb

#endif  // STORAGE_ROCKSDB_INCLUDE_TRANSACTION_LOG_ITERATOR_H_