All language subtitles for 004 Modelling Locations (Geospatial Data)_Downloadly.ir_en

Welcome back.

So after some heavier theory lectures,

now, we're finally gonna start implementing our data model

and starting with the locations.

So in this video, you're gonna learn all about

geospatial data in MongoDB.

And this is really a topic

that I personally find really exciting.

Now, remember from the previous lecture

that our location data will actually be embedded

into the tours.

And so therefore, we're basically gonna declare

everything that is related to locations

in our tour model.

All right, so let's open that one up and right at the end,

let's start by adding the startLocation.

Okay, so we will have startLocation

and then also, locations in general.

Now, MongoDB supports geospatial data out of the box.

And geospatial data is basically data that describes

places on earth using longitude and latitude coordinates.

Okay, so we can describe simple points

or we can also describe more complex geometries

like lines or even polygons or even multi-polygons.

So really, everything is possible

with geospatial data in MongoDB.

Okay, so let's add our startLocation field here

and then let's actually implement this geospatial data.

And MongoDB uses a special data format called GeoJSON.

All right, so.

GeoJSON, in order to specify geospatial data.

And now, how does this actually work?

Well, this object that we specified here

is actually, this time, not for the schema type options

as we have it, for example, up here.

So this object here is for the schema type options.

Remember that?

But now, this object here is actually really

an embedded object.

And so inside this object,

we can specify a couple of properties.

All right, and in order for this object to be recognized

as geospatial JSON, we need the type

and the coordinates properties, all right.

So we need type and we need

coordinates, all right.

And so now, each of these fields here,

so basically, each of these sub-fields is then gonna get

its own schema type options.

All right, so basically here, it's a bit nested,

so we have one level deeper.

Okay, so we have the type schema type options

and then we also need schema type options for coordinates

and again, just like we have up here in these other fields

with the difference that these are now sub-fields.

So type needs the type of string,

all right,

and the default should be point.

So remember how I said that we can specify

multiple geometries in MongoDB?

And the default one is always point.

But again, we could also specify polygons or lines

or other geometries like that.

But in this case, for the startLocation,

it really should be point.

And so let's actually make that the only possible option

by specifying the enum,

so the enumeration property.

So remember, we can specify an array

of all the possible options that this field can take

and so in this case, we only want it to be point, all right.

So we did that somewhere up here.

Yeah, right here with the difficulty

where we said it can only be either medium or difficult.

Right, and so here, we're doing the same thing,

but only with one option, okay.

So we need to define the type, remember,

and also, an array of coordinates.

Okay, and so we do that by saying number,

but then in these curly brackets.

Okay, and so that basically means that we expect

an array of numbers

and this array, as the name says, is the coordinates

of the point with the longitude first

and only second, the latitude.

And so that's a bit counterintuitive

because usually it works the other way around.

But in GeoJSON, that's just how it works.

So if you were to go, for example, to Google Maps

in order to get your coordinates,

then you will see first the latitude and then the longitude.

Let's actually take a look at that.

So

open up Maps here.

Let's say New York.

Okay, and if we now click somewhere here,

say here, then we get the coordinates

first with the latitude and second, the longitude.

All right, and in case your not familiar with that,

let's just zoom out a little bit here,

so we can see the entire earth.

Wow, what's that?

Okay.

So the latitude is basically the horizontal position

measured in degrees starting from the equator,

so from here to up here.

So in the equator, it's zero degrees

and up here, in the North Pole, it's 90 degrees.

And then the longitude

is just the same thing, but vertically.

So it's the position starting from a meridian,

which passes somewhere here, okay.

And so the longitude is the vertical position

starting from here.

And so that's why this point here that we got,

somewhere here,

somewhere here in Manhattan, has a latitude of 40

and a longitude of -73.

All right.

But anyway, let's go back to our code here, of course,

because I also want to specify a property for the address.

So add another string and then also, a description

of this startLocation

and that again, as a string, all right.

And we're not gonna say that any of these fields

should be required because we want to be allowed

to leave the startLocation blank.

Okay, so again, in order to specify geospatial data

with MongoDB, we basically need to create a new object

such as we did here.

And that object then needs to have at least two field names.

So coordinates has this array of numbers

and then the type, which should be of type string

and should be either point or some other

of these other geometries that I just told you about before.

Okay, and we can then of course add some more fields

to this object such as we did here, all right.

Now, remember how in the last lecture we said

how we were gonna embed all the locations

into the tour documents?

But right now, the startLocation here is not really

a document itself.

It's really just an object

describing a certain point on earth.

But in order to really create new documents

and then embed them into another document,

we actually need to create an array, all right.

So it's actually very similar to what we already have here,

but it needs to be an array.

And so that's what we're gonna do with our locations.

So locations, and now, I'm creating an array.

And then in this array is where I'm gonna specify

the object such as I did it before in startLocation.

Okay, and you will see what this will look like

in a second in the Compass application.

Okay, and so now, it's actually quite the same as before.

So the type, remember, for geospatial data

needs to be string.

The default needs to be point.

And also, it cannot be anything but point, okay.

So point.

Again, we need the coordinates as an array of numbers

and also, for all of these other locations,

we still want to specify an address and a description.

So string and here, I also want to specify the date,

so as a number.

And this date will basically be the day of the tour

in which people will go to this location.

Now, if we wanted to make it simpler,

we could delete the startLocation all together

and then simply define the first location

as the startLocation and set it to day number zero.

All right, but I decided it's nice to also have

the startLocation as a separate field.

Okay, so this is how you create embedded documents.

Remember we always need to use this array, okay.

And so by specifying basically an array of objects,

this will then create brand new documents

inside of the parent document,

which is, in this case, the tour.

All right, now, in order to create some locations,

I'm actually going to import all our original data.

All right, so instead of creating new tours,

I will delete the ones we have

and then import the complete data.

So here, in dev-data,

remember that before we imported tours-simple.

Okay, so this kind of data here.

But we also have tours and this then actually has

the locations and the startLocation.

So I'm not sure where that startLocation is.

Ah, here it is.

So this is how we specify the startLocation

and you see that we have type set to point.

We have our array of coordinates.

And then of course, we have description and address.

And then down here, in the location, we have an array,

which then contains one object for each location.

And you see that actually each of them gets their own id.

And so these really are documents

and not just simple objects.

All right, so let's go here to our import-dev-data

and replace this here just with tours.

Give it a save and then remember, we need first to delete

and then to import.

So going to another console here.

We now want to run node,

dev-data and then import,

so actually, in the data folder, and then import.

And start by deleting and let's wait for it and indeed,

and now, import.

And here we go.

And let's check out Compass now.

Come to our tours.

And so indeed, you now see the startLocation here

as an object.

Okay, and when you open that up,

you see all the data that I just showed you before

in the JSON file.

Right, then here, also, the locations,

which you see as an array, so type array.

And then in there, we have all of these objects

and each object then also has its object id.

Okay, and so again, this is proof that we have now created,

embedded, or de-normalized datasets,

so datasets that have a really close relationship

with the tours data.

And so that's why we chose to really make it part

of the tours instead of creating its own collection

just for locations, right.

So we will actually use this a bit later in this section

once we start to create some special geospatial queries.

Okay, and with geospatial queries,

we can do really amazing stuff

like finding locations data closest to certain points

or find all locations inside a certain radius

or a certain sphere.

And really, the possibilities are absolutely endless, okay.

So we will just see some applications of this

by the end of this section

because for now, I really just wanted to show you

how we can create embedded datasets just as we just did.