MongoDB er en populær NoSQL-database som lagrer data i samlinger. MongoDB-samlinger består av ett eller flere dokumenter som inneholder de faktiske dataene i JSON-format. Dokumenter er sammenlignbare med rader i tradisjonelle relasjons SQL-databaser, mens samlinger er analoge med tabeller.
En nøkkelfunksjonalitet i databaser er muligheten til å spørre etter data som er lagret i databasen. Spørring av data gjør det mulig å hente spesifikk informasjon, dataanalyse, datarapportering og også dataintegrasjon.
For å kunne spørre en database effektivt, er det avgjørende å kunne kombinere data fra flere tabeller, i tilfelle av SQL-databaser eller flere samlinger i NOSQL-databaser, til et enkelt resultatsett.
I MongoDB $lookup brukere å kombinere informasjon fra to samlinger når de spør. Den utfører tilsvarende en venstre ytre sammenføyning i en SQL-database.
Innholdsfortegnelse
$lookups bruk og mål
En viktig funksjon til databaser er databehandling for å få meningsfull informasjon ut av rådata.
Hvis du for eksempel driver en restaurantbedrift, kan det være lurt å analysere restaurantens data for å finne ut hvor mye du tjener hver dag, hvilke matvarer som er på forespørsel i helgene, eller til og med finne ut hvor mange kopper kaffe du selger på hver time på dagen.
For slike behov vil enkle databasespørringer ikke være tilstrekkelig. Du må utføre avanserte spørringer på dataene du har lagret. For å møte slike behov har MongoDB en funksjon som kalles en aggregeringsrørledning.
En aggregeringsrørledning er et system som består av komponerbare operasjoner kalt stadier, som brukes til å behandle data for å produsere et endelig aggregert resultat. Eksempler på stadier i aggregeringspipelinen inkluderer blant annet $sort, $match, $group, $merge, $count og $lookup.
Disse stadiene kan brukes i hvilken som helst rekkefølge i en aggregeringsrørledning. På hvert trinn i en aggregeringsrørledning utføres forskjellige operasjoner på dataene som sendes gjennom aggregeringsrørledningen.
$lookup er dermed et stadium i MongoDBs aggregeringspipeline. $Lookup brukes til å utføre en venstre ytre sammenføyning mellom to samlinger i en MongoDB-database. En ytre venstre sammenføyning kombinerer alle dokumentene eller oppføringene til venstre med samsvarende dokumenter eller oppføringer til høyre.
Tenk for eksempel på de to samlingene nedenfor, som er representert i tabellformat for enklere forståelse:
orders_collection:
order_idcustomer_idorder_datetotal_amount11002022-05-0150.0021012022-05-0275.0031022022-05-03100.00
kunder_samling:
customer_numcustomer_namecustomer_emailcustomer_phone100John [email protected] [email protected]
Hvis vi utfører en venstre ytre sammenføyning på de ovennevnte samlingene ved å bruke kunde_id-feltet, som vises i ordresamlingen, med ordreinnsamlingen som venstre samling og kundesamlingen er den riktige samlingen, vil resultatet inneholde alle dokumentene i ordresamlingen og dokumenter på kundesamlingen som har et kundenummer som samsvarer med en kunde-id for noen av postene i ordresamlingen.
Det endelige resultatet av den venstre ytre sammenføyningen på ordrene og kundesamlingene ser slik ut når representert i tabellformat:
Legg merke til at for kunden med kunde_id 101 i ordresamlingen, som ikke hadde en tilsvarende verdi for kundenummer i kundesamlingen, er manglende tilsvarende verdier fra kundetabellen fylt med null.
$lookup utfører streng likhetssammenligning mellom felt og henter hele dokumentet som matchet, og ikke bare feltene som matchet.
$lookup Syntaks
Syntaksen for $lookup er som følger:
{
$lookup:
{
from: <collection to join>,
localField: <field from the input documents>,
foreignField: <field from the documents of the "from" collection>,
as: <output array field>
}
}
$lookup har fire parametere:
- fra – representerer samlingen vi ønsker å slå opp dokumenter fra. I vårt tidligere eksempel med ordre_innsamling og kunder_innsamling, ville vi satt kunder_innsamling som fra samlingen.
- localField – dette er et felt i den fungerende eller primære samlingen som vi bruker til å sammenligne med feltene i vår fra-samling (customers_collection i vårt tilfelle). I eksemplet ovenfor vil localField være kunde_id som finnes i ordresamlingen.
- foreignField – dette er feltet vi ønsker å sammenligne med i samlingen vi spesifiserer i fra. I vårt eksempel vil dette være kunde_nummer funnet i kunde_samlingen som vi bruker som vår verdi i fra
- as – dette er et nytt feltnavn vi spesifiserer for å representere feltet som vil vises i dokumentet vårt, som inneholder dokumenter som er et resultat av samsvar mellom det lokale feltet og det fremmede feltet. Alle disse kampene er satt i en matrise i dette feltet. Hvis det ikke er noen treff, vil dette feltet inneholde en tom matrise.
Fra våre to tidligere samlinger ville vi bruke følgende kode for å utføre en $oppslagsoperasjon på de to samlingene med orders_collection som vår arbeids- eller primærsamling.
{
$lookup: {
from: "customers_collection",
localField: "customer_id",
foreignField: "customer_num",
as: "customer_info"
}
Merk at as-feltet kan være en hvilken som helst strengverdi. Men hvis du gir det et navn som allerede finnes i arbeidsdokumentet, vil det feltet bli overskrevet.
Sammenføyning av data fra flere samlinger
MongoDB $lookup er et nyttig stadium i en aggregeringspipeline i MongoDB. Selv om det ikke er et krav at en aggregeringspipeline i MongoDB må ha et $oppslagsstadium, er stadiet avgjørende når du utfører komplekse spørringer som krever sammenføyning av data på tvers av flere samlinger.
$lookup-stadiet utfører en venstre ytre sammenføyning på to samlinger som resulterer i at et nytt felt opprettes eller at et eksisterende felts verdier overskrives med en matrise som inneholder dokumenter fra en annen samling.
Disse dokumentene velges ut fra om de har verdier som samsvarer med verdiene i feltet de sammenlignes med. Sluttresultatet er et felt som inneholder en rekke dokumenter i tilfelle treff ble funnet eller en tom array i tilfelle ingen treff ble funnet.
Vurder de ansattes og prosjektsamlingene vist nedenfor.
Vi kan bruke følgende kode for å bli med i de to samlingene:
db.projects.aggregate([
{
$lookup: {
from: "employees",
localField: "employees",
foreignField: "_id",
as: "assigned_employees"
}
}
])
Resultatet av denne operasjonen er en kombinasjon av de to samlingene. Resultatet er prosjektene og alle de ansatte som er tildelt hvert prosjekt. De ansatte er representert i en matrise.
Pipeline Stages som kan brukes sammen med $lookup
Som nevnt tidligere, er $lookup et stadium i en MongoDB aggregeringspipeline, og det kan brukes sammen med andre aggregeringspipelinetrinn. For å vise hvordan disse stadiene kan brukes sammen med $lookup, bruker vi følgende to samlinger for illustrasjonsformål.
I MongoDB er de lagret i JSON-format. Slik ser samlingene ovenfor ut i MongoDB.
Noen eksempler på aggregeringsrørledningsstadier som kan brukes sammen med $lookup inkluderer:
$match
$match er et aggregeringsrørledningsstadium som brukes til å filtrere dokumentstrømmen slik at bare de dokumentene som oppfyller den gitte betingelsen, kan gå videre til neste trinn i aggregeringsrørledningen. Dette stadiet brukes best tidlig i pipelinen for å fjerne dokumenter som ikke vil være nødvendig og dermed optimalisere aggregeringsrørledningen.
Ved å bruke de to tidligere samlingene kan du kombinere $match og $lookup slik:
db.users.aggregate([
{
$match: {
country: "USA"
}
},
{
$lookup: {
from: "orders",
localField: "_id",
foreignField: "user_id",
as: "orders"
}
}
])
$match brukes til å filtrere etter brukere fra USA. Resultatet fra $match blir deretter kombinert med $lookup for å få bestillingsdetaljene til brukere fra USA. Resultatet av operasjonen ovenfor er vist nedenfor:
$prosjekt
$project er et stadium som brukes til å omforme dokumenter ved å spesifisere hvilke felt som skal inkluderes, ekskluderes eller legges til i dokumenter. For eksempel, i tilfelle du behandler dokumenter med ti felt hver, men bare fire felt i dokumentene inneholder data du trenger for databehandlingen din, kan du bruke $project til å filtrere feltene du ikke trenger.
Dette lar deg unngå å sende unødvendige data til neste trinn av aggregeringspipeline.
Vi kan kombinere $lookup og $project slik:
db.users.aggregate([
{
$lookup: {
from: "orders",
localField: "_id",
foreignField: "user_id",
as: "orders"
}
},
{
$project: {
name: 1,
_id: 0,
total_spent: { $sum: "$orders.price" }
}
}
])
Ovennevnte kombinerer bruker- og ordresamlingene ved å bruke $lookup, deretter brukes $project til kun å vise navnet på hver bruker og beløpet brukt av hver bruker. $project brukes også til å fjerne _id-feltet fra resultatene. Resultatet av operasjonen ovenfor er vist nedenfor:
$slappe av
$unwind er et aggregeringstrinn som brukes til å dekonstruere eller avvikle et matrisefelt som lager nye dokumenter for hvert element i matrisen. Dette er nyttig i tilfelle du vil kjøre litt aggregering på matrisefeltverdiene.
For eksempel, i eksemplet nedenfor, i tilfelle du ønsker å kjøre aggregering på hobbyfeltet, kan du ikke gjøre det fordi det er en matrise. Du kan imidlertid bruke avvikle det ved å bruke $unwind og deretter utføre aggregeringer på de resulterende dokumentene.
Ved å bruke bruker- og ordresamlingene kan vi bruke $lookup og $unwind sammen slik:
db.users.aggregate([
{
$lookup: {
from: "orders",
localField: "_id",
foreignField: "user_id",
as: "orders"
}
},
{
$unwind: "$orders"
}
])
I koden ovenfor returnerer $lookup et matrisefelt kalt ordrer. $unwind brukes deretter til å avvikle matrisefeltet. Resultatet av denne operasjonen er vist nedenfor: Legg merke til at Alice dukker opp to ganger fordi hun hadde to bestillinger.
Eksempler på $lookup brukstilfeller
Når du utfører databehandling, er $lookup et nyttig verktøy. Du kan for eksempel ha to samlinger du ønsker å bli med basert på felt på samlingene som har lignende data. Et enkelt $oppslagsstadium kan brukes til å gjøre dette og legge til et nytt felt i primærsamlingene, som inneholder dokumenter hentet fra en annen samling.
Vurderer bruker- og ordresamlingene vist nedenfor:
De to samlingene kan kombineres ved å bruke $lookup for å gi resultatet vist nedenfor:
$lookup kan også brukes til å utføre mer komplekse sammenføyninger. $lookup er ikke bare begrenset til å utføre deltakelse på to samlinger. Du kan implementere flere $lookup-stadier for å utføre sammenføyninger på mer enn to samlinger. Tenk på de tre samlingene vist nedenfor:
Vi kan bruke koden nedenfor for å utføre en mer kompleks sammenføyning på tvers av de tre samlingene for å få alle bestillingene som ble gjort og også detaljer om produktene som ble bestilt.
Koden nedenfor lar oss gjøre nettopp det:
db.orders.aggregate([
{
$lookup: {
from: "order_items",
localField: "_id",
foreignField: "order_id",
as: "order_items"
}
},
{
$unwind: "$order_items"
},
{
$lookup: {
from: "products",
localField: "order_items.product_id",
foreignField: "_id",
as: "product_details"
}
},
{
$group: {
_id: "$_id",
customer: { $first: "$customer" },
total: { $sum: "$order_items.price" },
products: { $push: "$product_details" }
}
}
])
Resultatet av operasjonen ovenfor er vist nedenfor:
Konklusjon
Når du utfører databehandling som involverer flere samlinger, kan $lookup være nyttig siden det lar deg slå sammen data og trekke konklusjoner basert på data lagret i flere samlinger. Databehandling er sjelden avhengig av bare én samling.
For å trekke meningsfulle konklusjoner fra data er det å slå sammen data på tvers av flere samlinger et nøkkeltrinn. Vurder derfor å bruke $lookup-stadiet i MongoDB-aggregeringspipeline for å tillate deg å behandle dataene dine bedre og få meningsfull innsikt fra rådata som er lagret på tvers av samlinger.
Du kan også utforske noen MongoDB-kommandoer og spørringer.