Transactions are protective blocks where SQL statements are only permanent if they can all succeed as one atomic action. The classic example is a transfer between two accounts where you can only have a deposit if the withdrawal succeeded and vice versa. Transactions enforce the integrity of the database and guard the data against program errors or database break-downs. So basically you should use transaction blocks whenever you have a number of statements that must be executed together or not at all. Example: 

  transaction do
    david.withdrawal(100)
    mary.deposit(100)
  end

This example will only take money from David and give to Mary if neither withdrawal nor deposit raises an exception. Exceptions will force a ROLLBACK that returns the database to the state before the transaction was begun. Be aware, though, that the objects by default will not have their instance data returned to their pre-transactional state.

Transactions are not distributed across database connections

A transaction acts on a single database connection. If you have multiple class-specific databases, the transaction will not protect interaction among them. One workaround is to begin a transaction on each class whose models you alter: 

  Student.transaction do
    Course.transaction do
      course.enroll(student)
      student.units += course.units
    end
  end

This is a poor solution, but full distributed transactions are beyond the scope of Active Record.

Save and destroy are automatically wrapped in a transaction

Both Base#save and Base#destroy come wrapped in a transaction that ensures that whatever you do in validations or callbacks will happen under the protected cover of a transaction. So you can use validations to check for values that the transaction depend on or you can raise exceptions in the callbacks to rollback.

Object-level transactions

You can enable object-level transactions for Active Record objects, though. You do this by naming each of the Active Records that you want to enable object-level transactions for, like this: 

  Account.transaction(david, mary) do
    david.withdrawal(100)
    mary.deposit(100)
  end

If the transaction fails, David and Mary will be returned to their pre-transactional state. No money will have changed hands in neither object nor database.

Exception handling

Also have in mind that exceptions thrown within a transaction block will be propagated (after triggering the ROLLBACK), so you should be ready to catch those in your application code.

Tribute: Object-level transactions are implemented by Transaction::Simple by Austin Ziegler.

Show files where this module is defined (1 file)
Register or log in to add new notes.
November 11, 2011
3 thanks

Catching and throwing -- don't!

@wiseleyb and @glosakti, neither of your suggestions are necessary, and both are bad practices.

This test:

test "transactions" do
  assert_raises ZeroDivisionError do
    User.transaction do
      1/0
    end
  end
end

passes just fine on its own, with the transaction rolled back as you’d expect. No need to hack something ugly together.

March 18, 2015
0 thanks

Transactions and Stale ORM Data

Consider the following:

ActiveRecord::Base.transaction do
  foo = Foo.new
  foo.save # succeeds

  bar = Bar.new
  bar.save # failure, validation problem
end
March 18, 2015
0 thanks

Transactions and Stale ORM Data

Consider the following:

foo = Foo.new
bar = Bar.new

ActiveRecord::Base.transaction do
  foo.save! # succeeds
  bar.save! # failure, validation problem
end

foo.persisted? # true (!)

foo was not permanently stored in the database, but it was transiently saved, and this is reflected in the ActiveRecord model still in memory. But if you try

foo.reload # raises ActiveRecord::RecordNotFound

Don’t let stale data confuse you after using transactions!

Edited to add: This particular example does not succeed in reproducing the issue I encountered, which involved a slightly more complicated set of nested transactions. I haven’t managed to produce a simple test case where stale data remains in the model, but I have definitely experienced it in my app.

January 3, 2011
0 thanks

Throw error after rollback

If you want to throw the exception after rolling back you can do something like this:

Company.transaction do
  user.save
  company.save
  x = 1/0
rescue
  exp = $!
  begin
    raise ActiveRecord::Rollback
  rescue
  end
  raise exp
end
June 1, 2011 - (>= v3.0.0)
0 thanks

Catching rollback and re-raise exception

In response to wiseleyb, I don’t believe that you could put “rescue” in a transaction block, let alone catching ActiveRecord::Rollback. It would lead you to an “unexpected kRESCUE” error.

I think this is more appropriate.

def start_transaction
  Company.transaction do
    # don't forget the bang to make sure it raise
    # exception or the transaction won't rollback
    user.save!
    company.save!
    x=1/0

    return true
  end

  # re-raise exception here
  raise "Exception!"
end

Then you could call the method in another place, and it would raise rollback and other exception.

...
  # would return the "Exception!" if rollback occurs
  # it would also still trigger another exception other
  # than rollback.
  start_transaction
...