Dependent destroy and nullify in Ruby on Rails - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What happens when a parent record is destroyed with dependent: :destroy?

Consider a Rails model Author that has_many :books, dependent: :destroy. What happens to the associated books when an Author is deleted?

Ruby on Rails

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

class Book < ApplicationRecord
  belongs_to :author
end

# In Rails console:
author = Author.find(1)
author.destroy

A All associated books have their author_id set to NULL but remain in the database.

B All associated books are deleted from the database automatically.

C The author record is deleted but the books remain unchanged with their author_id intact.

D An error is raised because dependent: :destroy requires manual deletion of books.

💡 Hint

Think about what dependent: :destroy means for child records when the parent is removed.

Using dependent: :destroy means Rails will automatically delete all associated child records when the parent is destroyed. So, all books linked to the author are deleted from the database.

❓ component_behavior

intermediate

What is the effect of dependent: :nullify on associated records?

Given a Rails model Category that has_many :products, dependent: :nullify, what happens to the products when a Category is destroyed?

Ruby on Rails

class Category < ApplicationRecord
  has_many :products, dependent: :nullify
end

class Product < ApplicationRecord
  belongs_to :category, optional: true
end

# In Rails console:
category = Category.find(1)
category.destroy

A All associated products have their category_id set to NULL but remain in the database.

B All associated products are deleted from the database.

C The category record is deleted but products keep their category_id pointing to the deleted record.

D An error is raised because dependent: :nullify requires products to be deleted manually.

💡 Hint

Think about what nullify means for foreign keys when the parent is removed.

Using dependent: :nullify means Rails will set the foreign key (category_id) to NULL on all associated products when the category is destroyed. The products remain in the database but are no longer linked to the deleted category.

🔧 Debug

advanced

Why does dependent: :destroy cause a stack level too deep error in a self-referential association?

Consider a Rails model Comment with a self-referential association:
has_many :replies, class_name: 'Comment', foreign_key: 'parent_id', dependent: :destroy
and
belongs_to :parent, class_name: 'Comment', optional: true.
Destroying a comment with replies causes a SystemStackError: stack level too deep. Why?

Ruby on Rails

class Comment < ApplicationRecord
  has_many :replies, class_name: 'Comment', foreign_key: 'parent_id', dependent: :destroy
  belongs_to :parent, class_name: 'Comment', optional: true
end

comment = Comment.find(1)
comment.destroy

A Because the replies are not loaded before destroy, causing a nil error.

B Because Rails does not support dependent: :destroy on self-referential associations.

C Because the foreign key parent_id is not nullable, causing a database constraint error.

D Because dependent: :destroy recursively destroys replies, which in turn try to destroy their parent again, causing infinite recursion.

💡 Hint

Think about what happens when destroying nested child records that point back to the parent.

The dependent: :destroy option causes Rails to destroy all replies recursively. Since replies also have dependent: :destroy on their replies, this can cause infinite recursion if a reply's parent is destroyed again during the process, leading to a stack overflow error.

📝 Syntax

advanced

Which option correctly sets up dependent: :nullify in a Rails model?

You want to set up a has_many association where deleting the parent sets the child's foreign key to NULL. Which code is correct?

A has_many :comments, dependent: :delete_nullify

B has_many :comments, dependent: :destroy_nullify

C has_many :comments, dependent: :nullify

D has_many :comments, dependent: :nullify_destroy

💡 Hint

Check the exact symbol Rails expects for nullifying foreign keys on dependent destroy.

The correct option is dependent: :nullify. The other options are invalid and will cause errors.

❓ state_output

expert

What is the state of child records after destroying a parent with dependent: :destroy and callbacks?

Given these models:
class Post < ApplicationRecord has_many :comments, dependent: :destroy end
class Comment < ApplicationRecord belongs_to :post before_destroy { puts "Destroying comment #{id}" } end
When post.destroy is called, what is the output and final state of comments?

Ruby on Rails

post = Post.find(1)
post.destroy

A Console prints "Destroying comment X" for each comment, and all comments are deleted from the database.

B Console prints nothing, and comments remain in the database with post_id set to NULL.

C Console prints "Destroying comment X" for each comment, but comments remain in the database.

D An error is raised because before_destroy callbacks prevent deletion.

💡 Hint

dependent: :destroy triggers callbacks on child records before deleting them.

When dependent: :destroy is used, Rails calls destroy on each child record, triggering callbacks like before_destroy. Then the child records are deleted from the database.