Hoe MongoDB-query's te gebruiken

Met MongoDB-query’s kunt u uw database snel en effectief door­zoe­ken en ana­ly­se­ren. De structuur van de methode is logisch en u kunt er talrijke pa­ra­me­ters mee gebruiken.

Hoe col­lec­ties effectief door­zoe­ken

Als do­cu­ment­ge­ba­seer­de NoSQL-oplossing biedt MongoDB ge­brui­kers de mo­ge­lijk­heid om grote en diverse hoe­veel­he­den gegevens eenvoudig op te slaan en te beheren. Het da­ta­ba­se­be­heer­sys­teem is zeer flexibel en kan eenvoudig ho­ri­zon­taal worden geschaald.

In te­gen­stel­ling tot re­la­ti­o­ne­le databases worden gegevens in Mongo DB op­ge­sla­gen in BSON-do­cu­men­ten (binaire JSON) en gebundeld in col­lec­ties. Om deze aanpak echt te laten werken, is het be­lang­rijk omover krachtige zoek­me­cha­nis­men te be­schik­ken die de database kunnen door­zoe­ken en de in­for­ma­tie kunnen pre­sen­te­ren die ge­brui­kers nodig hebben. Met MongoDB-zoek­op­drach­ten kan de database zelfs complex ge­struc­tu­reer­de col­lec­ties door­zoe­ken om de in­for­ma­tie te leveren die u zoekt.

Wat zijn MongoDB-query’s?

MongoDB-query’s zijn een ge­bruiks­vrien­de­lij­ke tool voor het door­zoe­ken van complexe da­ta­struc­tu­ren. Ze volgen logische regels en werken net als de fil­ter­op­ties die u op de meeste websites aantreft. Hierdoor kunt u uw zoek­op­dracht zo nauw­keu­rig mogelijk for­mu­le­ren, zodat u de best mogelijke re­sul­ta­ten krijgt. Dit is vooral be­lang­rijk omdat MongoDB veel ver­schil­len­de soorten gegevens kan opslaan. Zonder de nodige fil­ter­op­ties zou het moeilijk zijn om de database te beheren. In de volgende pa­ra­gra­fen leggen we uit wat u nodig hebt om MongoDB-query’s te maken en hoe u deze kunt gebruiken.

Wat zijn de vereisten voor MongoDB-query’s?

Er zijn slechts enkele vereisten voor het gebruik van MongoDB-query’s.

1. Je moet MongoDB op je computer hebben ge­ïn­stal­leerd. De database werkt op veel be­stu­rings­sys­te­men, dus de on­der­staan­de in­struc­ties werken zowel op Linux, OS X als Windows. De stappen die na de in­stal­la­tie volgen, zijn op alle systemen hetzelfde en hebben alleen be­trek­king op de database zelf. In onze MongoDB-tutorial kun je lezen hoe de in­stal­la­tie werkt.
2. U hebt be­heer­ders­rech­ten nodig om de zoek­func­tie te kunnen gebruiken.
3. Het is het beste om een testom­ge­ving te creëren, zodat u Mongo DB-query’s zonder risico kunt uit­pro­be­ren.

Hoe een test­col­lec­tie struc­tu­re­ren

Open eerst de shell en log in als beheerder. Maak ver­vol­gens een nieuwe collectie aan die zal dienen als testom­ge­ving voor uw eerste MongoDB-query’s. Naast het door­zoe­ken van een­vou­di­ge do­cu­men­ten, kan de methode ook arrays, ver­schil­len­de velden en ingebedde do­cu­men­ten door­zoe­ken. Daarom hebben we besloten om een iets com­plexe­re collectie aan te maken. Op deze manier krijgt u een beter beeld van de reik­wijd­te van MongoDB-query’s.

Ons voorbeeld bestaat uit een lijst met klanten. Het formaat van deze lijst is als volgt:

{
    "name" : "Schulz",
    "units" : 642,
    "location" : [ "Germany", "Austria" ],
    "transactions" : {
        "first" : {
            "year" : 2017,
        },
        "last" : {
            "year" : 2023,
        },
        "total" : 14
    }
}

Dit document bevat de volgende in­for­ma­tie:

• naam: De naam van het bedrijf dat de goederen heeft gekocht.
• eenheden: Het totale aantal producten dat door het bedrijf is besteld.
• locatie: De locatie van het bedrijf. Als er meerdere ves­ti­gin­gen zijn, kunnen deze worden op­ge­sla­gen in de vorm van een array.
• trans­ac­ties: Dit veld bevat een extra document. Dit soort do­cu­men­ten worden ‘in­ge­slo­ten do­cu­men­ten’ of ‘geneste do­cu­men­ten’ genoemd. Elk trans­ac­tie­do­cu­ment bevat in­for­ma­tie over hoe lang het bedrijf al klant is (onder het item ‘eerste’), wanneer de laatste be­stel­ling is geplaatst (onder het item ‘laatste’) en het totale aantal keren dat het bedrijf producten heeft besteld (onder het item ‘totaal’).

Voor dit voorbeeld hebben we extra do­cu­men­ten toe­ge­voegd om het ge­mak­ke­lij­ker te maken om op een later moment in­for­ma­tie toe te voegen. Dit helpt om een goed overzicht van de in­for­ma­tie in de database te behouden.

Een test­ver­za­me­ling maken voor MongoDB-query’s

Nu gaan we een collectie aanmaken met de naam ‘Klanten’. Om het over­zich­te­lijk te houden, nemen we slechts vijf items op in de collectie. Als je MongoDB-query’s gebruikt voor je werk, kun je met de insertMany uit­ge­brei­de­re col­lec­ties aanmaken.

Dit is hoe onze test­col­lec­tie eruitziet:

db.customers.insertMany ( [
{
    "name" : "Schulz",
    "location" : [ "Germany", "Austria" ],
    "transactions" : {
        "first" : {
            "year" : 2017,
        },
        "last" : {
            "year" : 2023,
        },
        "total" : 14
    }
},
{
    "name" : "ATS",
    "units" : 17,
    "location" : "France",
    "transactions" : {
        "first" : {
            "year" : 2021,
        },
        "last" : {
            "year" : 2022,
        },
        "total" : 2,
    }
},
{
    "name" : "Meyer",
    "units" : 814,
    "location" : [ "Austria", "Germany" ],
    "transactions" : {
        "first" : {
            "year" : 2016,
        },
        "last" : {
            "year" : 2023,
        },
        "total" : 22,
    }
},
{
    "name" : "Pawolski",
    "units" : 313,
    "location" : [ "Germany", "Poland" ],
    "transactions" : {
            "first" : {
            "year" : 2017,
            },
        "last" : {
            "year" : 2020,
        },
        "total" : 9,
    }
},
{
    "name" : "Jorgensen",
    "units" : 7,
    "location" : "Denmark",
    "transactions" : {
        "first" : {
            "year" : 2022,
        },
        "last" : {
            "year" : 2023,
        },
        "total" : 2,
    }
}
] )

Wanneer u deze invoer uitvoert met de gegevens die wij hebben gebruikt (of met uw eigen gegevens), krijgt u een lijst met object-ID’s terug. Deze zijn uniek en zorgen ervoor dat elk document ook via een bij­be­ho­ren­de ID kan worden gevonden. Als u zeker wilt weten dat alle do­cu­men­ten in de collectie zijn opgenomen, kunt u MongoDB find zonder pa­ra­me­ters gebruiken:

db.customers.find ( )

De uitvoer is een lijst met alle object-ID’s met de volledige do­cu­men­ten. U kunt deze nu door­zoe­ken met behulp van MongoDB-query’s.

Hoe MongoDB-query’s met velden en arrays te gebruiken

U kunt MongoDB-query’s gebruiken om af­zon­der­lij­ke velden, meerdere velden, arrays en in­ge­slo­ten do­cu­men­ten te door­zoe­ken. In de on­der­staan­de secties gaan we ze allemaal bekijken.

Af­zon­der­lij­ke velden opvragen met MongoDB-query’s

De uitvoer van MongoDB find laat zien hoe nuttig MongoDB-query’s kunnen zijn. Onze kleine steek­proef levert een uitvoer op met lange te­ken­reek­sen, dus u kunt zich voor­stel­len hoe het is als u met een grotere steek­proef werkt.

In het volgende voorbeeld gebruiken we ook find, maar deze keer stellen we een speciale eis waaraan een document moet voldoen om te worden uit­ge­voerd. We gaan namelijk zoeken naar alle do­cu­men­ten met de naam ‘ATS’.

db.customers.find (
    { "name" : "ATS" }
)

Een­vou­di­ge MongoDB-query’s zoals deze zoeken nu alle do­cu­men­ten in de collectie en matchen die do­cu­men­ten met de naam­waar­de ‘ATS’. Dit geldt slechts voor één item in onze collectie, dus de uitvoer ziet er als volgt uit:

db.customers.find ( { "name" : "ATS" } )
{
    "_id" : ObjectID ( "673d14684o75iftbb0ct5003" ),
    "name" : "ATS",
    "units" : 17,
    "location" : "France",
    "transactions" : {
        "first" : {
            "year" : 2021,
        },
        "last" : {
            "year" : 2022,
        },
        "total" : 2
    }

Het om­ge­keer­de werkt ook. Als u alle re­sul­ta­ten wilt weergeven behalve het item voor ‘ATS’, voert u het volgende in:

db.customers.find (
    { "name" : { $ne : "ATS" } }
)

Als u MongoDB-query’s met ver­schil­len­de waarden wilt uitvoeren, kunt u dit doen met een array. We doen dit met behulp van de klanten ATS en Jorgensen.

db.customers.find (
    { "name" : [ $in : [ "ATS", "Jorgensen" ] } }
)

Meerdere velden opvragen met MongoDB-query’s

Als u nauw­keu­ri­ge re­sul­ta­ten wilt, is het be­lang­rijk om uw zoek­op­dracht spe­ci­fie­ker te maken. U kunt uw MongoDB-zoek­op­drach­ten nauw­keu­ri­ger maken door aan­vul­len­de pa­ra­me­ters te gebruiken. Hieronder gaan we naast de be­drijfs­naam ‘ATS’ ook een waarde uit het segment ‘units’ spe­ci­fi­ce­ren. Op deze manier zoekt onze zoek­op­dracht naar een document dat beide waarden bevat:

db.customers.find (
    { "name" : "ATS", "units" : 17 }
)

We hebben een exacte over­een­komst. Als slechts één van de twee waarden over­een­komt, wordt er geen resultaat weer­ge­ge­ven. Hier is een voorbeeld van een zoek­op­dracht zonder re­sul­ta­ten:

db.customers.find (
    { "name" : "ATS", "units" : 25 }
)

Als u bij het gebruik van MongoDB-query’s rekening wilt houden met ver­schil­len­de waarden, maar wilt dat de query een resultaat oplevert, zelfs als slechts aan één van de vereisten is voldaan, voert u het volgende in:

db.customers.find (
    { $or : [ {"name" : "ATS"}, { "units" : 25 } ] }
)

Waarden in arrays opvragen

Je kunt bij MongoDB-query’s ook rekening houden met waarden in arrays. In onze collectie zitten bedrijven die ves­ti­gin­gen hebben in ver­schil­len­de landen. Als je alle bedrijven wilt weergeven die ten minste één vestiging in Duitsland hebben, kun je het volgende invoeren:

db.customers.find (
    { "location" : "Germany" }
)

De uitvoer bevat nu alle drie klanten die ten minste één vestiging in Duitsland hebben. Als u uw invoer wilt uit­brei­den en bedrijven wilt vinden die ves­ti­gin­gen in Duitsland en Oos­ten­rijk hebben met dezelfde query, kunt u een array gebruiken:

db.customers.find (
    { "location" : [ "Germany", "Austria" ] }
)

Je zult zien dat de invoer slechts één resultaat weergeeft, ook al voldoen twee bedrijven in theorie aan de zoek­cri­te­ria. De reden hiervoor is dat MongoDB-query’s zich strikt houden aan de invoer die ze krijgen, inclusief de volgorde van de elementen. Als je wilt dat de methode waarden in aan­mer­king neemt ongeacht de volgorde waarin ze voorkomen, schrijf je de query als volgt:

db.customers.find (
    { "location" : { $all : [ "Germany", "Austria" ] } }
)

Waarden in in­ge­slo­ten do­cu­men­ten opvragen

In onze collectie hebben we ook ingebedde do­cu­men­ten, die ook kunnen worden uit­ge­voerd met behulp van MongoDB-query’s. Om dit te doen, moet u een punt toevoegen om aan MongoDB aan te geven dat een veld in een genest document moet worden ge­a­na­ly­seerd. Als u bij­voor­beeld een lijst wilt van alle klanten die meer dan tien trans­ac­ties hebben, voert u het volgende in:

db.customers.find (
    { "transactions.total" : { $gt : 10 } }
)

MongoDB opent het document ‘trans­ac­ti­ons’ en zoekt ver­vol­gens het totale aantal trans­ac­ties onder ‘total’.

Hoe de uitvoer van MongoDB-query’s te beperken

De uitvoer van MongoDB-query’s kan be­hoor­lijk uit­ge­breid zijn, daarom kan het zinvol zijn om de uitvoer te beperken tot slechts enkele velden. U kunt pro­jec­ties gebruiken om het aantal velden dat in de uitvoer wordt weer­ge­ge­ven te beperken. Deze bevatten de waarde 1 (velden die in de uitvoer moeten worden opgenomen) en 0 (velden die niet in de uitvoer moeten worden opgenomen).

In het volgende voorbeeld voeren we een twee­de­li­ge query uit. Eerst starten we een zoek­op­dracht zonder pa­ra­me­ters met behulp van de find. Op zichzelf zou dit alle gegevens in de collectie weergeven. We volgen dit echter on­mid­del­lijk op met een projectie die alleen rekening houdt met het veld ‘naam’.

db.customers.find (
    { }
    { "name" : 1 }
)

Alle klanten worden weer­ge­ge­ven, maar de uitvoer wordt beperkt tot de namen van de bedrijven.

Wat zijn cursors en hoe kan ik ze gebruiken in MongoDB-query’s?

Cursors bieden een manier om de weergave van Mongo DB-query­re­sul­ta­ten aan te passen, zonder de daad­wer­ke­lij­ke re­sul­ta­ten van de query te wijzigen. U kunt bij­voor­beeld het aantal weer­ge­ge­ven re­sul­ta­ten beperken of de volgorde ervan wijzigen. Als u slechts twee van de re­sul­ta­ten wilt weergeven, kunt u de limit-methode gebruiken. Dat doet u als volgt:

db.customers.find (
    { }
    { "name" : 1 }
).limit ( 2 )

Om de uitvoer te sorteren, kunt u de volgende invoer gebruiken. Hiermee worden de drie klanten weer­ge­ge­ven die de minste producten hebben besteld:

db.customers.find (
    { }
    { "name" : 1 }
).limit ( 2 ) .sort ( { "units" : 1 } )