Now that we've created our dows and

our entities it's time to create a room database to help organize all of it.

As per usual this will involve using annotations.

And it'll even involve using an abstract class.

But don't worry,

you don't need to understand how it works under the hood to be able to use it.

The first thing we'll need to do is create an abstract class

that extends from room database.

Inside the data package, let's create a new class, And name it pizza database.

Then let's make this an abstract class by adding abstract to the front and

make it extend from room database.

And use Alt+Enter to add the call to the constructor.

Next, above the class, we need to add the @Database annotation.

Inside this annotation is where it'll specify which

entities are in our database, as well as the version number.

We'll start the version number at 1, and

increase it every time we change something structural about our database.

Like adding a new table or renaming a column.

Inside the parenthesis,

let's set the entities parameter equal to an array containing our entity classes.

We've got Pizza::class,

PizzaTopping class and

Topping::class.

Then let's add a comma, and set version equal to 1.

Awesome, now that we've connected the entities to our database,

it's time to give access to our DAOs.

For each DAO,

we'll need to add an abstract function that returns an instance of that DAO.

Let's start by creating an abstract function PizzaDao and

make it return a PizzaDao.

>> Then let's make another abstract function called PizzaToppingDao.

>> And make it return a PizzaToppingDao.

>> And finishing up, let's create an abstract function

called toppingDao which returns toppingDao.

All right, that does it for our room database.

Let's see how to use it.

Let's open up main activity.

And right below the call to set content view, let's create a new val named db and

set it equal to room inner to import it database builder.

And then we need to pass in a context,

the Java class of our room database and what we would like to call the database.

So let's pass in this for the context.

PizzaDatabase::class.java for the class.

And let's call it PizzaDatabase.

And then give us a little more room as well.

And now we've got our database builder object.

From here we can set some properties of our database or

use the build a function to return an instance of our specific database.

Which in our case, is a pizza database.

Let's add a call to .build which we can see returns a pizza database.

And on the next line, if we type db., we've got access to each

of our DAOs and can call in to any of our queries.

Okay, it's time to start implementing this in the app and

finally make the UI do something, right?

Not quite, we've done a lot of work here.

But to make sure we've done it correctly, we'll need to test it.

Sure, we could just test it in the app, but then we'd have to go through and

test everything manually.

And that might be hard to tell the difference between a bug in the database

and a bug in the UI.

Instead, let's write some tests to make sure everything's working

before we start putting it in the app.