Models in peewee are Python classes.

Each column in the table, each aspect that we want to remember about our thing.

Is an attribute on the Model Class.

To demonstrate this, let's make a model to represent a student here at Treehouse.

So, let's start by creating a new file that we're going to call, Students.py.

And I'm going to hold all of our information about

the different students in a dictionary.

But before I do that, I need to go ahead and make the database and

the model and all of that stuff.

You know, cart before the horse kind of thing.

So, to do most of this, I need to import the stuff that I need from peewee.

But unlike most of the platform that we've been writing,

we're going to be using a lot of different stuff in peewee.

And so, the convention for that is, to actually go ahead and

just import everything.

I don't really like doing this, it's not my favorite technique.

But this is the convention for working with peewee and

it's pretty important to stick to conventions.

Because that way your code, looks like other people's code.

Everybody can make assumptions and just work.

So we're going to import everything.

So now, let's make our database.

We're going to be using SQLite so we wanna make a SQLite connection.

Peewee will create the database for

us if it doesn't exist, at least when we're using SQLite.

So, Sqlitedatabase, and

I'm going to call it Students.db.

The .db is kind of a bit of a convention, because it says, hey, this is a database.

You don't have to, of course, if you don't want to.

And you can name the file anything you want.

If you don't want to call it students, if you want to call it people, whatever.

Go for it.

But now, we need our model.

Models in peewee are classes, but they inherit from the model class.

So let's do, class Student and it inherits from Model.

And we always name our models with a singular name.

Notice how I'm using Student and not Students.

So, why it that?

Well, it's because a model represents a single

item in the database, theoretically.

It wouldn't make sense then, to give them a plural name.

You'll see this convention used all over the place with peewee.

And you'll also see this used everywhere in Django.

Now, our model needs some attributes.

These attributes will become the fields or columns in the database table.

Let's just hold onto two things.

We're going to hold onto the student's username.

CharField.

And let's hold onto their points.

So, what's up with these?

Well, a CharField is a field that holds characters.

Somebody will say, CareField but I always find that really hard to say.

In sequel terminology, this is a VarChar field.

Because it has a variable length, VarChar variable character.

We have to tell it the maximum number of characters that we want to store.

So we're gonna set this to 255.

That should hold pretty much any username that we're going to ever come across.

The unique attribute,

the second argument there, says that we want the usernames to be unique.

We don't wanna have multiple records for the same student.

Our points attribute which is an integer field.

You probably guessed, integer fields hold integers.

And what we've said with this default keyword argument here,

is that if we don't supply a points.

Then it should just default it to zero.

Now, we didn't set a default on the user name field.

So, if we don't provide a user name we're going to get an error.

The last thing that we have to do is,

we have to tell the model what database it belongs to.

And we do that, by defining a class inside of our class that's called Meta.

Yeah, you can have classes inside of classes.

Now, metaclasses are something you're going to hear about

a lot of different places.

And they're a huge part of programming, but this isn't a metaclass.

This is just a class that's called meta.

It's describing the class that it belongs to.

The name has some meaning, but

it doesn't necessarily mean the thing that the name reflects on.

I know that's a little weird, but again,

this is a convention you're going to see in peewee and in Django.

So, we can use the metaclass to define all sorts of things.

Like which fields should be indexed,

how things should be ordered by default, all that stuff.

But for right now,

we're just going to stick to one attribute which is the database attribute.

And we're going to set database as being equal to DB.

which is our SQLite database we created up on line three.

Okay so, we have a database and we have a model that's been described.

We should use them.

So, let's add some code in here.

That if our file is run directly and not imported.

That it will go ahead and connect to our database.

And it will create tables and the tables we want it to create is, or are student.

We only have one table.

But something we want to do is, going to be sure and say safe equals true.

The reason we have to pass in the safe equals true keyword argument.

Is so, that if we run this multiple times toward the database that's

already been created.

And the table has already been created, peewee won't freak out and break.

It'll just go, okay, cool, everything's there.

Let's move on.

Okay, let's try and run this.

We come down here, python students.py.

And then I should be able to run this a second time with no problems.

Yay!

All right, so let's do an ls, and there's our students.db.

We're not going to talk about everything in SQL lite.

But let's use SQL lite real quick, to look inside there and see what's going on.

So, we can do SQL lite 3, students.db.

That'll connect to our database.

We can do .tables and that will show us all of our tables.

So, we have a student table.

And we can do say ,select * from student.

And we get back nothing, because we haven't put anything in there.

And then we can do .exit, and that'll go ahead and leave SQL lite.

Great, we're now ready to go build something.

Connecting to a database and creating a model are both pretty simple.

Most of that is thanks to peewee's API.

Now that we have a table, let's insert some data into it and

see about getting that data back out.