Bummer! This is just a preview. You need to be signed in with a Basic account to view the entire video.

Preview

Start a free Basic trial
to watch this video

Sign up for Treehouse

Has One Associations

3:39 with Jay McGavren

Some tables in your database will have a tendency to grow in number of columns over time. Eventually, the number of columns can become unwieldy. When this happens, it may be a good idea to move the less-frequently-used columns to a separate table, and have them tracked by a separate Rails model.

Some tables in your database will have a tendency to grow in number of columns over time. Eventually, the number of columns can become unwieldy. When this happens, it may be a good idea to move the less-frequently-used columns to a separate table, and have them tracked by a separate Rails model.

A foreign key in the original table references the primary key of the new table. This works just like a has_many association, except that a record in the original table will only ever be associated with one record in the new table. So Active Record calls this a has_one association.

We're back in our forum app, and we want to create a Profile model to hold some of our user data. The User model class will have a has_one association with the Profile class.

We can generate the Profile model like this:

bin/rails g model Profile user:references twitter:string github:string

That creates this migration:

class CreateProfiles < ActiveRecord::Migration[5.0]
  def change
    create_table :profiles do |t|
      t.references :user, foreign_key: true
      t.string :twitter
      t.string :github

      t.timestamps
    end
  end
end

Then we need to declare that a User has_one Profile:

class User < ApplicationRecord
  has_and_belongs_to_many :forums
  has_one :profile
end

With that done, we can set up a Profile for a User in the Rails console:

user = User.find_by(name: "Jay")
user.profile
user.create_profile(twitter: "jaymcgavren", github: "jaymcgavren")
pp User.first
pp User.first.profile
  • 0:00

    Some tables in your database will have a tendency to grow

  • 0:03

    in number of columns over time.

  • 0:05

    Eventually the number of columns can become unwieldy.

  • 0:08

    When this happens it may be a good idea to move the less frequently used columns to

  • 0:12

    a separate table and have them tracked by a separate Rails model.

  • 0:16

    A foreign key in the original table references the primary key of

  • 0:20

    the new table.

  • 0:21

    This works just like a has_many association,

  • 0:24

    except that a record in the original table will only ever be associated with

  • 0:28

    one record in the new table.

  • 0:30

    So Active Record calls this a has_one association.

  • 0:34

    We're back in our forum map, and

  • 0:36

    we wanna create a profile model to hold some of our user data.

  • 0:40

    The user model class will have a has_one association with the profile class.

  • 0:45

    So let's generate this new profile model,

  • 0:50

    bin/rails g model Profile, and we'll set up a foreign

  • 0:56

    key to the user's table with user:references.

  • 1:01

    Then we'll add a couple attributes that the Profile model is going to track.

  • 1:05

    We'll track the user's Twitter handle with a column named twitter and

  • 1:09

    a type of string.

  • 1:12

    And we'll track a user's github users name, also with a type of string.

  • 1:21

    That'll create a migration to set up our new profiles table.

  • 1:30

    Note the foreign key for the users table to get set up here

  • 1:34

    as well as the attributes that are specific to the profile model.

  • 1:39

    Because the foreign key will be here in the profiles table,

  • 1:41

    there's no need to make any changes to the users table.

  • 1:45

    Let's go ahead and run our new migration with bin/rails db:migrate.

  • 1:52

    And the migration will create our new profiles table.

  • 1:56

    Then we need to add an association to the model class,

  • 1:59

    we'll go into the user model class.

  • 2:03

    And we'll add a new association, has_one :profile,

  • 2:09

    note that that's in the singular form, not the plural.

  • 2:13

    Let's save that, and now if we launch a Rails console,

  • 2:20

    and look up a user, user = User.find_by name: Jay.

  • 2:30

    User model objects should have a profile method available on the map.

  • 2:35

    That seems to work, but this user doesn't currently have a profile.

  • 2:39

    So we'll call user.create_profile to create one and

  • 2:44

    automatically associate it with this user.

  • 2:46

    We'll say that the profile's Twitter username should be jaymcgavren.

  • 2:55

    And the GitHub username should also be jaymcgavren.

  • 3:03

    Now, if we take a look at this user, we'll see

  • 3:08

    that there's no changes to its attributes directly.

  • 3:10

    But, if we take a look at that user's profile,

  • 3:14

    we'll see the new profile object with its Twitter and GitHub handles set.

  • 3:18

    So that's how to create has_one associations.

  • 3:21

    See the teacher's notes, if you'd like more info.

  • 3:24

    Now you know how to associate models with each other.

  • 3:27

    And you can use those associations within the Rails console.

  • 3:31

    You may find there's a little more to do before you can display and

  • 3:34

    update associations within your app though.

  • 3:36

    We'll look into those details next.

You need to sign up for Treehouse in order to download course files.

Sign up