[MUSIC]

[SOUND] We've solved the first problem.

Let's move on to the second one.

We need to implement a way for our users to save their pizzas.

To do this,

we'll be using the Room library to store pizza information in a SQLite database.

Room makes maintaining a database a lot easier than it used to be.

Instead of having to write all the SQL yourself, Room gives us a set of

components that handle a lot of that work behind the scenes.

Let's take a minute to look at these components and

see how it all fits together.

The first component of a RoomDatabase is an entity, which represents a table and

the database.

Stepping up from an entity, we have data access objects, also referred to as DAOs.

A data access object is where we'll keep all the queries we need for

a specific table.

At the very top is the RoomDatabase, which groups together all of the DOAs and

entities and provides a single point of entry from within the app.

We'll talk more about each of those in just a bit.

But before we can start on anything,

we'll need to decide on the structure of our database.

What tables does it have?

What columns are in those tables?

And what relationships do we need to maintain between columns?

For us, we'll have a Pizza table and a Toppings table.

Both with id primary keys.

But while this lets us store some information,

it's not giving us the whole story.

We're missing out on which toppings belong on which pizza.

To get this information, we'll need to add a third table

to keep track of all the pizza and topping combinations.

This PizzaTopping table will have two columns which are both

foreign keys to other tables.

And together, those two columns also make up the primary key.

If you'd like to read more about why we need the PizzaTopping table,

check out the article below on how to handle a many-many relationship.

Okay, now that we've got a better idea of what we have to do,

let's start building up from the bottom and get to work on those entities.

Heading back to Android Studio,

I'll clean up my workspace a little bit by closing all of these tabs.

Then the first thing we need to do is add a couple import statements for

the Room library.

Let's head over to our apps build.gradle file and copy and

paste in these two lines to the bottom of the dependencies section.

Also, they've been updating these libraries somewhat frequently.

So if you see a newer version warning,

feel free to use Alt+Enter to upgrade to the newest version.

Then let's sync the project, And now we can go about using our entities.

Let's head over to the Pizza class and add a line above the class declaration.

And then type @Entity and hit Enter to import it.

And there we go, our Pizza class is now a Pizza entity.

However, all entities require a primary key.

So we're not quite done yet.

To tell Room which column is the primary key,

we just need to add the @PrimaryKey annotation before that column.

Let's add a line above id and then type, @PrimaryKey.

You may need to use Alt+Enter to import it.

Awesome, that's it for our Pizza entity.

Now let's update the Topping class.

Let's add the @ entity annotation, and then the @ primary key annotation.

You could also put it on the same line as the id if you prefer.

Now that we've got Pizza and Topping entities,

it's time to create the PizzaTopping entity, which we'll do in the next video.