[?mellow guitar music?]

[Think Vitamin Membership - Est. 2010] [membership.thinkvitamin.com]

Ruby on Rails: Basic Associations: Part 1 with Jim Hoskins]

Often, when creating web applications, we need our different models

to be associated with each other in different ways.

In this video, we'll see how ActiveRecord makes managing those associations easy.

So here in TextMate, we have our Rails project that we've been working on

open and ready for us to edit, and if you haven't been following along,

you can download the code from this video's webpage

and all you need to do is unzip it into a folder like this.

I'm assuming you have Ruby installed.

What you'll want to do is make sure you have Bundler installed

so something like $gem install bundler

and you may have to go ahead and do a $sudo for that.

And once you have Bundler installed and you're inside of the application folder,

all you need to do to get it running is type in $bundle install

and this will install Rails and all the other dependencies

in order to get this application up and running.

Now, to start up this application, all we need to do is type in $rails s or $rails server

and it should look something like this, which means we can now go over to our browser

and go to localhost port 3000 and we should see this application.

Now, since the database was bundled in,

you should have this same data that I'm looking at here.

So far, we've implemented projects for our task manager

and ultimately what we want to do is for each project

to be able to implement several tasks within that.

Now, what we've implemented in this project so far

is projects, so we can split up our tasks into different projects.

Now, the next thing we want to do is actually create tasks within those projects.

Let's think about what this means for when we build our models.

Every project in our database will have zero or more tasks associated with that project

and each task in our database will have exactly one parent project associated with it.

Now, to represent this in a relational database,

what we can do is assign a project number

to each of our task instances.

For instance, if we had a task and we saw its project number is 3,

we can locate that project instance by searching for the project with the id of 3

in the database.

Conversely, if we have a project--let's say it's project number 4--

and we wanted to know all of the tasks that belong to that project,

we could search through all of our tasks and look for the ones with project number 4

associated with it.

In real terms, what we'll do is call this property on our task the project_id

and its value will correspond to the id value of a certain project.

Now, this project id property is what we call a foreign key,

which means it holds the primary key or id value of some foreign model.

Now, if were coding the database queries ourself,

we could create different queries using the joint operator

to efficiently pull the associated objects from the database,

but in ActiveRecord in Rails, it's much easier.

So first, let's actually create our model.

To do this, I'm going to go over to our Terminal

and I have a new tab open that's in our projects directory here

and we'll go ahead and use the Rails generator to create it.

And we're going to use a scaffold generator

because eventually, we will want the views and controllers for our tasks,

even though right now, we're just going to be primarily concerned with the model.

So what we'll do is $rails generate scaffold

for the Task model.

Now we need to define the properties that we want associated with our Task model.

The order we define these doesn't matter, so I'm going to start with the name.

I want each Task to have a name, and that's going to be a string,

so we'll do name:string.

Now you can see it's sort of broken onto two lines, just to show you

that it's all one token there,

I'll just add some spaces, and the next property we want to do is completed

because we want to be able to complete our task,

and this will be of type boolean,

And now we need to add our foreign key that we were talking about,

and we're going to call this project_id: and we're going to give it the type of integer.

Now, the reason we're calling it project_id is because it's a convention

when we're defining foreign keys for it to take the form of the name of the model _id.

In this case, this foreign key relates to the project, so we'll call it project_id.

Now it's of type integer because it will match up with the primary key

or id column from our project,

and we give it the type integer because it matches up with the id property

of the actual project class.

So let's go ahead and create this,

and it looks like we've got everything we need

so we're going to go back to our code and we'll open up the CreateTasks migration file.

You can just open it up by searching for it, or you can go to db migrate

and look for the migration that ends with CreateTasks.

So we can see we have the string :name,

the boolean :completed,

the integer :project_id

and it will add the magical timestamps for created at and updated at.

So that looks good to us,

and let's go ahead and run that migration.

So in order to do that, we do $rake db:migrate

and we've created our tasks.

Now let's open up our Rails console to see how all of this works.

So I'm going to type in $rails console or we can just do rails c

and so we can mess around and we can see Project.all.

Cool.

We can see Task.all and we can see that it's empty right now.

And now we've defined our new model with a foreign key.

In the next video, we'll see how to tell ActiveRecord to use this foreign key.

[?mellow guitar music?]

[Think Vitamin Membership - Est. 2010] [membership.thinkvitamin.com]