So far when we've needed to make a new instance in the database,

we've used either the admin or a model form.

Both of these are excellent ways and probably the way you'll create almost all

of your model instances when you're using Django.

But 99% probability or

not, you need to know about three other handy ORM methods for creating records.

So sometimes you just need to make a model instance really quick.

You know the data is good, you don't wanna bother with a form,

you just gotta stick a thing into the database.

Django's ORM give us a really quick way to handle that using the create model.

I've already got courses imported, I need to import the user,

so django.contrib.auth.models import user.

Okay, cool.

So I want to make a new course for myself really quick.

So I'm gonna go ahead and get my user record out, so

get username equals kennethlove, I know that's me.

All right, cool, and now I wanna make a course.

So let's do course equals Course.objects.create

teacher equals teacher, me subject equals Python.

Big surprise right there and the title's gonna be Django Basics.

All right, and so now if I look at the id of the course, it's 24.

Now, I notice I didn't have to go and make a course instance.

I didn't have a call save, I didn't have to go fetch it afterwards.

Create is a wonderful shortcut, it inserts the record into the database and

then gives you back the record.

So course is now that course that I created in the database.

So that's really cool.

This only works for creating one thing though.

If you need to make several items, you're probably like a loop, loop,loop, but no,

don't make a loop.

You can but ideally you don't.

There's actually something that's a little bit easier to do which is a bulk create.

So we can do course.objects.bulk_create.

And you always pass both create and iterable of some kind.

So in this case, we're sending in a list and

inside that iterable, you have instances of the model that are not saved.

So we'll do a course where the teacher equals to teacher,

title equals Django Forms and the subject equals Python.

And then we'll do another one where the teacher equal teacher.

And just to get a little bit [INAUDIBLE] Django ORM and subect equals Python.

All right. And then we'll close our loop and

we'll close our call to bulk create.

And cool, we got back a list,

we could've assign that to an object if we wanted to a variable, but it's cool.

So now if we do a Course.objects.filter title contains Django.

Then cool, we've got Lacey's customizing Django templates and

we then have my own Django basic's string of forms and the current Django ORM.

So that's great, it created all the courses for us at once.

If we're doing this in a view with Django debug toolbar,

we'd only see a single query being run for inserting both of those records.

We wouldn't get two queries, we'd get one which is awesome.

So yey for being efficient.

You should also be able to figure out how to do this with a loop or

a list comprehension but you don't have to of course.

Speaking with efficiency, there's no reason to add records that we

don't need to add or to throw exceptions recklessly.

So just like we have the get object or 404 to save ourselves from having to catch

a missing record and throw a 404 when it doesn't exist.

We also have the get or

create method, well, let's quickly move through possible record data.

Get or create checks to see if a record exists using

all of the attributes that we give it.

If it does exist, we get that record back.

If it doesn't exist, it will create the record and give it back to us.

It also gives us back a boolean value of whether or not the record was created.

So for instance, let's try this,

course.objects.get or create,

teacher equals teacher, title equals Django forms.

And I get a back course and I get back false because it wasn't being created,

it already existed.

Let's change this a little bit here and let's go with the Django REST Framework.

All right.

This doesn't exist but some day it will, right?

[INAUDIBLE] And we get back to the course and

we get back true because it was created, all right.

Out of all these methods, I probably use get or create more than anything else.

I imagine you will too, so enjoy it.

I found that over the years I tend to use create a lot

when I'm playing with ideas in the shell.

It's a really handy way of building stuff quickly just to make sure that a model

method works or that I can select records the way I think I can.

Bulk create comes in really handy for

a lot of start up scripts like when a project first starts.

And get or create is one that is pretty much indispensable for

a lot of applications like when you're creating tags or categories and

want to only have one record of each tag.

I'm sure you'll find all sorts of ways that these three methods save you

time and trouble.