Because of this, Active Record emulates nested transactions by using savepoints. At the time of writing, the only database that we're aware of that supports true nested transactions, is MS-SQL. Most databases don't support true nested transactions. If we add it to the previous example: ansaction do If anything goes wrong, the database rolls back to the beginning of the sub-transaction without rolling back the parent transaction. In order to get a ROLLBACK for the nested transaction you may ask for a real sub-transaction by passing requires_new: true. Since these exceptions are captured in transaction blocks, the parent block does not see it and the real transaction is committed. Reason is the ActiveRecord::Rollback exception in the nested block does not issue a ROLLBACK. For example, the following behavior may be surprising: ansaction doĬreates both “Kotori” and “Nemu”. By default, this makes all database statements in the nested transaction block become part of the parent transaction. One should restart the entire transaction if an ActiveRecord::StatementInvalid occurred. # ignored until end of transaction block" # => "PG::Error: ERROR: current transaction is aborted, commands # statement will cause a PostgreSQL error, even though the unique # On PostgreSQL, the transaction is now unusable. # This will raise a unique constraint error. Here is an example which demonstrates the problem: # Suppose that we have a Number model with a unique column called 'i'. On some database systems, such as PostgreSQL, database errors inside a transaction cause the entire transaction to become unusable until it's restarted from the beginning. ActiveRecord::StatementInvalid exceptions indicate that an error occurred at the database level, for example when a unique constraint is violated. Warning: one should not catch ActiveRecord::StatementInvalid exceptions inside a transaction block. One exception is the ActiveRecord::Rollback exception, which will trigger a ROLLBACK when raised, but not be re-raised by the transaction block. Exception handling and rolling backĪlso 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. The after_commit callback is the only one that is triggered once the update is committed. For example, if you try to update the index of a search engine in after_save the indexer won't see the updated record. So you can use validations to check for values that the transaction depends on or you can raise exceptions in the callbacks to rollback, including after_* callbacks.Īs a consequence changes to the database are not seen outside your connection until the operation is complete. save and destroy are automatically wrapped in a transactionīoth #save and #destroy come wrapped in a transaction that ensures that whatever you do in validations or callbacks will happen under its protected cover. This is a poor solution, but fully distributed transactions are beyond the scope of Active Record. One workaround is to begin a transaction on each class whose models you alter: ansaction do If you have multiple class-specific databases, the transaction will not protect interaction among them. Transactions are not distributed across database connectionsĪ transaction acts on a single database connection. For example, you can also do this: ansaction do The transaction method is also available as a model instance method. In this example a balance record is transactionally saved even though transaction is called on the Account class: ansaction do This is because transactions are per-database connection, not per-model. Though the transaction class method is called on some Active Record class, the objects within the transaction block need not all be instances of that class. Different Active Record classes in a single transaction Be aware, though, that the objects will not have their instance data returned to their pre-transactional state. Exceptions will force a ROLLBACK that returns the database to the state before the transaction began. This example will only take money from David and give it to Mary if neither withdrawal nor deposit raise an exception. So basically you should use transaction blocks whenever you have a number of statements that must be executed together or not at all.įor example: ActiveRecord::ansaction do Transactions enforce the integrity of the database and guard the data against program errors or database break-downs. The classic example is a transfer between two accounts where you can only have a deposit if the withdrawal succeeded and vice versa. Transactions are protective blocks where SQL statements are only permanent if they can all succeed as one atomic action.
0 Comments
Leave a Reply. |