MongoDB is een populaire NoSQL-database die gegevens in collecties opslaat. MongoDB-collecties bestaan uit een of meer documenten die de feitelijke gegevens in JSON-indeling bevatten. Documenten zijn vergelijkbaar met rijen in traditionele relationele SQL-databases, terwijl verzamelingen analoog zijn aan tabellen.
Een belangrijke functionaliteit in databases is de mogelijkheid om de gegevens op te vragen die in de database zijn opgeslagen. Het opvragen van gegevens maakt het ophalen van specifieke informatie, data-analyse, datarapportage en ook data-integratie mogelijk.
Om een database effectief te kunnen bevragen, is het cruciaal om gegevens uit meerdere tabellen, in het geval van SQL-databases of meerdere collecties in NOSQL-databases, te kunnen combineren tot één resultatenset.
In MongoDB $lookup kunnen gebruikers informatie uit twee collecties combineren tijdens het uitvoeren van question’s. Het voert het equal uit van een left exterior take part een SQL-database.
Gebruik en doel van $lookup
Een belangrijke functie van databases is gegevensverwerking om betekenisvolle informatie uit ruwe gegevens te halen.
Als u bijvoorbeeld een restaurantbedrijf runt, wilt u misschien de gegevens van uw restaurant analyseren om erachter te komen hoeveel u elke dag verdient, welke voedingsmiddelen in het weekend op aanvraag zijn, of zelfs om uit te vinden hoeveel koppen koffie u verkoopt. elk uur van de dag.
Voor dergelijke behoeften zijn eenvoudige databasequery’s niet voldoende. U moet geavanceerde zoekopdrachten uitvoeren op de gegevens die u hebt opgeslagen. Om aan dergelijke behoeften te voldoen, heeft MongoDB een functie die een aggregatiepijplijn wordt genoemd.
Een aggregatiepijplijn is een systeem dat bestaat uit samenstelbare bewerkingen, fasen genoemd, die worden gebruikt om gegevens te verwerken om een uiteindelijk geaggregeerd resultaat te produceren. Voorbeelden van fasen in de aggregatiepijplijn zijn onder andere $type, $match, $group, $merge, $rely en $lookup.
Deze fasen kunnen in elke volgorde in een aggregatiepijplijn worden toegepast. In elke fase van een aggregatiepijplijn worden verschillende bewerkingen uitgevoerd op de gegevens die door de aggregatiepijplijn worden gevoerd.
$opzoeken is dus een fase in de MongoDB-aggregatiepijplijn. $Lookup wordt gebruikt om een left exterior be part of uit te voeren tussen twee collecties in een MongoDB-database. Een linkerbuitenste be part of combineert alle documenten of vermeldingen aan de linkerkant met overeenkomende documenten of vermeldingen aan de rechterkant.
Beschouw bijvoorbeeld de twee onderstaande verzamelingen, die in tabelvorm zijn weergegeven voor een beter begrip:
bestellingen_collectie:
| Order ID | Klanten ID | besteldatum | totaalbedrag |
|---|---|---|---|
| 1 | 100 | 01-05-2022 | 50,00 |
| 2 | 101 | 02-05-2022 | 75.00 uur |
| 3 | 102 | 03-05-2022 | 100,00 |
klanten_collectie:
| klant_nummer | klantnaam | klanten e mail | klant_telefoon |
|---|---|---|---|
| 100 | John Doe | [email protected] | 555-1234 |
| 102 | Jane Smith | [email protected] | 555-5678 |
Als we een left exterior be part of uitvoeren op de bovenstaande verzamelingen met behulp van de Klanten ID veld, dat verschijnt in het order_collectionmet de order_collection zijnde de linkercollectie en de klanten_collectie Omdat het de juiste collectie is, bevat het resultaat alle documenten in de Ordercollectie en documenten in de Klantencollectie die een klant_nummer dat previous bij een Klanten ID van een van de information in de Orderverzameling.
Het uiteindelijke resultaat van de left exterior join-bewerking op de bestellingen en klantencollecties ziet er als volgt uit wanneer weergegeven in tabelvorm:
Merk dat voor de klant op klant_id 101 in de Orders-collectie, die geen matching had klant_nummer waarde in de klantenverzameling, ontbrekende corresponderende waarden uit de klantentabel zijn gevuld met null.
$opzoeken voert een strikte gelijkheidsvergelijking uit tussen velden en haalt het volledige doc op dat overeenkomt, en niet alleen de velden die overeenkomen.
$lookup-syntaxis
De syntaxis voor $opzoeken is als volgt:
{
$lookup:
{
from: <assortment to affix>,
localField: <subject from the enter paperwork>,
foreignField: <subject from the paperwork of the "from" assortment>,
as: <output array subject>
}
}$opzoeken heeft vier parameters:
- van – vertegenwoordigt de collectie waaruit we documenten willen opzoeken. In ons eerdere voorbeeld gebruiken we bestellingen_collectie En klanten_collectiezouden we zetten klanten_collectie als de van de verzameling.
- lokaalVeld – dit is een veld in de werk- of primaire verzameling dat we gebruiken om te vergelijken met velden in onze van verzameling(klanten_collectie in ons geval). In het bovenstaande voorbeeld is de lokaalVeld zou zijn Klanten ID die te vinden is in de bestellingen_collectie.
- buitenlandsVeld – dit is het veld waarmee we willen vergelijken in de verzameling waarin we specificeren van. In ons voorbeeld zou dit het geval zijn klant_nummer gevonden in de klant_collectie waarin we onze waarde gebruiken van
- als – dit is een nieuwe veldnaam die we specificeren om het veld weer te geven dat in ons doc zal verschijnen, dat documenten bevat die het resultaat zijn van overeenkomsten tussen het localField en het ForeignField. Al deze overeenkomsten worden in dit veld in een array geplaatst. Als er geen overeenkomsten zijn, bevat dit veld een lege array.
Uit onze twee eerdere collecties zouden we de volgende code gebruiken om een $lookup-bewerking uit te voeren op de twee collecties met de orders_collection als onze werk- of primaire collectie.
{
$lookup: {
from: "customers_collection",
localField: "customer_id",
foreignField: "customer_num",
as: "customer_info"
}Merk op dat de als veld kan elke tekenreekswaarde zijn. Als u het echter een naam geeft die al in het werkdocument bestaat, wordt dat veld overschreven.
Gegevens uit meerdere collecties samenvoegen
MongoDB $opzoeken is een nuttige fase in een aggregatiepijplijn in MongoDB. Hoewel het geen vereiste is dat een aggregatiepijplijn in MongoDB een $opzoeken Deze fase is van cruciaal belang bij het uitvoeren van complexe question’s waarbij gegevens uit meerdere verzamelingen moeten worden samengevoegd.
De $opzoeken fase voert een left exterior be part of uit op twee collecties, wat resulteert in het maken van een nieuw veld of het overschrijven van de waarden van een bestaand veld met een array die documenten uit een andere collectie bevat.
Deze documenten worden geselecteerd op foundation van de vraag of ze waarden hebben die overeenkomen met de waarden van het veld waarmee ze worden vergeleken. Het eindresultaat is een veld met een array van documenten als er overeenkomsten zijn gevonden, of een lege array als er geen overeenkomsten zijn gevonden.
Denk hierbij aan de onderstaande medewerkers- en projectcollecties.
We kunnen de volgende code gebruiken om de twee collecties samen te voegen:
db.initiatives.combination([
{
$lookup: {
from: "employees",
localField: "employees",
foreignField: "_id",
as: "assigned_employees"
}
}
])Het resultaat van deze operatie is een combinatie van de twee collecties. Het resultaat zijn de projecten en alle medewerkers die aan elk mission zijn toegewezen. De medewerkers zijn weergegeven in een array.
Pipeline-fasen die samen met $lookup kunnen worden gebruikt
Zoals eerder gezegd, $opzoeken is een fase in een MongoDB-aggregatiepijplijn en kan samen met andere aggregatiepijplijnfasen worden gebruikt. Om te laten zien hoe deze fasen samen kunnen worden gebruikt $opzoekengebruiken we de volgende twee verzamelingen ter illustratie.
In MongoDB worden ze opgeslagen in JSON-indeling. Zo zien de bovenstaande collecties eruit in MongoDB.
Enkele voorbeelden van aggregatiepijplijnfasen die samen kunnen worden gebruikt $opzoeken erbij betrekken:
$match
$match is een aggregatiepijplijnfase die wordt gebruikt om de documentstroom te filteren, zodat alleen de documenten die aan de gegeven voorwaarde voldoen, door kunnen gaan naar de volgende fase in de aggregatiepijplijn. Deze fase kan het beste vroeg in de pijplijn worden gebruikt om documenten te verwijderen die niet nodig zijn en zo de aggregatiepijplijn te optimaliseren.
Met de twee eerdere collecties kun je combineren $match En $opzoeken zoals zo:
db.customers.combination([
{
$match: {
country: "USA"
}
},
{
$lookup: {
from: "orders",
localField: "_id",
foreignField: "user_id",
as: "orders"
}
}
])$overeenkomst wordt gebruikt om te filteren op gebruikers uit de VS. Het resultaat van $match wordt dan gecombineerd met $opzoeken om de bestelgegevens van gebruikers uit de VS te verkrijgen. Het resultaat van bovenstaande operatie ziet u hieronder:
$mission
$mission is een fase die wordt gebruikt om documenten opnieuw vorm te geven door te specificeren welke velden moeten worden opgenomen, uitgesloten of toegevoegd aan documenten. Als u bijvoorbeeld documenten verwerkt met elk tien velden, maar slechts vier velden in de documenten bevatten gegevens die u nodig heeft voor uw gegevensverwerking, kunt u gebruik maken van $mission om buiten de velden te filteren die u niet nodig heeft.
Hierdoor kunt u voorkomen dat onnodige gegevens naar de volgende fase van uw aggregatiepijplijn worden verzonden.
We kunnen $lookup en $mission als volgt combineren:
db.customers.combination([
{
$lookup: {
from: "orders",
localField: "_id",
foreignField: "user_id",
as: "orders"
}
},
{
$project: {
name: 1,
_id: 0,
total_spent: { $sum: "$orders.price" }
}
}
])Het bovenstaande combineert de gebruikers- en orderverzamelingen met behulp van $lookup, vervolgens wordt $mission gebruikt om alleen de naam van elke gebruiker en het door elke gebruiker uitgegeven bedrag weer te geven. $mission wordt ook gebruikt om het veld _id uit de resultaten te verwijderen. Het resultaat van bovenstaande operatie ziet u hieronder:
$ontspan
$ontspan is een aggregatiefase die wordt gebruikt om een arrayveld te deconstrueren of af te wikkelen en nieuwe documenten te creëren voor elk ingredient in de array. Dit is handig als u een aggregatie wilt uitvoeren op de veldwaarden van de array.
Als u in het onderstaande voorbeeld bijvoorbeeld aggregatie wilt uitvoeren op de passion’s veld, kunt u dit niet doen omdat het een array is. U kunt het echter wel gebruiken om het af te wikkelen $ontspan en voer vervolgens aggregaties uit op de resulterende documenten.
Met behulp van de gebruikers- en orderverzamelingen kunnen we $lookup en $unwind als volgt samen gebruiken:
db.customers.combination([
{
$lookup: {
from: "orders",
localField: "_id",
foreignField: "user_id",
as: "orders"
}
},
{
$unwind: "$orders"
}
])In de bovenstaande code retourneert $lookup een arrayveld met de naam orders. $unwind wordt vervolgens gebruikt om het arrayveld af te wikkelen. Het resultaat van deze operatie wordt hieronder weergegeven: Merk op dat Alice twee keer verschijnt omdat ze twee orders had.
Voorbeelden van $lookup-gebruiksscenario’s
Bij het uitvoeren van gegevensverwerking $opzoeken is een handig hulpmiddel. U kunt bijvoorbeeld twee collecties hebben waaraan u wilt deelnemen op foundation van velden in de collecties die vergelijkbare gegevens bevatten. Hiervoor kan een eenvoudige $lookup-fase worden gebruikt en een nieuw veld worden toegevoegd aan de primaire collecties, die documenten bevatten die uit een andere collectie zijn verkregen.
Houdt rekening met de onderstaande gebruikers- en orderverzamelingen:
De twee verzamelingen kunnen worden gecombineerd met behulp van $lookup om het onderstaande resultaat te geven:
$opzoeken kan ook worden gebruikt om complexere joins uit te voeren. $opzoeken is niet alleen beperkt tot het samenvoegen van twee collecties. Je kunt er meerdere implementeren $opzoeken podia om joins uit te voeren op meer dan twee collecties. Beschouw de drie onderstaande collecties:
We kunnen de onderstaande code gebruiken om een complexere samenvoeging van de drie collecties uit te voeren om alle geplaatste bestellingen te verkrijgen, evenals particulars van de bestelde producten.
Met de onderstaande code kunnen we precies dat doen:
db.orders.combination([
{
$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" }
}
}
])Het resultaat van bovenstaande operatie ziet u hieronder:
Conclusie
Bij het uitvoeren van gegevensverwerking waarbij meerdere verzamelingen betrokken zijn, kan $lookup nuttig zijn, omdat u hiermee gegevens kunt samenvoegen en conclusies kunt trekken op foundation van gegevens die in meerdere verzamelingen zijn opgeslagen. Gegevensverwerking is zelden afhankelijk van slechts één verzameling.
Om betekenisvolle conclusies uit knowledge te kunnen trekken, is het samenvoegen van knowledge uit meerdere collecties een belangrijke stap. Overweeg daarom om de $lookup-fase in uw MongoDB-aggregatiepijplijn te gebruiken, zodat u uw gegevens beter kunt verwerken en zinvolle inzichten kunt putten uit onbewerkte gegevens die in verschillende collecties zijn opgeslagen.
U kunt ook enkele MongoDB-opdrachten en -query’s verkennen.