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.