has_one relationship in Ruby on Rails - Performance & Optimization

Performance: has_one relationship

MEDIUM IMPACT

This affects how Rails loads associated data and impacts page load speed and database query efficiency.

Loading a user and their profile using has_one association

Ruby on Rails

user = User.includes(:profile).find(1)
profile_name = user.profile.name

Eager loads profile with user in a single query, avoiding extra queries on access.

📈 Performance GainSingle query regardless of number of users, reducing database load and speeding up LCP

Loading a user and their profile using has_one association

Ruby on Rails

user = User.find(1)
profile_name = user.profile.name

This triggers an extra database query for the profile when accessed, causing N+1 query problem if done in a loop.

📉 Performance CostTriggers 1 extra query per user, increasing load time linearly with number of users

Performance Comparison

Pattern	DOM Operations	Reflows	Paint Cost	Verdict
Lazy loading has_one (user.profile)	N/A	N/A	Increases HTML render delay due to DB wait	[X] Bad
Eager loading has_one (User.includes(:profile))	N/A	N/A	Faster HTML render, less DB wait	[OK] Good

Rendering Pipeline

Rails fetches data from the database before rendering views. Using has_one without eager loading causes multiple queries, increasing database time and delaying HTML generation.

→Data Fetching

→View Rendering

⚠️ BottleneckData Fetching due to multiple queries

Core Web Vital Affected

LCP

This affects how Rails loads associated data and impacts page load speed and database query efficiency.

Optimization Tips

1Always eager load has_one associations when rendering views to avoid N+1 queries.

2Use User.includes(:association) to fetch related data in one query.

3Reducing database queries improves Largest Contentful Paint (LCP) and user experience.

Performance Quiz - 3 Questions

What is the main performance problem when accessing a has_one association without eager loading?

A CSS selector complexity increases

B Too many DOM nodes created

C Multiple database queries causing slower page load

D JavaScript bundle size grows

DevTools: Rails Logs

How to check: Open your Rails server logs, reload the page, and count the number of SQL queries.

What to look for: Multiple queries for associated data (e.g., SELECT from profiles table) indicate lazy loading; a single query with JOIN indicates eager loading.

Practice

1. What does the has_one association in Rails represent?

easy

A. A many-to-many connection between two models

B. A one-to-many connection from one model to many others

C. A one-to-one connection from one model to another

D. A model inheriting from another model

Solution

1. Step 1: Understand the purpose of has_one

   The has_one association sets up a one-to-one link from one model to another, meaning each instance of the first model is connected to exactly one instance of the second model.

2. Step 2: Compare with other associations

   Unlike has_many (one-to-many) or has_and_belongs_to_many (many-to-many), has_one is strictly one-to-one.

3. Final Answer:

   A one-to-one connection from one model to another -> Option C

4. Quick Check:

   has_one = one-to-one [OK]

Hint: Remember: has_one means exactly one related record [OK]

Common Mistakes:

• Confusing has_one with has_many
• Thinking has_one creates many related records
• Mixing up has_one with belongs_to

2. Which of the following is the correct syntax to declare a has_one association in a Rails model?

easy

A. has_one = :profile

B. has_one profile

C. has_one => :profile

D. has_one :profile

Solution

1. Step 1: Recall Rails association syntax

   In Rails, associations are declared using the method name followed by a symbol representing the related model, e.g., has_one :profile.

2. Step 2: Identify correct Ruby syntax

   has_one :profile uses the correct Ruby method call with a symbol argument. Options A, B, and C are invalid Ruby syntax for this purpose.

3. Final Answer:

   has_one :profile -> Option D

4. Quick Check:

   Association syntax uses symbol with colon [OK]

Hint: Use colon before association name: has_one :name [OK]

Common Mistakes:

• Omitting the colon before the association name
• Using hash rocket syntax incorrectly
• Assigning association with equals sign

3. Given these models:

class User < ApplicationRecord
  has_one :profile
end

class Profile < ApplicationRecord
  belongs_to :user
end

What will user.profile return if the user has no profile record?

medium

A. nil

B. An error is raised

C. An empty Profile object

D. A new unsaved Profile instance

Solution

1. Step 1: Understand has_one association behavior

   If no associated record exists, calling user.profile returns nil because there is no linked profile.

2. Step 2: Confirm no automatic creation

   Rails does not create or return empty or new instances automatically for has_one associations.

3. Final Answer:

   nil -> Option A

4. Quick Check:

   No associated record means nil [OK]

Hint: No linked record? Association returns nil [OK]

Common Mistakes:

• Expecting an empty or new object instead of nil
• Assuming an error is raised when missing association
• Confusing with build_profile method

4. Identify the error in this code snippet:

class User < ApplicationRecord
  has_one :profile
end

class Profile < ApplicationRecord
  has_one :user
end

medium

A. Profile should use belongs_to :user instead of has_one

B. User should use belongs_to :profile instead of has_one

C. Both models should use has_one for the association

D. No error; the code is correct

Solution

1. Step 1: Understand correct association directions

   In a one-to-one relationship, the model holding the foreign key uses belongs_to. Here, Profile should belong to User.

2. Step 2: Identify incorrect association

   Using has_one :user in Profile is wrong because it implies Profile owns User, which is not the case.

3. Final Answer:

   Profile should use belongs_to :user instead of has_one -> Option A

4. Quick Check:

   Foreign key side uses belongs_to [OK]

Hint: belongs_to goes on model with foreign key [OK]

Common Mistakes:

• Using has_one on both sides
• Confusing which model holds foreign key
• Omitting belongs_to in related model

5. You want to ensure that when a User is deleted, their associated Profile is also deleted automatically. How do you modify the has_one association in the User model?

hard

A. has_one :profile, autosave: true

B. has_one :profile, dependent: :destroy

C. has_one :profile, validate: true

D. has_one :profile, inverse_of: :user

Solution

1. Step 1: Understand dependent option in associations

   The dependent: :destroy option tells Rails to delete the associated record when the owner is deleted.

2. Step 2: Apply to has_one association

   Adding dependent: :destroy to has_one :profile ensures the profile is removed automatically with the user.

3. Final Answer:

   has_one :profile, dependent: :destroy -> Option B

4. Quick Check:

   dependent: :destroy deletes associated record [OK]

Hint: Use dependent: :destroy to auto-delete associated record [OK]

Common Mistakes:

• Using autosave or validate instead of dependent
• Forgetting to add dependent option
• Confusing inverse_of with dependent