A MongoDB egy népszerű NoSQL adatbázis, amely gyűjteményekben tárolja az adatokat. A MongoDB gyűjtemények egy vagy több dokumentumból állnak, amelyek a tényleges adatokat JSON formátumban tartalmazzák. A dokumentumok összehasonlíthatók a hagyományos relációs SQL-adatbázisok soraival, míg a gyűjtemények a táblázatokkal.
Az adatbázisok egyik kulcsfontosságú funkciója az adatbázisban tárolt adatok lekérdezésének képessége. Az adatok lekérdezése lehetővé teszi konkrét információk lekérését, adatelemzést, adatjelentést, valamint adatintegrációt.
Ahhoz, hogy egy adatbázist hatékonyan lehessen lekérdezni, kulcsfontosságú, hogy több tábla adatait SQL adatbázisok vagy NOSQL-adatbázisok több gyűjteménye esetén egyetlen eredményhalmazba tudjuk kombinálni.
A MongoDB $lookupban a felhasználók két gyűjteményből származó információkat kombinálhatnak lekérdezéskor. Az SQL-adatbázis bal oldali külső összekapcsolásának megfelelőjét hajtja végre.
Tartalomjegyzék
A $lookup használata és célja
Az adatbázisok fontos funkciója az adatfeldolgozás, hogy a nyers adatokból értelmes információkat nyerjünk ki.
Például, ha éttermi vállalkozást működtet, érdemes elemeznie az étterme adatait, hogy megtudja, mennyit keres naponta, mely ételekre van igény a hétvégén, vagy akár hány csésze kávét ad el. a nap minden órájában.
Ilyen igényekre az egyszerű adatbázis-lekérdezések nem elegendőek. Speciális lekérdezéseket kell végrehajtania a tárolt adatokon. Az ilyen igények kielégítésére a MongoDB rendelkezik egy aggregációs folyamatnak nevezett szolgáltatással.
Az aggregációs folyamat egy olyan rendszer, amely szakaszoknak nevezett összeállítható műveletekből áll, amelyek az adatok feldolgozására szolgálnak a végső összesített eredmény előállításához. Az összesítési folyamat szakaszaira példák többek között a $sort, a $match, a $group, a $merge, a $count és a $lookup.
Ezek a szakaszok tetszőleges sorrendben alkalmazhatók az összesítési folyamatban. Az összesítési folyamat minden egyes szakaszában különböző műveleteket hajtanak végre az összesítési folyamaton keresztül továbbított adatokon.
A $lookup tehát a MongoDB aggregációs folyamat egy szakasza. A $Lookup a MongoDB adatbázis két gyűjtemény közötti bal külső összekapcsolására szolgál. A bal oldali külső illesztés egyesíti az összes bal oldali dokumentumot vagy bejegyzést a megfelelő dokumentumokkal vagy bejegyzésekkel a jobb oldalon.
Vegyük például az alábbi két gyűjteményt, amelyeket táblázatos formában ábrázoltunk a könnyebb érthetőség érdekében:
orders_collection:
order_idcustomer_idorder_datetotal_amount11002022-05-0150.0021012022-05-0275.0031022022-05-03100.00
customers_collection:
customer_numcustomer_namecustomer_emailcustomer_phone100John [email protected] [email protected]
Ha a fenti gyűjteményekben bal oldali külső összeillesztést végzünk a rendelés_gyűjteményben megjelenő vevő_azonosító mezővel, ahol az order_collection a bal oldali gyűjtemény, a vevők_gyűjtemény pedig a jobb gyűjtemény, az eredmény a Megrendelésgyűjteményben lévő összes dokumentumot és dokumentumokat tartalmazza. azon Ügyfélgyűjteményben, amelynek ügyfélszáma megegyezik a Rendelésgyűjtemény bármely rekordjának ügyfélazonosítójával.
A bal oldali külső összekapcsolási művelet végeredménye a rendeléseken és az ügyfelek gyűjteményén így néz ki táblázatos formában:
Figyelje meg, hogy a 101-es vevőazonosítójú ügyfélnél a rendelésgyűjteményben, amely nem tartalmazott egyező vevőszám értéket a Vevők gyűjteményében, a vevőtáblából hiányzó megfelelő értékek nullával lettek kitöltve.
A $lookup szigorú egyenlőségi összehasonlítást végez a mezők között, és lekéri a teljes dokumentumot, amely megfelelt, nem csak az egyező mezőket.
$lookup Szintaxis
A $lookup szintaxisa a következő:
{
$lookup:
{
from: <collection to join>,
localField: <field from the input documents>,
foreignField: <field from the documents of the "from" collection>,
as: <output array field>
}
}
A $lookup négy paraméterrel rendelkezik:
- from – azt a gyűjteményt jelöli, amelyből dokumentumokat szeretnénk keresni. Korábbi példánkban a orders_collection és a customers_collection használatával a customers_collection értéket helyeztük el a gyűjteményből.
- localField – ez egy mező a működő vagy elsődleges gyűjteményben, amelyet a gyűjteményünk mezőivel való összehasonlításhoz használunk (esetünkben ügyfelek_gyűjtemény). A fenti példában a localField az ügyfél_azonosítója lenne, amely az orders_collection-ben található.
- ForeignField – ezzel a mezővel szeretnénk összehasonlítani abban a gyűjteményben, amelyből megadjuk. Példánkban ez az ügyfél_szám a customer_collectionben található, amelyet értékként használunk
- as – ez egy új mezőnév, amelyet a localField és a ForeignField közötti egyezésekből származó dokumentumokat tartalmazó dokumentumunkban megjelenő mező képviselésére adunk meg. Mindezek az egyezések egy tömbbe kerülnek ebben a mezőben. Ha nincs egyezés, ez a mező egy üres tömböt fog tartalmazni.
Két korábbi gyűjteményünkből a következő kódot használjuk egy $lookup művelet végrehajtására a két gyűjteményben, amelyekben az orders_collection a működő vagy elsődleges gyűjteményünk.
{
$lookup: {
from: "customers_collection",
localField: "customer_id",
foreignField: "customer_num",
as: "customer_info"
}
Vegye figyelembe, hogy az as mező bármilyen karakterlánc értéke lehet. Ha azonban olyan nevet ad neki, amely már létezik a munkadokumentumban, akkor ez a mező felül lesz írva.
Több gyűjteményből származó adatok összekapcsolása
A MongoDB $ lookup egy hasznos szakasz a MongoDB összesítési folyamatában. Bár nem követelmény, hogy a MongoDB aggregációs folyamatának $lookup szakasza legyen, ez a szakasz kulcsfontosságú összetett lekérdezések végrehajtásakor, amelyek több gyűjtemény adatainak összekapcsolását igénylik.
A $lookup szakasz bal oldali külső összekapcsolást hajt végre két gyűjteményen, amelynek eredményeként új mező jön létre, vagy egy meglévő mező értékeit felülírják egy másik gyűjtemény dokumentumait tartalmazó tömbbel.
Ezeket a dokumentumokat a rendszer az alapján választja ki, hogy vannak-e olyan értékeik, amelyek megegyeznek az összehasonlítandó mező értékeivel. A végeredmény egy olyan mező, amely dokumentumok tömbjét tartalmazza, ha egyezés található, vagy üres tömböt, ha nem található egyezés.
Vegye figyelembe az alkalmazottak és a projektek alább látható gyűjteményeit.
A következő kóddal egyesíthetjük a két gyűjteményt:
db.projects.aggregate([
{
$lookup: {
from: "employees",
localField: "employees",
foreignField: "_id",
as: "assigned_employees"
}
}
])
Ennek a műveletnek az eredménye a két gyűjtemény kombinációja. Az eredmény a projektek és az egyes projektekhez rendelt összes alkalmazott. Az alkalmazottak egy tömbben jelennek meg.
A $lookup szolgáltatással együtt használható csővezeték szakaszok
Mint korábban említettük, a $lookup egy MongoDB aggregációs folyamatszakasz, és más összesítési folyamatszakaszokkal együtt használható. Annak bemutatására, hogyan használhatók ezek a szakaszok a $lookup-pal együtt, a következő két gyűjteményt használjuk szemléltetés céljából.
A MongoDB-ben JSON formátumban vannak tárolva. Így néznek ki a fenti gyűjtemények a MongoDB-ben.
Néhány példa a $lookup szolgáltatással együtt használható összesítési folyamatszakaszokra:
$match
A $match egy összesítési folyamatszakasz, amely a dokumentumfolyam szűrésére szolgál, hogy csak az adott feltételnek megfelelő dokumentumok juthassanak tovább az összesítési folyamat következő szakaszába. Ezt a szakaszt a legjobb a folyamat korai szakaszában használni a szükségtelen dokumentumok eltávolítására, így optimalizálva az összesítési folyamatot.
A két korábbi gyűjtemény használatával kombinálhatja a $match és a $lookup, így:
db.users.aggregate([
{
$match: {
country: "USA"
}
},
{
$lookup: {
from: "orders",
localField: "_id",
foreignField: "user_id",
as: "orders"
}
}
])
A $match az USA-beli felhasználók szűrésére szolgál. A $match eredményét ezután kombinálja a $lookup-pal, hogy megkapja az USA-beli felhasználók rendelési adatait. A fenti művelet eredménye az alábbiakban látható:
$projekt
A $projekt egy szakasz, amely a dokumentumok átalakítására szolgál azáltal, hogy meghatározza, mely mezőket kell belefoglalni, kizárni vagy hozzáadni a dokumentumokhoz. Például abban az esetben, ha egyenként tíz mezőt tartalmazó dokumentumokat dolgoz fel, de a dokumentumokban csak négy mező tartalmazza az adatfeldolgozáshoz szükséges adatokat, a $project segítségével kiszűrheti azokat a mezőket, amelyekre nincs szüksége.
Ez lehetővé teszi, hogy elkerülje a szükségtelen adatok elküldését az összesítési folyamat következő szakaszába.
Kombinálhatjuk a $lookup-ot és a $projektet így:
db.users.aggregate([
{
$lookup: {
from: "orders",
localField: "_id",
foreignField: "user_id",
as: "orders"
}
},
{
$project: {
name: 1,
_id: 0,
total_spent: { $sum: "$orders.price" }
}
}
])
A fenti a $lookup segítségével egyesíti a felhasználókat és a rendelési gyűjteményeket, majd a $projekt csak az egyes felhasználók nevét és az egyes felhasználók által elköltött összeget jeleníti meg. A $projekt az _id mező eltávolítására is szolgál az eredmények közül. A fenti művelet eredménye az alábbiakban látható:
$nyugodj le
A $unwind egy aggregációs szakasz, amellyel egy tömbmezőt dekonstruálnak vagy feltekernek, új dokumentumokat hozva létre a tömb minden eleméhez. Ez akkor hasznos, ha valamilyen összesítést szeretne futtatni a tömbmezőértékeken.
Például az alábbi példában, ha összesítést szeretne futtatni a hobbi mezőben, ezt nem teheti meg, mert az egy tömb. Azonban használhatja a letekerést a $ unwind segítségével, majd összesítést hajthat végre a kapott dokumentumokon.
A felhasználók és rendelések gyűjteményét használva a $lookup és a $unwind együtt használhatók, így:
db.users.aggregate([
{
$lookup: {
from: "orders",
localField: "_id",
foreignField: "user_id",
as: "orders"
}
},
{
$unwind: "$orders"
}
])
A fenti kódban a $lookup egy orders nevű tömbmezőt ad vissza. A $unwind ezután a tömbmező letekerésére szolgál. A művelet eredménye az alábbiakban látható: Figyeld Alice kétszer jelenik meg, mert két parancsa volt.
Példák a $lookup használati esetekre
Adatfeldolgozás során a $lookup hasznos eszköz. Például előfordulhat, hogy két gyűjteményt szeretne összekapcsolni a gyűjtemények hasonló adatokkal rendelkező mezői alapján. Ehhez egy egyszerű $lookup szakasz használható, és hozzáadhat egy új mezőt az elsődleges gyűjteményekhez, amelyek egy másik gyűjteményből származó dokumentumokat tartalmaznak.
Figyelembe veszi az alább látható felhasználókat és rendelési gyűjteményeket:
A két gyűjtemény a $lookup segítségével kombinálható az alábbi eredmény eléréséhez:
A $lookup összetettebb összekapcsolások végrehajtására is használható. A $lookup nemcsak két gyűjtemény összekapcsolására korlátozódik. Több $lookup szakaszt is megvalósíthat kétnél több gyűjtemény összekapcsolásához. Tekintsük az alábbi három gyűjteményt:
Az alábbi kód segítségével összetettebb összekapcsolást hajthatunk végre a három kollekció között, hogy megkapjuk az összes megrendelést és a megrendelt termékek részleteit is.
Az alábbi kód pontosan ezt teszi lehetővé:
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" }
}
}
])
A fenti művelet eredménye az alábbiakban látható:
Következtetés
Ha több gyűjteményt is magában foglaló adatfeldolgozást végez, a $lookup hasznos lehet, mivel lehetővé teszi az adatok összekapcsolását és következtetések levonását a több gyűjteményben tárolt adatok alapján. Az adatfeldolgozás ritkán támaszkodik csak egy gyűjteményre.
Ahhoz, hogy az adatokból értelmes következtetéseket lehessen levonni, kulcsfontosságú lépés az adatok több gyűjteményben történő összekapcsolása. Ezért fontolja meg a $lookup szakasz használatát a MongoDB aggregációs folyamatban, hogy lehetővé tegye az adatok jobb feldolgozását, és értelmes betekintést nyerjen a gyűjtemények között tárolt nyers adatokból.
Felfedezhet néhány MongoDB parancsot és lekérdezést is.