Module: ActiveRecord::Transactions::ClassMethods
- Defined in:
- lib/active_record/transactions.rb
Overview
Transactions are protective blocks where SQL statements are only permanent if they can all succed as one atomic action. The classic example is a transfer between two accounts where you can only have a deposit if the withdrawal succedded and vice versa. Transaction enforce the integrity of the database and guards 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:
Account.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.
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 the 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.
Instance Method Summary collapse
Instance Method Details
#transaction(*objects, &block) ⇒ Object
62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 |
# File 'lib/active_record/transactions.rb', line 62 def transaction(*objects, &block) TRANSACTION_MUTEX.lock begin objects.each { |o| o.extend(Transaction::Simple) } objects.each { |o| o.start_transaction } connection.begin_db_transaction block.call connection.commit_db_transaction objects.each { |o| o.commit_transaction } rescue Exception => exception connection.rollback_db_transaction objects.each { |o| o.abort_transaction } raise exception ensure TRANSACTION_MUTEX.unlock end end |