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.]]>

Counter Cache: How to get started

coderhs — Tue, 26 Jul 2016 10:40:48 +0000

number of tasks under a project or the number of comments in a post or the number of users in an organization or anything similar is a common requirement in most rails applications. The code for doing it is also simple- @project.tasks.count; but the problem with this code is that every time you run it, you are counting the number of tasks of that project one by one. So, the speed of execution decreases with more number of rows. This code will slow down your page load, if you are displaying the details of more than one project in your page as shown below. To speed this up, rails gives you an in-build mechanism called “Counter Cache“. As the name suggests, it literally means to cache the number of referenced rows it has (number of tasks a project has). Example code definition

class Projects < ActiveRecord::Base
  has_many :tasks
end
class Task < ActiveRecord::Base
  belongs_to :project
end

To implement counter_cache, you need to pass in the counter_cache: true option along with the belongs_to relationship. You also need to add a migration to add an extra column called tasks_count to store the count. This needs to be added to the other model, which has the has_many reference.

class Task < ActiveRecord::Base
  belongs_to :project, counter_cache: true
end

Migration

class AddTasksCounterCacheToProjects < ActiveRecord::Migration[5.0]
  def change
    add_column :projects, :tasks_count, :integer
  end
end

If you are adding counter cache to an existing system, you need to update your tasks_count with the existing counts. To do that, one can use the code given below. Either place the code along with the migration or run it in console in both production/development environments.

Project.find_each { |project| Project.reset_counters(project.id, :tasks) }

Also note that the tasks_count is just the default column name; if you wish to change it with another name, just pass that name along with the :counter_cache option as below.

class Task < ActiveRecord::Base
  belongs_to :project, counter_cache: :not_the_default_column_name
end

Now, to use the counter cache in your calculations, you should use the method “size” instead of “count”. The method “size” will use the counter_cache if its present, where as using “.count” itself would do the actual sql count.

<% Project.all.each do |project| %>
  <%= project.name %> (<%= project.tasks.size %>)
<% end %>

Points to Remember

:counter_cache is the optional attribute of a belongs_to relationship
It requires the creation of an extra column (tasks_count) in the table which has the has_many relationship
One can use another column name by passing the name along with :counter_cache option
To use the counter_cache, one must use the “.size” method

Speed Improvements ]]>

mysql – redpanthers.co

after_create vs after_save vs after_commit

Counter Cache: How to get started