BigBinary Blog 2026-10-05T12:06:36+00:00 https://www.bigbinary.com/ <![CDATA[Rails 7.2 adds SQL query counts to rendering logs]]> Navaneeth D 2024-08-20T12:00:00+00:00 https://www.bigbinary.com/blog/rails-8-adds-sql-queries-count-to-template-rendering-logs For Rails developers, debugging database queries is a frequent task. Whetherit's addressing the notorious N+1 query problem or fine-tuning cachingstrategies, developers often find themselves diving into logs to scrutinize SQLquery counts.

Traditionally, this involved manually inspecting the logs and counting thenumber of queries. Needless to say, this becomes tedious and error-prone foractions generating a significant number of queries in the order of tens orhundreds.

Thankfully, Rails 7.2 introduces a helpful improvement by enhancing the logoutput to include the query count alongside existing information.

sql-query-count-in-template-log

The improved log output now includes the query count within the ActiveRecordsection. It shows 3 queries, 1 cached, indicating that three database querieswere executed, with one being served from the cache.

This seemingly small addition allows for quick identification of query volumeand potential optimization areas. You can easily see if caching is workingeffectively and if the number of queries aligns with expectations, savingdevelopers valuable time and effort.

Check this pull request for moredetails:

]]> <![CDATA[Rails 7.2 makes counter_cache integration safer and easier]]> Navaneeth D 2024-07-16T12:00:00+00:00 https://www.bigbinary.com/blog/rails-8-adds-ability-to-ignore-counter_cache-column-while-backfilling Counter caches are a cornerstone of performance optimization in Railsapplications. They efficiently keep track of the number of associated recordsfor a model, eliminating the need for frequent database queries. However, addingcounter caches to existing applications, especially those with large tables,often can be challenging. Rails 7.2 brings an exciting update to address justthat!

Counter cache integration challenges

When introducing counter caches to large datasets, developers often encountertwo primary challenges:

  • Backfilling data efficiently: Adding a counter cache column to an existingtable with a substantial amount of data can be problematic. Backfilling thecounter cache values separately from the column addition is necessary toprevent prolonged table locks, which can significantly impact applicationperformance. This process requires careful consideration to ensure dataintegrity while minimizing downtime and avoiding disruptions to userexperience.
  • Ensuring data consistency: Once the counter cache is in place, maintainingdata consistency becomes paramount. Methods such as size, any?, and othersthat utilize counter caches internally must return accurate results. However,during the backfilling process, relying solely on the counter cache mayproduce incorrect counts until all records are appropriately updated.

Safer counter cache implementation in Rails 7.2

The new update in Rails 7.2 introduces a feature that allows developers tomanage counter caches more effectively, especially in scenarios involvingexisting large datasets. By introducing the active option in the counter cacheconfiguration, developers can control when the counter cache is activelyutilized. This enables them to backfill counter cache columns separately fromtheir addition, minimizing table locks and potential performance issues. Oncethe backfilling process is complete, developers can activate the counter cache,ensuring accurate association counts without compromising applicationperformance.

Let's illustrate the implementation of this update in Rails using astraightforward example involving a blog application with articles and comments.In our blog application, each article can have multiple comments. We want to adda counter cache to track the number of comments associated with each article.However, our database already contains a significant amount of data, makingtraditional counter cache implementation challenging.

Implementation Steps

  1. Define the association: Initially, we define the association between theArticle model and the Comment model, specifying the counter cache withthe active: false option to keep it inactive during the initial setup.
class Comment < ApplicationRecord  belongs_to :article, counter_cache: { active: false }end

  1. Backfill the Counter Cache: With the association configured, we proceed tobackfill the counter cache column in the articles table. During this phase,the counter cache remains inactive, and methods like size, any?, etc.,retrieve results directly from the database. This prevents incorrectvalues from getting displayed during backfilling.

  2. Activate the Counter Cache: Once the backfilling process is complete, weactivate the counter cache by removing the active: false option from thecounter cache definition.

class Comment < ApplicationRecord  belongs_to :article, counter_cache: trueend

Upon activation, the counter cache integrates into the association, efficientlytracking the number of comments associated with each article.

This PR introduced active option.Checkout full feature discussionhere.

]]>