ceph/src/rocksdb/utilities/transactions/optimistic_transaction.cc

   1 //  Copyright (c) 2011-present, Facebook, Inc.  All rights reserved.
   2 //  This source code is licensed under both the GPLv2 (found in the
   3 //  COPYING file in the root directory) and Apache 2.0 License
   4 //  (found in the LICENSE.Apache file in the root directory).
   5
   6 #ifndef ROCKSDB_LITE
   7
   8 #include "utilities/transactions/optimistic_transaction.h"
   9
  10 #include <string>
  11
  12 #include "db/column_family.h"
  13 #include "db/db_impl.h"
  14 #include "rocksdb/comparator.h"
  15 #include "rocksdb/db.h"
  16 #include "rocksdb/status.h"
  17 #include "rocksdb/utilities/optimistic_transaction_db.h"
  18 #include "util/cast_util.h"
  19 #include "util/string_util.h"
  20 #include "utilities/transactions/transaction_util.h"
  21
  22 namespace rocksdb {
  23
  24 struct WriteOptions;
  25
  26 OptimisticTransaction::OptimisticTransaction(
  27     OptimisticTransactionDB* txn_db, const WriteOptions& write_options,
  28     const OptimisticTransactionOptions& txn_options)
  29     : TransactionBaseImpl(txn_db->GetBaseDB(), write_options), txn_db_(txn_db) {
  30   Initialize(txn_options);
  31 }
  32
  33 void OptimisticTransaction::Initialize(
  34     const OptimisticTransactionOptions& txn_options) {
  35   if (txn_options.set_snapshot) {
  36     SetSnapshot();
  37   }
  38 }
  39
  40 void OptimisticTransaction::Reinitialize(
  41     OptimisticTransactionDB* txn_db, const WriteOptions& write_options,
  42     const OptimisticTransactionOptions& txn_options) {
  43   TransactionBaseImpl::Reinitialize(txn_db->GetBaseDB(), write_options);
  44   Initialize(txn_options);
  45 }
  46
  47 OptimisticTransaction::~OptimisticTransaction() {}
  48
  49 void OptimisticTransaction::Clear() { TransactionBaseImpl::Clear(); }
  50
  51 Status OptimisticTransaction::Prepare() {
  52   return Status::InvalidArgument(
  53       "Two phase commit not supported for optimistic transactions.");
  54 }
  55
  56 Status OptimisticTransaction::Commit() {
  57   // Set up callback which will call CheckTransactionForConflicts() to
  58   // check whether this transaction is safe to be committed.
  59   OptimisticTransactionCallback callback(this);
  60
  61   DBImpl* db_impl = static_cast_with_check<DBImpl, DB>(db_->GetRootDB());
  62
  63   Status s = db_impl->WriteWithCallback(
  64       write_options_, GetWriteBatch()->GetWriteBatch(), &callback);
  65
  66   if (s.ok()) {
  67     Clear();
  68   }
  69
  70   return s;
  71 }
  72
  73 Status OptimisticTransaction::Rollback() {
  74   Clear();
  75   return Status::OK();
  76 }
  77
  78 // Record this key so that we can check it for conflicts at commit time.
  79 //
  80 // 'exclusive' is unused for OptimisticTransaction.
  81 Status OptimisticTransaction::TryLock(ColumnFamilyHandle* column_family,
  82                                       const Slice& key, bool read_only,
  83                                       bool exclusive, bool untracked) {
  84   if (untracked) {
  85     return Status::OK();
  86   }
  87   uint32_t cfh_id = GetColumnFamilyID(column_family);
  88
  89   SetSnapshotIfNeeded();
  90
  91   SequenceNumber seq;
  92   if (snapshot_) {
  93     seq = snapshot_->GetSequenceNumber();
  94   } else {
  95     seq = db_->GetLatestSequenceNumber();
  96   }
  97
  98   std::string key_str = key.ToString();
  99
 100   TrackKey(cfh_id, key_str, seq, read_only, exclusive);
 101
 102   // Always return OK. Confilct checking will happen at commit time.
 103   return Status::OK();
 104 }
 105
 106 // Returns OK if it is safe to commit this transaction.  Returns Status::Busy
 107 // if there are read or write conflicts that would prevent us from committing OR
 108 // if we can not determine whether there would be any such conflicts.
 109 //
 110 // Should only be called on writer thread in order to avoid any race conditions
 111 // in detecting write conflicts.
 112 Status OptimisticTransaction::CheckTransactionForConflicts(DB* db) {
 113   Status result;
 114
 115   auto db_impl = static_cast_with_check<DBImpl, DB>(db);
 116
 117   // Since we are on the write thread and do not want to block other writers,
 118   // we will do a cache-only conflict check.  This can result in TryAgain
 119   // getting returned if there is not sufficient memtable history to check
 120   // for conflicts.
 121   return TransactionUtil::CheckKeysForConflicts(db_impl, GetTrackedKeys(),
 122                                                 true /* cache_only */);
 123 }
 124
 125 Status OptimisticTransaction::SetName(const TransactionName& /* unused */) {
 126   return Status::InvalidArgument("Optimistic transactions cannot be named.");
 127 }
 128
 129 }  // namespace rocksdb
 130
 131 #endif  // ROCKSDB_LITE