DEV Community: Trupti

N+1 Queries Problem in Rails

Trupti — Sun, 11 Feb 2024 09:04:52 +0000

In Ruby on Rails applications, the N+1 query problem often sneaks in during the development of ActiveRecord associations. This issue can drastically affect the performance of your application by making an excessive number of database queries, which can slow down your application. But what exactly are N+1 queries, and how can you solve them? Let's break it down.

What are N+1 Queries?

The N+1 query problem occurs when your application makes 1 query to retrieve the primary objects, and then N additional queries to fetch associated objects for each primary object. Here, "N" represents the number of primary objects retrieved by the initial query, and "1" signifies the initial query itself.

Example of N+1 Queries

Consider a blogging platform where each Post has many Comments. If you want to display all posts along with their comments, you might do something like this:

@posts = Post.limit(10)
@posts do |post|
  puts post.comments.text
end

And in your view:

<% @posts.each do |post| %>
  <h2><%= post.title %></h2>
  <% post.comments.each do |comment| %>
    <p><%= comment.body %></p>
  <% end %>
<% end %>

This innocent-looking code leads to the N+1 query problem. Here's why:

1 query is made to fetch all posts.
N queries are made to fetch comments for each post (if there are 10 posts, 10 additional queries are made to fetch comments for each post).

How to Fix N+1 Queries

Active Record lets you specify in advance all the associations that are going to be loaded.

The methods are:

includes: With includes, Active Record ensures that all of the specified associations are loaded using the minimum possible number of queries.
preload: With preload, Active Record loads each specified association using one query per association.
eager_load: With eager_load, Active Record loads all specified associations using a LEFT OUTER JOIN.

Use Join

Ruby on Rails ActiveRecord provides a .joins method that can be used to address N+1 query problems in certain situations, particularly when you want to filter or sort by fields on associated tables. Unlike includes, which is designed for preloading related records to avoid N+1 queries, .joins performs an SQL JOIN operation. This can be more efficient in cases where you don't need to access all the attributes of the related records, but rather need to query based on them or include them in the select statement.

@posts_with_comments = Post.joins(:comments).distinct

This query fetches posts that have at least one comment by performing an INNER JOIN between posts and comments. The distinct method is used to ensure each post is listed only once, even if it has multiple comments.

When to Use `.joins`

Use .joins when you need to filter or sort queries based on associated records' attributes.
It's also useful for aggregations or when counting related records.

Limitations

While .joins can help avoid N+1 queries by allowing you to filter or aggregate data based on associated records, it doesn't automatically preload these associated records for later use. Accessing unloaded associations will trigger separate queries, potentially leading to N+1 issues if not managed carefully.

Solution

For scenarios where you need to both join and preload associated records to avoid N+1 queries while also using the data for filtering or sorting, you can combine .joins with .includes:

@posts = Post.joins(:comments).includes(:comments).distinct

This approach leverages .joins to filter or sort based on the associated table and .includes to preload the associated records, ensuring efficient data access and avoiding N+1 queries.

Understanding when and how to use .joins, .includes, and other ActiveRecord query methods like .preload and .eager_load is essential for optimizing database queries in Ruby on Rails applications. Each method serves different purposes, and choosing the right one depends on your specific requirements for querying and accessing associated records.

Scope vs Class Methods

Trupti — Sat, 10 Feb 2024 12:23:59 +0000

Recently in one of interviews, I was asked about this and that led me to revisit these concepts again.

What is Scope in Ruby on Rails?

In Ruby on Rails, scope refers to a way to define commonly used queries that can be referenced as method calls on ActiveRecord models. Scopes allow you to encapsulate query logic, making it reusable and easy to maintain.

Example scope of Post model, in which we frequently need to fetch published posts, we can define a scope like so:

class Post < ApplicationRecord
  scope :published, -> { where(published: true) }
end

Characteristics of Scopes

Chainable: Since scopes always return an ActiveRecord::Relation, they're guaranteed to be chainable with other scopes or query methods.
Simplified Syntax: Scopes provide a more succinct way to write reusable query logic with a clear intention.
Default Scope: You can define a default scope that applies to all queries on the model.

What are Class Methods in Ruby on Rails?

Class methods in Ruby on Rails serve a similar purpose as scopes, allowing you to define methods at the class level. These methods can perform operations or queries related to the class they are defined in.

Example of class method on Post model, we can define a class method to achieve the same result as the scope:

class Post < ApplicationRecord
  def self.published
    where(published: true)
  end
end

Characteristics of Class Methods

Flexibility: Class methods can contain any Ruby code, which allows for complex logic that might be awkward or impossible to define in a scope.
Return Values: While they can return an ActiveRecord::Relation to allow for chaining, they can also return any other type of object, depending on the method's internal logic.

Both of these methods can be called Post. self.published

When to Use Each

The choice between using a scope and a class method boils down to the complexity of the logic you need to implement and personal preference. Here are some guidelines:

Use scopes for simple, straightforward query conditions that will always return an ActiveRecord::Relation. They're more readable and directly convey the intention of returning a query result.
Use class methods when your query logic is complex, requires conditional logic, or when you might need to return something other than an ActiveRecord::Relation. Class methods offer the full power of Ruby, making them suitable for scenarios where scopes might not be sufficient.

In practice, many Rails developers use a combination of both, leveraging scopes for the majority of straightforward query needs and reserving class methods for when those needs exceed the neat encapsulation scopes offer. This approach takes advantage of the strengths of both techniques, leading to more maintainable and understandable model code.

Using AI tools to build a React.js application - Part 1

Trupti — Wed, 17 Jan 2024 13:08:09 +0000

In this post I am going to leverage some AI tools available to help build an application. Let's start by asking ChatGPT to help us creating a twitter-clone app and use tailwind css. I gave the following input and this is the output I received:

After following the steps given by ChatGPT and now start the server.

npm start

and here is the screenshot for the app that starts in the browser:

So lets start by adding some steps that we are going todo later on:

      <h1>Things to do</h1>
      <ul>
        <li>Create a mock up of the UI you want</li>
        <li>Make react components out of them</li>
        <li>Use AI tools to build</li>
      </ul>

and here is how it looks after adding the things that we are going to do.

next step, is I would like to ask Github Inline Copilot to add in some classes to the header and list items and accept the changes provided by Copilot.

The changes to the pages looks like this

This is not exactly the perfect looking application but still not bad if you can get this started.