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.

//

#pragma once

#ifndef ROCKSDB_LITE

#include <string>

#include <vector>

#include "yb/rocksdb/comparator.h"

#include "yb/rocksdb/db.h"

#include "yb/rocksdb/utilities/stackable_db.h"

#include "yb/rocksdb/utilities/transaction.h"

// Database with Transaction support.

//

// See transaction.h and examples/transaction_example.cc

namespace rocksdb {

class TransactionDBMutexFactory;

struct TransactionDBOptions {

  // Specifies the maximum number of keys that can be locked at the same time

  // per column family.

  // If the number of locked keys is greater than max_num_locks, transaction

  // writes (or GetForUpdate) will return an error.

  // If this value is not positive, no limit will be enforced.

  int64_t max_num_locks = -1;

  // Increasing this value will increase the concurrency by dividing the lock

  // table (per column family) into more sub-tables, each with their own

  // separate

  // mutex.

  size_t num_stripes = 16;

  // If positive, specifies the default wait timeout in milliseconds when

  // a transaction attempts to lock a key if not specified by

  // TransactionOptions::lock_timeout.

  //

  // If 0, no waiting is done if a lock cannot instantly be acquired.

  // If negative, there is no timeout.  Not using a timeout is not recommended

  // as it can lead to deadlocks.  Currently, there is no deadlock-detection to

  // recover

  // from a deadlock.

  int64_t transaction_lock_timeout = 1000;  // 1 second

  // If positive, specifies the wait timeout in milliseconds when writing a key

  // OUTSIDE of a transaction (ie by calling DB::Put(),Merge(),Delete(),Write()

  // directly).

  // If 0, no waiting is done if a lock cannot instantly be acquired.

  // If negative, there is no timeout and will block indefinitely when acquiring

  // a lock.

  //

  // Not using a a timeout can lead to deadlocks.  Currently, there

  // is no deadlock-detection to recover from a deadlock.  While DB writes

  // cannot deadlock with other DB writes, they can deadlock with a transaction.

  // A negative timeout should only be used if all transactions have an small

  // expiration set.

  int64_t default_lock_timeout = 1000;  // 1 second

  // If set, the TransactionDB will use this implemenation of a mutex and

  // condition variable for all transaction locking instead of the default

  // mutex/condvar implementation.

  std::shared_ptr<TransactionDBMutexFactory> custom_mutex_factory;

};

struct TransactionOptions {

  // Setting set_snapshot=true is the same as calling

  // Transaction::SetSnapshot().

  bool set_snapshot = false;

  // TODO(agiardullo): TransactionDB does not yet support comparators that allow

  // two non-equal keys to be equivalent.  Ie, cmp->Compare(a,b) should only

  // return 0 if

  // a.compare(b) returns 0.

  // If positive, specifies the wait timeout in milliseconds when

  // a transaction attempts to lock a key.

  //

  // If 0, no waiting is done if a lock cannot instantly be acquired.

  // If negative, TransactionDBOptions::transaction_lock_timeout will be used.

  int64_t lock_timeout = -1;

  // Expiration duration in milliseconds.  If non-negative, transactions that

  // last longer than this many milliseconds will fail to commit.  If not set,

  // a forgotten transaction that is never committed, rolled back, or deleted

  // will never relinquish any locks it holds.  This could prevent keys from

  // being

  // written by other writers.

  int64_t expiration = -1;

};

class TransactionDB : public StackableDB {

 public:

  // Open a TransactionDB similar to DB::Open().

  static Status Open(const Options& options,

                     const TransactionDBOptions& txn_db_options,

                     const std::string& dbname, TransactionDB** dbptr);

  static Status Open(const DBOptions& db_options,

                     const TransactionDBOptions& txn_db_options,

                     const std::string& dbname,

                     const std::vector<ColumnFamilyDescriptor>& column_families,

                     std::vector<ColumnFamilyHandle*>* handles,

                     TransactionDB** dbptr);

  virtual ~TransactionDB() {}

  // Starts a new Transaction.

  //

  // Caller is responsible for deleting the returned transaction when no

  // longer needed.

  //

  // If old_txn is not null, BeginTransaction will reuse this Transaction

  // handle instead of allocating a new one.  This is an optimization to avoid

  // extra allocations when repeatedly creating transactions.

  virtual Transaction* BeginTransaction(

      const WriteOptions& write_options,

      const TransactionOptions& txn_options = TransactionOptions(),

      Transaction* old_txn = nullptr) = 0;

 protected:

  // To Create an TransactionDB, call Open()

  explicit TransactionDB(DB* db) : StackableDB(db) {}

 private:

  // No copying allowed

  TransactionDB(const TransactionDB&);

  void operator=(const TransactionDB&);

};

}  // namespace rocksdb

#endif  // ROCKSDB_LITE