[MUSIC]

[SOUND] Most of this stage is going to concentrate on area of models

that we haven't talk about before, inheritance.

If you played around with object oriented Python, which I'm assuming you

have because you've come this far, then this should be pretty comfortable to you.

Model inheritance lets us define some fields, methods, attributes, etc, in

one model, and then reuse those in another model without having to repeat them again.

Django models really are just Python classes.

Where this matters, though, is your actual database.

Sometimes you want more tables, sometimes you don't.

Let's start with model inheritance that doesn't make a new table.

We call this abstract inheritance, and

we call the models that don't have a database table abstract models.

Django has two main types of inheritance, abstract and multi-table.

Let's look at abstract first.

In abstract inheritance, we have a model that's marked as abstract.

We'll call ours User.

This user model won't actually have a database table and

can't be used for quires.

So how's this useful?

This model can be used for a starter for other models.

Maybe we have Students and Staff.

These are both users but we don't want to have to look up a user and

then a student or vice versa.

Since our User model is abstract, we can make both Student and

Staff extend from User.

Each of them get all of the fields of User and they get their own tables.

Our queries are simpler.

Our database design is nicer.

And our models file is still pretty easy to understand and dry.

Let's go to workspaces and make this abstract concept a bit more concrete.

So, I'm now inside of courses, models.py where all of our models are.

And we need to see about making an abstract model.

And the model that makes the most sense to make abstract at the moment is Step.

We're gonna have multiple types of steps later on, right?

We may have text based steps, we might have video based steps, we're

gonna have quizzes, eventually we'd have code challenges, all this kind of stuff.

So we wanna make it to where this is as adaptable as possible.

So some things are gonna be the same in all of these different types of steps, and

some things are gonna be different step to step.

I think content is one that is not gonna be the same in every singe step.

So it's probably one we would take take out.

First though, let's come down here and

to make Step abstract, we have to say that it's abstract.

So we say abstract = True.

Now, that means that we're basically gonna get rid of the table.

And we just got an error here.

It tried to restart and it's like, oh, you can't have abstract models in admin.

We're gonna fix that in just a minute.

So then, let's take content.

Oops, let's take content out.

And I'm gonna cut that instead of just deleting it,

cuz I need to use it again in a minute.

And let's make our new class.

And so this class is gonna be called Text.

This will represent our text steps.

And since Text will be a step, we're gonna have it inherit from Step.

And then, we'll put our content field back in there, okay?

Cuz we want to have a content field.

And that should be it.

Everything else is gonna come from Step.

We're gonna get this dunder __str__.

We're gonna get the ordering.

We're gonna get all that stuff from Step.

The only thing that's not gonna happen is Step won't be in the database.

So let's save that.

And let's come down here and we're gonna have to make some migrations.

So python manage.py makemigrations courses.

Now, we wanna be sure and we need to pay attention to this one.

So we're gonna do that and, oh, sorry, we're gonna go fix our admin real quick.

Let's go over here to admin, and

let's come down here and let's not register step.

And let's take off that inline as well.

All right.

So now let's give it a try.

There you go, okay.

Cool, all right, [LAUGH] so now this asked us a very important question.

Did you rename the courses.Step model to Text?

And we did.

We want all of our existing steps that we created in Django basics,

we want all of those to still be in here.

We just wanted to move them over to the Text table.

So we're gonna answer y, press Return, and now we get this migration and

we have rename model Step to text.

And I wanna actually look at this migration because this is

an important one.

So if we look here and we look through here,

we see that we renamed the model Step to Text, and that's really all we did.

That's it, because that's really what we wanted to do.

We wanted Step to become abstract.

We don't want step to exist anymore.

But we want all the data that's in Step to move over to this new table called Text.

So now let's go ahead and run that, python mange.py migrate courses.

Press Return, and then now its asking us,

do we still have the content type of Step that belongs to Courses?

And we don't, it's now called Text its no longer called Step so that doesn't exist.

So we're gonna type yes to tell Django to get rid of it.

And then let's go ahead and run our server.

And let's go fix our admin.

All right, everything's up and running.

Close that migration.

And up here inside of Step we wanna bring in Text.

And let's change this over to TextInline, even though we probably wanna get rid of

these inlines and come up with something a little better later on.

And we're actually gonna build a lot of this out as a little CMS in a bit.

TextInline, and we'll register Text.

All right, cool.

And now if we come look at our Site administration, we had Steps.

So let's refresh that, we should now have Texts.

And if we look in our Texts, we still have the couple that we made before.

And if we look at Courses and we look inside here,

we still have the ability to create Texts from inside of the admin.

So everything's still good.

So, let's go look at our model again.

Turning this to True,

all it really did in this case was it got rid of the table that we already had.

Mot of the time your gonna do this without having an existing table.

But it's good to know how to do it if you have a table and you're gonna go back and

refactor, and rework through how things work.

Abstract models are an amazingly handy tool when you need to be able to diversify

your models without creating a ton of tables or

requiring complex joins in the SQL that Django generates for you.

Later in this stage, we'll look at the other type of model inheritance Django

offers, but first, let's start our quizzes.