Sådan implementeres MongoDB geospatiale funktioner

Sadan Implementeres Mongodb Geospatiale Funktioner



Den geospatiale funktion i MongoDB giver en ligetil måde at gemme de geografiske data i en database. I det væsentlige kan vi gemme de geospatiale data i MongoDB som GeoJSON-objekter. GeoJSON er et gratis og open source-format, der afhænger af JavaScript Object Notation med enkle geografiske data. Denne funktionalitet er vigtig for apps, der kræver tjenester baseret på placering, såsom kortlægningsprocessen, baseret på placeringssøgning og andre. Denne artikel dækker den geospatiale funktion med eksempelimplementeringen.

Tilføjelse af dokumenter til samlingen for geospatiale funktioner

For at demonstrere funktionaliteten af ​​MongoDB Geospatial-funktionen har vi brug for dokumenterne til den specifikke samling. Vi indsætter nogle få dokumenter i 'område'-samlingen som vist i følgende:

db.area.insertMany( [
{
navn: 'Børneparken' ,
placering: { type: 'Punkt' , koordinater: [ - 60,97 , 30,77 ] },
kategori: 'Have'
},
{
navn: 'Studentområde' ,
placering: { type: 'Punkt' , koordinater: [ - 60,9928 , 30,7193 ] },
kategori: 'Have'
},
{
navn: 'Fodboldbane' ,
placering: { type: 'Punkt' , koordinater: [ - 60,9375 , 30,8303 ] },
kategori: 'Stadion'
}
])

Vi har dokumenter, der indeholder lokalitetsdata såsom koordinater. Derudover opretter vi et geospatialt indeks på marken for at optimere ydeevnen af ​​geospatiale forespørgsler.









Eksempel 1: Brug af $geoIntersects Query Operator

For det første har vi den geospatiale funktions $geoIntersects-operator, som skærer det angivne objekt. Overvej følgende implementering af $geoIntersects-operatoren:



db.area.find({ placering: { $geoIntersects: { $geometry: { type: 'Punkt' ,

koordinater: [ - 60,97 , 30,77 ] } } } })

I eksemplet kalder vi 'område'-samlingen sammen med 'find'-operationen. Til find()-metoden videregiver vi 'location'-feltsættene til $geoIntersects-forespørgselsoperatoren for den geospatiale funktion. Dette bruges til at kontrollere, om det angivne punkt skærer den geometri, der er gemt i geometrifeltet.





Derefter tager $geoIntesects-operatoren $geometry-operatoren, hvor typefeltet er sat med 'Point'-værdien, og koordinatfeltet er givet med 'koordinater'-værdierne. Her er $geometrien defineret for den geospatiale sammenligning.

Følgende output er, hvor det forventede dokument hentes, og hvor geometrifeltet indeholder et geometrisk objekt, der skærer det angivne punkt:



Eksempel 2: Brug af $near Query Operator

$near-operatoren er også den geospatiale funktion, der bruges til at udføre de geospatiale forespørgsler for at identificere de dokumenter, der er geografisk tæt på et givet sted. Den henter de dokumenter, der er arrangeret efter deres nærhed til den angivne placering. Her giver vi implementeringen af ​​$near-operatøren:

db.area.find(
{
Beliggenhed:
{ $nær:
{
$geometry: { type: 'Punkt' ,  koordinater: [ - 60,9667 , 30,78 ] },
$minDistance: 1000 ,
$maxDistance: 5000
}
}
}
)

I eksemplet definerer vi 'placering'-feltet for 'område'-samlingen inde i 'find'-operationen. Derefter indstiller vi $near-forespørgselsoperatøren for den geospatiale funktion til det 'placering'-felt. $nær-operatoren søger efter nærpunktet med det givne koordinatpunkt. Dernæst bruger vi $minDistance- og $maxDistance-parametrene i $near-operatoren, som er forsynet med bestemte værdier til at hente dokumenterne inden for det angivne afstandsområde fra det givne punkt.

Dokumentet hentes i outputtet, der er i nærheden af ​​de angivne steder eller interessepunkter i en geospatial 'område'-samling:

Eksempel 3: Brug af $nearsphere Query Operator

Alternativt har vi $nearsphere-operatoren, som ligner $near-operatoren, men $nearSphere tager højde for Jordens sfæriske form, når afstandene beregnes.

db.area.find(
{
Beliggenhed: {
$nearSphere: {
$geometri: {
type: 'Punkt' ,
koordinater: [- 60,9667 , 30,78 ]
},
$minDistance: 1000 ,
$maxDistance: 5000
}
}
}
)

I eksemplet bruger vi $nearsphere-operatoren for den geospatiale forespørgsel. $nearspehere-operatoren her søger efter det dokument, hvis nærmeste punkter er tæt på de punkter, der er angivet i forespørgslen, og punkterne sættes til koordinatfeltarrayet.

Derefter forfiner vi resultaterne ved at etablere parametrene $minDistance og $maxDistance. Parameteren $minDistance sikrer, at de returnerede dokumenter er mindst 1000 meter væk fra det angivne punkt, mens parameteren $maxDistance begrænser resultaterne til de steder, der ikke er mere end 5000 meter væk.

Dokumentet vises i outputtet med en placering inden for en specificeret meter fra punktet med givne koordinater:

Eksempel 4: Brug af $geoWithin Query Operator

Dernæst har vi $geoWithin-operatoren i MongoDB, som bruges til geospatiale forespørgsler for at finde de dokumenter, der er helt inden for en specificeret form, såsom en cirkel. Lad os få følgende demonstration af $geoWithin-forespørgslen:

db.area.find({ placering:

{ $geoWithin:

{ $centerSphere: [ [ - 60.93414657 , 30.82302903 ], 3 / 3963,2 ] } } })

I eksemplet bruger vi $geoWithin-operatoren til at finde dokumenterne i 'område'-samlingen inden for et bestemt cirkulært område på en 2D-kugle. Til dette specificerer vi $centerSphere-operatoren inde i $geoWithin-operatoren, som tager de to argumenter som det centriske punkt, som sandsynligvis repræsenterer koordinatpunktet her, og cirklens radius, som repræsenterer afstandsværdien i miles.

Det resulterende dokument hentes i det følgende, som repræsenterer et geospatialt punkt, der falder inden for cirklen, der er defineret af det givne midtpunkt og radius på cirka 3 miles:

Eksempel 5: Brug af $geoNear Query Operator

Desuden er $geoNear-operatøren også en geospatial operatør, som bruges til aggregeringspipelinen. Den udfører en geospatial forespørgsel og returnerer de dokumenter, der er sorteret efter deres nærhed til et bestemt punkt. Her har vi givet $geoNear-operatøren, som kaldes inde i aggregeringspipelinen.

db.area.aggregate([
{
$geoNear: {
nær: { type: 'Punkt' , koordinater: [ - 60,99279 , 30.719296 ] },
afstandsfelt: 'afstandsberegnet' ,
maxDistance: 2 ,
forespørgsel: { kategori: 'Have' },
inkludererLocs: 'dist.location' ,
sfærisk: sandt
}
}
])

I eksemplet kalder vi den samlede metode for MongoDB og definerer $geoNear-operatoren inde i den. $geoNear-operatoren er indstillet med flere parametre til at specificere forespørgselsadfærden. Først indstiller vi 'nær'-parameteren, som giver 'koordinatværdierne' som referencepunkt for søgning.

Derefter bruger vi parameteren 'distanceField' til at angive det angivne felt som resultatfelt. Dette sæt udfaldsfelt gemmer afstanden mellem hvert dokument og referencepunktet. Dernæst definerer vi parameteren 'maxDistance' med værdien '2', som repræsenterer den maksimale afstand i meter.

Derefter har vi 'query'-parameteren, som filtrerer dokumenterne efter 'category'-feltet og kun tager hensyn til de dokumenter, hvor 'category' er 'Parks'. Vi kalder derefter parameteren 'includeLocs' for at indeholde placeringsoplysningerne. Til sidst specificerer vi den 'sfæriske' parameter med den 'sande' værdi, som beregner afstandene ved hjælp af et 2D sfærisk koordinatsystem.

Aggregeringspipelinen repræsenterer dokumentet i outputtet, som viser informationen mod parameteren i overensstemmelse hermed. Følgende 'dist.calculated'-felt viser afstanden mellem hvert dokument fra referencepunktet:

Konklusion

Vi fandt ud af, at de geospatiale muligheder i MongoDB hjælper os til effektivt at håndtere og forespørge på den stedbaserede information. Vi lærte implementeringen af ​​den geospatiale funktion ved at bruge dens forskellige operatører med eksempelprogrammet. Vi har mange flere funktioner og metoder, som også er gavnlige til en lang række applikationer.