has_one

Specifies a one-to-one association with another class. This method should only be used if the other class contains the foreign key. If the current class contains the foreign key, then you should use belongs_to instead. See also ActiveRecord::Associations::ClassMethods's overview on when to use has_one and when to use belongs_to.

The following methods for retrieval and query of a single associated object will be added:

association(force_reload = false)

Returns the associated object. nil is returned if none is found.

association=(associate)

Assigns the associate object, extracts the primary key, sets it as the foreign key, and saves the associate object. To avoid database inconsistencies, permanently deletes an existing associated object when assigning a new one, even if the new one isn't saved to database.

build_association(attributes = {})

Returns a new object of the associated type that has been instantiated with attributes and linked to this object through a foreign key, but has not yet been saved.

create_association(attributes = {})

Returns a new object of the associated type that has been instantiated with attributes, linked to this object through a foreign key, and that has already been saved (if it passed the validation).

create_association!(attributes = {})

Does the same as create_association, but raises ActiveRecord::RecordInvalid if the record is invalid.

(association is replaced with the symbol passed as the first argument, so has_one :manager would add among others manager.nil?.)

Example

An Account class declares has_one :beneficiary, which will add:

• Account#beneficiary (similar to Beneficiary.where(account_id: id).first)

• Account#beneficiary=(beneficiary) (similar to beneficiary.account_id = account.id; beneficiary.save)

• Account#build_beneficiary (similar to Beneficiary.new("account_id" => id))

• Account#create_beneficiary (similar to b = Beneficiary.new("account_id" => id); b.save; b)

• Account#create_beneficiary! (similar to b = Beneficiary.new("account_id" => id); b.save!; b)

Options

The declaration can also include an options hash to specialize the behavior of the association.

Options are:

:class_name

Specify the class name of the association. Use it only if that name can't be inferred from the association name. So has_one :manager will by default be linked to the Manager class, but if the real class name is Person, you'll have to specify it with this option.

:dependent

Controls what happens to the associated object when its owner is destroyed:

• :destroy causes the associated object to also be destroyed

• :delete causes the associated object to be deleted directly from the database (so callbacks will not execute)

• :nullify causes the foreign key to be set to NULL. Callbacks are not executed.

• :restrict_with_exception causes an exception to be raised if there is an associated record

• :restrict_with_error causes an error to be added to the owner if there is an associated object

:foreign_key

Specify the foreign key used for the association. By default this is guessed to be the name of this class in lower-case and â_idâ suffixed. So a Person class that makes a has_one association will use âperson_idâ as the default :foreign_key.

:primary_key

Specify the method that returns the primary key used for the association. By default this is id.

:as

Specifies a polymorphic interface (See belongs_to).

:through

Specifies a Join Model through which to perform the query. Options for :class_name, :primary_key, and :foreign_key are ignored, as the association uses the source reflection. You can only use a :through query through a has_one or belongs_to association on the join model.

:source

Specifies the source association name used by has_one :through queries. Only use it if the name cannot be inferred from the association. has_one :favorite, through: :favorites will look for a :favorite on Favorite, unless a :source is given.

:source_type

Specifies type of the source association used by has_one :through queries where the source association is a polymorphic belongs_to.

:validate

If false, don't validate the associated object when saving the parent object. false by default.

:autosave

If true, always save the associated object or destroy it if marked for destruction, when saving the parent object. If false, never save or destroy the associated object. By default, only save the associated object if it's a new record.

Note that accepts_nested_attributes_for sets :autosave to true.

:inverse_of

Specifies the name of the belongs_to association on the associated object that is the inverse of this has_one association. Does not work in combination with :through or :as options. See ActiveRecord::Associations::ClassMethods's overview on Bi-directional associations for more detail.

Option examples:

has_one :credit_card, dependent: :destroy  # destroys the associated credit card
has_one :credit_card, dependent: :nullify  # updates the associated records foreign
                                              # key value to NULL rather than destroying it
has_one :last_comment, -> { order 'posted_on' }, class_name: "Comment"
has_one :project_manager, -> { where role: 'project_manager' }, class_name: "Person"
has_one :attachment, as: :attachable
has_one :boss, readonly: :true
has_one :club, through: :membership
has_one :primary_address, -> { where primary: true }, through: :addressables, source: :addressable