Okay we need relationships in our app so that we can actually call it social.

We'll do a pretty simple relationship where I can follow you, but

that doesn't automatically make you follow me.

The usual way of talking about this is calling it an asymmetrical relationship.

We'll do that with a couple of foreign keys and a new model, and

then we'll update our user model to add some handy query methods for

finding out who you're following and who's following you.

'Kay, so we need to build our relationship model.

And we're gonna add that in down here.

And it's gonna be called class Relationship.

And it's a model.

And so we're gonna have two fields.

We're gonna have the user that it's from which is always gonna be,

when you're thinking about this, me.

It's always the user who's logged in.

So from_user, and ForeignKeyField,

and up here we did this rel model user related name equals posts.

We can do that, or we can just say user and

then related_name equals relationships.

And then to_user, ForeignKeyField, also user.

And it has to have a different related name.

So we're gonna say related_to.

So this one you can think of, who are the people who are related to me,

and this one, who are the people I'm related to?

Now we have to add in something different down here to the class meta than

what we've had before.

So first and first we're gonna say database is equal to database.

But then the new thing is that we have to specify an index.

We haven't done indexes before.

So indexes tell the database how to find the data to remember the data.

But it also allows us to specify whether or not a index is unique,

so what we wanna do is we want to say that this is a unique index.

So let's go ahead and specify the index first.

So each index is a topple.

Inside of that is a topple of fields.

So from_user and to_user.

Those are our two fields that are in our unique index.

And then we say true, so that we know that this is a unique index.

So we're gonna save that, and we're gonna add relationship down here.

And then, we need to go change our user model.

Our user models queries,

these are gonna be some very different queries from what you're used to seeing.

So, let's come back up here to our user and let's add in two new ones,

one of which to get the people that we follow [SOUND], and

one of which will get the people that are following us.

So, let's start with the people that we're following.

So let's put a name on this.

The users that we are following.

And yeah, feel free to add doc strings and

comments to all of this stuff cuz there's a lot in here.

So return.

This is gonna take up a lot of lines, so I'm gonna stick it into parens here.

So user, and then, we're gonna say .select, and

then .join, cuz we need to do a join.

We need to select from multiple tables at once.

So Relationship, that's the table we need to select from, or the model, rather.

The field we're gonna select on is relationship.to_user,

so select where the one's that I'm related to

let's put that on the next line and then where,

relationship.from_user is equal to me.

Put that on the next line too.

'Kay, so.

We're gonna select all the users where the relationship to user.

All right, I wanna get the, the relationship.to_user,

I wanna get all those users where the from_user is me in the relationship, okay.

A bit of stuff moving around, like I said.

And then let's do followers, so these are the people who are following me.

Get users following the current user.

So again, this is gonna be multiple lines, so we'll do parenths, user.select.join.

Hey look, another join.

And we want to do relationship on relationship.from_user.

I'm just making sure I'm getting these, opposite to each other.

.where, relationship.to_user is equal to me.

And, yeah I'll put that on the next line.

So these two are basically exact opposites of each other.

So on this one we're joining on the to_user,

this one we're joining on the from_user.

We're doing a where for the from_user here,

we're doing a where on the to_user here.

So those are not amazingly [LAUGH] hard, amazingly hard queries to understand,

but if you've not worked with joins before, they're a little weird.

They're a little, I mean, it's almost ridiculous having to,

like, figure out where these things traverse.

Those queries are intense, but

learning to use joins like that will open up a lot of new worlds for using ORMs.

Now that we can follow people and see who's following us,

let's build the UI that we need to create these relationships.