Database transaction in Rails

coderhs — Mon, 01 Aug 2016 11:38:48 +0000

A transaction is a sequence of operations performed as a single logical unit of work. A logical unit of work must exhibit four properties called the atomicity, consistency, isolation and durability (ACID) properties, to qualify as a transaction. We use database transactions to make sure that all the instructions we send to database are successful, and would cause changes to the database only if they are successful. Let’s say that you are working on a banking application which would withdraw money from one account and deposit into another account. The code for it would look like below

User.find(156).withdraw(1000)
User.find(157).deposit(1000)

But for some reason, the withdrawal was successful but the deposit was not, the amount was taken out but never deposited to the other user.To avoid these kind of issues, database has a functionality called transactions, in which you can build up each sql query. But if for any reason, any of the sql statements fails or an exception rises in the block, all the transactions are rolled back to their original form.

User.transaction do
  User.find(156).withdraw(1000)
  User.find(157).deposit(1000)
end

In rails, the transaction method is available as class method and instance method, but the functionality for both is same. There is no difference when you will use.

@user.transaction do
end

and

User.transaction do
end

The reason why rails provides this, is for better readability. One can also mix various model types in a transaction, as the transaction are bound to a database connection. So there is no issue in writing code like below.

User.transaction do
  Order.create order_attributes
  Purchase.create purchase_attribute
end

Nested Transactions: It is possible to write nested transactions. But it is to be noted that, it would just make each child transaction a part of the parent transaction. Taking the example from the Rails documentation. The below code

User.transaction do
  User.create(username: 'Kotori')
  User.transaction do
    User.create(username: 'Nemu')
    raise ActiveRecord::Rollback
  end
end

Creates both “Kotori” and “Nemu”. Reason is the ActiveRecord::Rollback exception in the nested block does not issue a ROLLBACK. Since these exceptions are captured in transaction blocks, the parent block does not see it and the real transaction is committed. Reference: https://technet.microsoft.com/en-us/library/ms190612(v=sql.105).aspx]]>

after_create vs after_save vs after_commit

coderhs — Thu, 28 Jul 2016 06:46:38 +0000

after_save, after_create and after_commit are called active record call backs in rails. They get executed when we work on the database, similarly we also have before_* callback and callbacks on destroy as well. In this article I will explain you about the difference between *_save, *_create and *_commit callbacks. The purpose of each as per rails docs:

after_create Is called after Base.save on new objects that haven‘t been saved yet (no record exists) after_save Is called after Base.save (regardless of whether it‘s a create or update save) after_commit Is called after the database transaction is completed.

Now to explain the real difference between the three, we must first explain about database transaction. They are a protective block around a group of sql statements, that are permanent only if all of them succeed in a single atomic statement.

User.transaction do
    # update company
    # update hr_department
    # update user_table
end

When rails execute a create, the after_save and after_create would be called within the transaction block of the create statement. So they will be executed before executing the sql statement to make permanent changes in the DB. If the query fails, then no change will happen to the DB, but we would have executed the instructions of the after_create and after_save block. Where as after_commit, is called after the execution of the final/outer transaction block. Thus the changes in the DB would be permanent.]]>

transaction – redpanthers.co

Database transaction in Rails

after_create vs after_save vs after_commit