What is Eager Loading?

Eager loading addresses the N+1 query problem by loading all the necessary data (including associations) upfront. Instead of waiting until the association is accessed, Rails retrieves all related data in a single query.

We can achieve eager loading using the includes method. Below is a example

user = User.includes(:posts).first # loads both the User and the associated Posts at the same time

Here, Rails not only loads the user but also fetches the associated posts in one go. This minimizes the number of queries and makes the code more efficient, especially when dealing with large datasets.

Pros:

        1) Reduces the number of database queries, avoiding the N+1 problem

        2) Improves performance when you know you’ll need the associated data soon

Cons:

       1) Loads more data upfront, which may not be efficient if the associated data is not always needed

Example of Eager Loading to Prevent N+1 Queries: 

users = User.includes(:posts).all # loads all users and their associated posts in one query 

users.each do |user| 
     puts user.posts.count # no additional queries are triggered
end

In this case, Rails only executes 1 query to load both the users and their posts. Even when accessing the posts inside the loop, no additional queries are needed. This is the power of eager loading.

What is Lazy Loading? 

Lazy loading is a strategy where data is only loaded when it’s explicitly needed. Instead of fetching all related data upfront, Rails waits until you access an association before loading it from the database. This can reduce the initial load time of an object, but it might also cause multiple database queries later on.

Example of Lazy Loading:

Let’s say you have two models: User and Post, where each user can have many posts.

user = User.first # loads the User data from the database 
posts = user.posts # this query is executed only when 'posts' is called

Here, when we retrieve the user object using User.first, Rails only queries the users table. The associated posts (from the posts table) are not fetched at this point. They will only be loaded when you call user.posts. This is lazy loading in action.

Pros:

        1) Efficient when you don’t always need associated data

        2) Reduces the initial data load and query complexity

Cons:

        1) Can lead to the N+1 query problem, which happens when Rails executes a new query every time an association is accessed in a loop

N+1 Query Problem Example:

users = User.all # loads all users 

users.each do |user| 
    puts user.posts.count # triggers a new query for each user's posts 
end

If there are 10 users, this loop would execute 1 query to load the users and then an additional 10 queries to load each user’s posts—leading to a total of 11 queries. This problem is common with lazy loading.

When to Use Lazy Loading vs. Eager Loading

1) Lazy Loading: Use lazy loading when you’re unsure if the associated data will be needed or if you want to keep the initial load lightweight. For example, if you have a dashboard where users may or may not click to view related posts, lazy loading can prevent unnecessary data fetching

2) Eager Loading: Eager loading is more efficient when you know for sure that you’ll need the associated data. This is especially useful in reports or listings where the associated data (e.g., posts, comments) will always be displayed along with the parent data (e.g., users)

Both lazy loading and eager loading are powerful techniques in Rails for managing database queries, each with its advantages and drawbacks. Lazy loading helps keep initial requests lightweight, but it can lead to performance issues like the N+1 query problem. Eager loading solves this by fetching all needed data upfront, reducing the number of database queries.

swaz_ahmed

I am swaz_ahmed blogger on shadbox. I am influencer,content writer,author and publisher. Feel free to ask me any question and suggestions.