transaction_guard.hpp

Go to the documentation of this file.

#pragma once
 
#include "connection.hpp"
 
#include <stdexcept>
#include <string_view>
#include <utility>
 
namespace relx::connection {
 
class TransactionException : public std::runtime_error {
public:
  explicit TransactionException(const ConnectionError& error)
      : std::runtime_error(error.message), error_code_(error.error_code) {}
 
  explicit TransactionException(const std::string& message)
      : std::runtime_error(message), error_code_(0) {}
 
  int error_code() const noexcept { return error_code_; }
 
private:
  int error_code_;
};
 
class TransactionGuard {
public:
  explicit TransactionGuard(Connection& connection,
                            IsolationLevel isolation_level = IsolationLevel::ReadCommitted)
      : connection_(connection), committed_(false), rolled_back_(false) {
    auto result = connection_.get().begin_transaction(isolation_level);
    if (!result) {
      throw TransactionException(result.error());
    }
  }
 
  ~TransactionGuard() noexcept {
    if (!committed_ && !rolled_back_ && connection_.get().in_transaction()) {
      try {
        rollback();
      } catch (...) {
        // Suppress any exceptions from rollback in destructor
      }
    }
  }
 
  // Delete copy constructor and assignment operator
  TransactionGuard(const TransactionGuard&) = delete;
  TransactionGuard& operator=(const TransactionGuard&) = delete;
 
  // Allow move operations
  TransactionGuard(TransactionGuard&& other) noexcept
      : connection_(other.connection_), committed_(other.committed_),
        rolled_back_(other.rolled_back_) {
    // Mark the other transaction as rolled back to prevent double-rollback
    other.rolled_back_ = true;
  }
 
  TransactionGuard& operator=(TransactionGuard&& other) noexcept {
    if (this != &other) {
      // Rollback the current transaction if needed
      if (!committed_ && !rolled_back_ && connection_.get().in_transaction()) {
        try {
          rollback();
        } catch (...) {
          // Suppress any exceptions from rollback
        }
      }
 
      connection_ = other.connection_;
      committed_ = other.committed_;
      rolled_back_ = other.rolled_back_;
 
      // Mark the other transaction as rolled back to prevent double-rollback
      other.rolled_back_ = true;
    }
    return *this;
  }
 
  void commit() {
    if (committed_ || rolled_back_) {
      throw TransactionException("Transaction already committed or rolled back");
    }
 
    auto result = connection_.get().commit_transaction();
    if (!result) {
      throw TransactionException(result.error());
    }
 
    committed_ = true;
  }
 
  void rollback() {
    if (committed_ || rolled_back_) {
      throw TransactionException("Transaction already committed or rolled back");
    }
 
    auto result = connection_.get().rollback_transaction();
    if (!result) {
      throw TransactionException(result.error());
    }
 
    rolled_back_ = true;
  }
 
  bool is_committed() const noexcept { return committed_; }
 
  bool is_rolled_back() const noexcept { return rolled_back_; }
 
  template <typename Func>
  static void with_transaction(Connection& connection, Func&& func,
                               IsolationLevel isolation_level = IsolationLevel::ReadCommitted) {
    TransactionGuard guard(connection, isolation_level);
    func(connection);
    guard.commit();
  }
 
private:
  std::reference_wrapper<Connection> connection_;
  bool committed_;
  bool rolled_back_;
};
 
}  // namespace relx::connection
 
// Convenient imports from the connection namespace
using relx::connection::TransactionException;
using relx::connection::TransactionGuard;