Active Record pattern in Ruby on Rails - Step-by-Step Execution

Concept Flow - Active Record pattern

Define Model Class

↓

Create Object Instance

↓

Set Attributes

↓

Call Save Method

↓

Active Record Maps Object to DB

↓

Insert or Update DB Record

↓

Return Success or Failure

The Active Record pattern connects a model class to a database table, letting you create, update, and save objects that automatically map to database rows.

Execution Sample

Ruby on Rails

class User < ApplicationRecord
end

user = User.new
user.name = "Anna"
user.save

This code creates a new User object with a name and saves it to the database using Active Record.

Execution Table

Step	Action	Object State	DB Operation	Result
1	Define User model class	User class ready	No DB action	Model linked to users table
2	Create new User instance	User object with name=nil	No DB action	Object created in memory
3	Set attribute name='Anna'	User object with name='Anna'	No DB action	Attribute set in object
4	Call save method	User object with name='Anna'	INSERT INTO users (name) VALUES ('Anna')	Record saved in DB
5	Save returns true	User object saved	No DB action	Save successful

💡 Save completes successfully, object data stored in database

Variable Tracker

Variable	Start	After Step 2	After Step 3	After Step 4	Final
user	undefined	User instance (name=nil)	User instance (name='Anna')	User instance (name='Anna', persisted)	User instance saved

Key Moments - 3 Insights

Why doesn't the database get updated when we just create a new User object?

Creating a new User instance only makes an object in memory (see Step 2 in execution_table). The database updates only happen when calling save (Step 4).

What does the save method do exactly?

Save checks if the object is new or existing, then inserts or updates the database record accordingly (Step 4 shows an INSERT). It returns true if successful (Step 5).

How does Active Record know which table to use?

By convention, the User model maps to the 'users' table automatically (Step 1). This is why no explicit table name is needed.

Visual Quiz - 3 Questions

Look at the execution_table, what is the state of the user object after Step 3?

A User instance with name=nil

B User instance with name='Anna'

C User instance saved in DB

D No user object exists

💡 Hint

Check the 'Object State' column at Step 3 in execution_table

At which step does the database record get created?

A Step 4

B Step 3

C Step 2

D Step 5

💡 Hint

Look at the 'DB Operation' column in execution_table

If we skip calling save, what happens to the user object?

A It is saved automatically

B It deletes itself

C It remains only in memory without DB record

D It updates the DB anyway

💡 Hint

Refer to Step 2 and Step 4 in execution_table and variable_tracker

Concept Snapshot

Active Record pattern links model classes to database tables.
Create an object, set attributes, then call save to insert/update DB.
Save returns true if successful.
Model class name maps to table name by convention.
Objects exist in memory until saved.
This pattern simplifies database work in Rails.

Full Transcript

The Active Record pattern in Rails connects a model class to a database table. First, you define a model class like User that inherits from ApplicationRecord. Then you create an instance of this class in memory. You set attributes on this object, such as name. The database is not affected yet. When you call the save method on the object, Active Record generates an SQL INSERT or UPDATE command to store the data in the database. The save method returns true if the operation succeeds. This pattern lets you work with database records as simple Ruby objects, making database interaction easier and more natural. The model class name automatically maps to the corresponding database table by Rails convention. Until you call save, the object only exists in memory and does not affect the database.

Practice

1. What is the main purpose of the Active Record pattern in Rails?

easy

A. To link Ruby classes with database tables for easy data management

B. To create user interfaces with Ruby code

C. To handle HTTP requests and responses

D. To style web pages using CSS

Solution

1. Step 1: Understand Active Record's role

   Active Record connects Ruby classes to database tables, making data handling easier.

2. Step 2: Compare options to this role

   Only To link Ruby classes with database tables for easy data management describes this connection; others describe unrelated tasks.

3. Final Answer:

   To link Ruby classes with database tables for easy data management -> Option A

4. Quick Check:

   Active Record = Ruby class to DB table link [OK]

Hint: Active Record links Ruby classes to tables [OK]

Common Mistakes:

• Confusing Active Record with view or controller roles
• Thinking it handles HTTP or styling
• Assuming it writes SQL directly

2. Which of the following is the correct way to find a record by its ID using Active Record?

easy

A. User.find_by_id(5)

B. User.where(id: 5).first!

C. User.find(5)

D. User.get(5)

Solution

1. Step 1: Recall Active Record find methods

   The method find fetches a record by its ID directly.

2. Step 2: Check each option

   User.find(5) uses find(5), which is correct. User.find_by_id(5) is deprecated. User.where(id: 5).first! is valid but less direct. User.get(5) is invalid.

3. Final Answer:

   User.find(5) -> Option C

4. Quick Check:

   Use find(id) to get record by ID [OK]

Hint: Use find(id) to get record by ID [OK]

Common Mistakes:

• Using deprecated find_by_id instead of find
• Using invalid method names like get
• Confusing where.first! with find for simple ID lookup

3. Given the code:

user = User.find(3)
user.update(name: "Alice")
puts user.name

What will be printed?

medium

A. Alice

B. An error message

C. nil

D. 3

Solution

1. Step 1: Understand the update method

   The update method changes the record's attributes and saves it.

2. Step 2: Check the output of puts user.name

   After updating, user.name is "Alice", so it prints "Alice".

3. Final Answer:

   Alice -> Option A

4. Quick Check:

   update changes attribute, then prints new value [OK]

Hint: update changes and saves record attributes [OK]

Common Mistakes:

• Thinking update returns the ID
• Assuming update does not save changes
• Expecting nil or error without reason

4. What is wrong with this code snippet?

post = Post.find(10)
post.title = "New Title"
post.save!

medium

A. Using save! will not save changes

B. No error; this code correctly updates the post title

C. Assigning title directly is not allowed

D. find(10) returns an array, not a single record

Solution

1. Step 1: Analyze the code actions

   The code finds a post by ID, changes its title, then saves it with save!.

2. Step 2: Check if any step is invalid

   Assigning attributes directly and using save! is valid and will update the record.

3. Final Answer:

   No error; this code correctly updates the post title -> Option B

4. Quick Check:

   Direct attribute assignment + save! updates record [OK]

Hint: Direct attribute change + save! updates record [OK]

Common Mistakes:

• Thinking save! does not save changes
• Believing find returns an array
• Assuming direct assignment is forbidden

5. You want to get all users who signed up after January 1, 2023, and order them by their signup date descending. Which Active Record query is correct?

hard

A. User.select_all.where(created_at > '2023-01-01').order_desc('created_at')

B. User.find_by(created_at: '> 2023-01-01').sort(created_at: :desc)

C. User.filter(created_at > '2023-01-01').order_by('created_at desc')

D. User.where('created_at > ?', '2023-01-01').order(created_at: :desc)

Solution

1. Step 1: Identify correct where syntax

   Active Record uses where('created_at > ?', date) to filter by date.

2. Step 2: Identify correct order syntax

   Ordering is done with order(created_at: :desc) for descending order.

3. Step 3: Compare options

   Only User.where('created_at > ?', '2023-01-01').order(created_at: :desc) uses correct where and order syntax; others use invalid or non-existent methods.

4. Final Answer:

   User.where('created_at > ?', '2023-01-01').order(created_at: :desc) -> Option D

5. Quick Check:

   where + order with symbols = correct query [OK]

Hint: Use where with ? and order with symbol for sorting [OK]

Common Mistakes:

• Using find_by instead of where for multiple records
• Using non-existent methods like filter or order_desc
• Incorrect syntax in where clause