has_many

We'll need to implement has_many relationships on both Photo and Slideshow. Figure 3-2 shows the mapping between Active Record objects and database tables with has_many.

Figure 3-2. The entity (slideshow) has_many associations (slides) relationship is a one-to-many relationship

has_many is the other side of a belongs_to relationship, so you don't need to modify the class or table for Slide. You can merely add the relationship has_many to slideshow.rb:

class Slideshow < ActiveRecord::Base
  has_many :slides
end

And now, photo.rb:

class Photo < ActiveRecord::Base
  has_many :slides
  validates_presence_of :filename
end

By specifying that a photo has many slides, you give users the ability to use the same photo in several different slideshows. Remember: a slide is a photo and a position in a specific slideshow. So a slide can't be reused, but a photo can.

That's all you have to do to manage the second side of the relationship. Now, you can to see all of the slides associated with a photo, and all of the slides in a slideshow. As usual, you can open the console to see the model in action:

>> slide = Slide.find 1
...
>> slideshow = slide.slideshow
...
>> slideshow.slides.each {|slide| puts slide.photo.filename}
balboa_park.jpg
camel.jpg
cat_and_candles.jpg
hut.jpg
mosaic.jpg
polar_bear.jpg
police.jpg
sleeping_dog.jpg
stairs.jpg

So you get a list of slides in the slideshow, and each has an associated photo. Active Record is now managing the has_many relationship between Slideshow and Slide. You could use photo.slides in the same way. Table 3-2 shows you the metaprogramming for has_many.

Cascading Relationships

Many-to-one relationships introduce some problems for persistence frameworks. Primarily, the framework designer has to decide whether deleting a parent object also deletes child objects as well. Automatic deletion of dependent objects is called cascading deletes. Sometimes, you want automatic deletion to happen. For example, deleting an invoice should also delete the line items for that invoice. But sometimes, you want related objects to stay: employees should not be deleted when a department is dissolved. If you define a relationship with the :dependent option, deleting a row also deletes the associated objects. For example, to define an invoice, you might specify your invoice like this:

class Invoice < ActiveRecord::Base
  has_many :line_items, dependent => true
end

With this definition, deleting an invoice would also delete associated line items, each with a separate query. Sometimes, using a separate query to delete each child is unnecessarily inefficient, but there's a remedy. If the line items belong to one invoice—and only one—you can set the exclusively_dependent parameter on has_many to true, and Active Record will delete all dependent objects with one query.

Similarly, when you read an object, you need to decide whether to load dependent objects. By default, Active Record does not cascade loads. But you can load children when you load a parent by using the :include option on any finder.

Table 3-2. Metaprogramming for has_many

Added feature	Description
Methods
<associations><< object	Add an object to the <associations> collection: photo.slides << a_slide
<associations>.delete object	Delete an object in the <associations> collection. The objects will be destroyed if the dependent parameter of has_many is set to true: photo.slides.delete a_slide
<associations>_singular_ids collection	Replace the <associations> collection with a collection of objects identified by ids in the collection: photo.slides_singular_ids [1, 2, 3, 4]
<associations>.find	Uses the same rules as a basic find, but operates only on the items in the <associations> collection: photo.slides.find_by_position 4
<associations>.clear	Delete all of the objects in the association: photo.slides.clear
<associations>.empty?	Test to see if <associations> collection is empty: photo.slides.clear
<associations>.size	Return the number of items in the <associations> collection: photo.slides.size
<associations>.build	Build an object of the associated type, but do not initialize it to the root object. It takes a hash map of attributes for the new object as a parameter: slide.build_photo(:filename => "cat.jpg" In this example, photo.slide is initialized to nil.
<associations>.create	Create an object of the associated type, initialized to the root object. It takes a hash map of attributes for the new object as a parameter: slide.build_photo(:filename => "cat.jpg" In this example, photo.slide is initialized to slide.
Attributes
<associations>	A collection of the associated objects: slide.photos[4]