Dependent destroy and nullify in Ruby on Rails - Step-by-Step Execution

Concept Flow - Dependent destroy and nullify

Parent object exists

↓

Delete parent object

↓

Dependent destroy

↓

Delete child objects

↓

Child objects removed

When a parent record is deleted, dependent destroy deletes child records, while dependent nullify keeps children but removes their link to the parent.

Execution Sample

Ruby on Rails

class Author < ApplicationRecord
  has_many :books, dependent: :destroy
end

Author.find(1).destroy

Deletes an author and all their books because of dependent: :destroy.

Execution Table

Step	Action	Parent Exists?	Child Exists?	Child Foreign Key	Result
1	Author with id=1 exists	Yes	Yes (3 books)	author_id = 1	Parent and children present
2	Call Author.find(1).destroy	Yes	Yes (3 books)	author_id = 1	Start deletion
3	dependent: :destroy triggers	Yes	Yes (3 books)	author_id = 1	Prepare to delete children
4	Delete each book	Yes	No	null	All 3 books deleted
5	Delete author	No	No	null	Author deleted, children gone
6	End	No	No	null	Deletion complete

💡 Author and all dependent books are deleted, no children remain.

Variable Tracker

Variable	Start	After Step 3	After Step 4	After Step 5
Author.exists?(1)	true	true	true	false
Books.count with author_id=1	3	3	0	0

Key Moments - 2 Insights

Why do the child books get deleted when the author is destroyed?

Because dependent: :destroy tells Rails to delete all associated child records before deleting the parent, as shown in execution_table step 3 and 4.

What happens to child records with dependent: :nullify?

Instead of deleting children, Rails sets their foreign key to null, keeping the child records but removing the link to the parent.

Visual Quiz - 3 Questions

Look at the execution_table at step 4, what happens to the child books?

A Their foreign keys are set to null

B They remain unchanged

C They are deleted

D They are duplicated

💡 Hint

Check the 'Result' column at step 4 showing 'All 3 books deleted'

At which step does the parent author get deleted?

A Step 4

B Step 5

C Step 3

D Step 6

💡 Hint

Look at the 'Action' and 'Result' columns in step 5

If dependent: :nullify was used instead of :destroy, what would happen to the books after author deletion?

A Books would remain with author_id set to null

B Books would remain unchanged with author_id still set

C Books would be deleted

D Books would be duplicated

💡 Hint

Refer to key_moments explanation about dependent: :nullify behavior

Concept Snapshot

dependent: :destroy deletes all child records when parent is deleted.
dependent: :nullify keeps child records but sets their foreign keys to null.
Use dependent options to control child record cleanup.
Deleting parent triggers dependent action automatically.
Choose destroy to remove children, nullify to keep them without parent link.

Full Transcript

In Rails, when you delete a parent record, you can control what happens to its child records using dependent options. With dependent: :destroy, deleting the parent deletes all its children. With dependent: :nullify, deleting the parent keeps the children but removes their link by setting foreign keys to null. The execution table shows step-by-step how deleting an author with dependent: :destroy deletes all their books first, then deletes the author. Variable tracking confirms the author and books no longer exist after deletion. This helps keep your database clean and consistent automatically.

Practice

1. What does dependent: :destroy do in a Rails model association?

easy

A. Deletes associated records when the parent record is deleted.

B. Sets associated records' foreign keys to null when the parent is deleted.

C. Prevents deletion of the parent record if associated records exist.

D. Copies associated records to a backup table before deletion.

Solution

1. Step 1: Understand the role of dependent option

   The dependent option in Rails associations controls what happens to associated records when the parent is deleted.

2. Step 2: Identify behavior of :destroy

   The :destroy option deletes all associated records automatically when the parent record is deleted.

3. Final Answer:

   Deletes associated records when the parent record is deleted. -> Option A

4. Quick Check:

   dependent: :destroy = deletes associated records [OK]

Hint: Destroy deletes children; nullify just clears foreign keys [OK]

Common Mistakes:

• Confusing :destroy with :nullify behavior
• Thinking :destroy prevents parent deletion
• Assuming it backs up records before deletion

2. Which is the correct syntax to set an association to nullify dependent records in Rails?

easy

A. has_many :comments, dependent: :delete_all

B. has_many :comments, dependent: :remove

C. has_many :comments, dependent: :nullify

D. has_many :comments, dependent: :destroy_all

Solution

1. Step 1: Recall valid dependent options in Rails

   Rails supports :destroy, :delete_all, and :nullify as valid dependent options.

2. Step 2: Identify the option that sets foreign keys to null

   dependent: :nullify sets the foreign keys of associated records to null instead of deleting them.

3. Final Answer:

   has_many :comments, dependent: :nullify -> Option C

4. Quick Check:

   dependent: :nullify = sets foreign keys to null [OK]

Hint: Use :nullify to keep records but clear foreign keys [OK]

Common Mistakes:

• Using :destroy_all which is invalid
• Confusing :delete_all with :nullify
• Using non-existent :remove option

3. Given the models:

class Post < ApplicationRecord
  has_many :comments, dependent: :nullify
end

class Comment < ApplicationRecord
  belongs_to :post, optional: true
end

What happens to comments when a post is deleted?

medium

A. Comments remain but their post_id is set to null.

B. All comments are deleted from the database.

C. Comments remain unchanged with the same post_id.

D. An error occurs because comments must belong to a post.

Solution

1. Step 1: Analyze the dependent option in Post model

   The dependent: :nullify option means when a post is deleted, associated comments' foreign keys (post_id) are set to null.

2. Step 2: Check if comments can have null post_id

   The belongs_to :post, optional: true allows comments to exist without a post, so setting post_id to null is valid.

3. Final Answer:

   Comments remain but their post_id is set to null. -> Option A

4. Quick Check:

   dependent: :nullify + optional: true = nullify foreign keys [OK]

Hint: Nullify keeps records but clears foreign keys if optional true [OK]

Common Mistakes:

• Assuming comments get deleted with post
• Ignoring optional: true and expecting errors
• Thinking comments keep old post_id after deletion

4. Identify the error in this Rails model code:

class User < ApplicationRecord
  has_many :posts, dependent: :nullify
end

class Post < ApplicationRecord
  belongs_to :user
end

medium

A. belongs_to should be has_many in Post model.

B. No error; code works as expected.

C. dependent: :nullify is invalid syntax for has_many.

D. Posts cannot have null user_id because belongs_to is not optional.

Solution

1. Step 1: Understand dependent: :nullify effect

   It sets foreign keys of associated posts to null when a user is deleted.

2. Step 2: Check belongs_to association in Post

   belongs_to :user by default requires user_id to be present (not null). Since it's not marked optional, nullifying user_id causes validation or DB errors.

3. Final Answer:

   Posts cannot have null user_id because belongs_to is not optional. -> Option D

4. Quick Check:

   dependent: :nullify requires optional belongs_to [OK]

Hint: Use optional: true with nullify to avoid errors [OK]

Common Mistakes:

• Assuming nullify works without optional: true
• Thinking dependent: :nullify is invalid syntax
• Confusing belongs_to with has_many in Post

5. You have a Library model with many Books. You want to delete a library and automatically delete all its books. But if a Book has Reviews, you want to keep the reviews but remove the book reference (set book_id to null). Which setup correctly achieves this?

hard

A. Library has_many :books, dependent: :destroy; Book has_many :reviews, dependent: :destroy; Review belongs_to :book, optional: true

B. Library has_many :books, dependent: :destroy; Book has_many :reviews, dependent: :nullify; Review belongs_to :book, optional: true

C. Library has_many :books, dependent: :nullify; Book has_many :reviews, dependent: :destroy; Review belongs_to :book

D. Library has_many :books, dependent: :nullify; Book has_many :reviews, dependent: :nullify; Review belongs_to :book

Solution

1. Step 1: Set Library to delete all books on deletion

   Using dependent: :destroy on has_many :books deletes all books when a library is deleted.

2. Step 2: Set Book to nullify reviews instead of deleting

   Using dependent: :nullify on has_many :reviews keeps reviews but sets their book_id to null.

3. Step 3: Allow reviews to have null book_id

   Marking belongs_to :book, optional: true in Review allows book_id to be null without errors.

4. Final Answer:

   Library has_many :books, dependent: :destroy; Book has_many :reviews, dependent: :nullify; Review belongs_to :book, optional: true -> Option B

5. Quick Check:

   destroy deletes children; nullify clears foreign keys with optional true [OK]

Hint: Destroy parents, nullify grandchildren with optional belongs_to [OK]

Common Mistakes:

• Using nullify on library-books deletes nothing
• Destroying reviews deletes data you want to keep
• Not setting optional: true on Review's belongs_to