Sådan bruges MongoDB-fo­re­spørgs­ler

MongoDB-fo­re­spørgs­ler giver dig mulighed for at søge og analysere din database hurtigt og effektivt. Metodens struktur er logisk, og du kan bruge ad­skil­li­ge parametre sammen med den.

Sådan søger du effektivt i samlinger

Som en do­ku­ment­ba­se­ret NoSQL-løsning giver MongoDB brugerne mulighed for nemt at gemme og ad­mi­ni­stre­re store og for­skel­lig­ar­te­de da­ta­mæng­der. Da­ta­ba­sesty­rings­sy­ste­met er meget flek­si­belt og kan nemt skaleres ho­ri­son­talt.

I mod­sæt­ning til re­la­tio­nel­le databaser gemmes data i Mongo DB i BSON-do­ku­men­ter (binær JSON) og samles i samlinger. For at denne tilgang virkelig kan fungere, er det vigtigt athave stærke sø­ge­me­ka­nis­mer, der kan gennemgå databasen og præ­sen­te­re de op­lys­nin­ger, som brugerne har brug for. Med MongoDB-søgninger kan databasen endda søge i komplekst struk­tu­re­re­de samlinger for at levere de op­lys­nin­ger, du leder efter.

Hvad er MongoDB-fo­re­spørgs­ler?

MongoDB-fo­re­spørgs­ler er et bru­ger­ven­ligt værktøj, der bruges til at søge i komplekse da­ta­struk­tu­rer. De følger logiske regler og fungerer som de fil­te­rindstil­lin­ger, du finder på de fleste websteder. Dette giver dig mulighed for at formulere din søgning så præcist som muligt, så du kan opnå de bedst mulige re­sul­ta­ter. Dette er især vigtigt, da MongoDB kan gemme mange for­skel­li­ge typer data. Uden de nød­ven­di­ge fil­te­rindstil­lin­ger ville det være van­ske­ligt at ad­mi­ni­stre­re databasen. I de følgende afsnit forklarer vi, hvad du har brug for for at oprette MongoDB-fo­re­spørgs­ler, og hvordan du bruger dem.

Hvad er kravene til MongoDB-fo­re­spørgs­ler?

Der er kun få krav til brug af MongoDB-fo­re­spørgs­ler.

1. Du skal have MongoDB in­stal­le­ret på din computer. Databasen fungerer på mange ope­ra­tiv­sy­ste­mer, så ne­den­stå­en­de in­struk­tio­ner virker, uanset om du bruger Linux, OS X eller Windows. Trinene efter in­stal­la­tio­nen er de samme på alle systemer og påvirker kun selve databasen. Du kan finde ud af, hvordan in­stal­la­tio­nen fungerer, i vores MongoDB-vej­led­ning.
2. Du skal have ad­mi­ni­stra­tor­ret­tig­he­der for at kunne bruge sø­ge­funk­tio­nen.
3. Det er bedst at oprette et testmiljø, så du kan afprøve Mongo DB-fo­re­spørgs­ler uden risiko.

Hvordan man struk­tu­re­rer en test­sam­ling

Åbn først shellen og log ind som ad­mi­ni­stra­tor. Opret derefter en ny samling, der skal fungere som testmiljø for dine første MongoDB-fo­re­spørgs­ler. Ud over at søge i enkle do­ku­men­ter kan metoden også søge i arrays, for­skel­li­ge felter og ind­lej­re­de do­ku­men­ter, og derfor har vi besluttet at oprette en lidt mere kompleks samling. På den måde får du et bedre indtryk af omfanget af MongoDB-fo­re­spørgs­ler.

Vores eksempel består af en liste over kunder. Formatet for denne liste er som følger:

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

Dette dokument in­de­hol­der følgende op­lys­nin­ger:

• navn: Navnet på det firma, der har købt varerne.
• enheder: Det samlede antal produkter, som virk­som­he­den har bestilt.
• placering: Virk­som­he­dens placering. Hvis der er flere filialer, kan disse gemmes i form af en matrix.
• transak­tio­ner: Dette felt in­de­hol­der et yder­li­ge­re dokument. Do­ku­men­ter som dette kaldes ‘ind­lej­re­de do­ku­men­ter’ eller ‘ind­lej­re­de do­ku­men­ter’. Hvert af transak­tions­do­ku­men­ter­ne in­de­hol­der op­lys­nin­ger om, hvor længe virk­som­he­den har været kunde (under ‘første’ punkt), hvornår den sidste ordre blev afgivet (under ‘sidste’ punkt) og det samlede antal gange, virk­som­he­den har bestilt produkter (under ‘samlet’ punkt).

I dette eksempel har vi tilføjet yder­li­ge­re do­ku­men­ter for at gøre det lettere at inkludere op­lys­nin­ger på et senere tidspunkt. Dette bidrager til at sikre et godt overblik over op­lys­nin­ger­ne i databasen.

Op­ret­tel­se af en test­sam­ling til MongoDB-fo­re­spørgs­ler

Nu skal vi oprette en samling kaldet ‘Kunder’. For at det er nemt at bevare over­blik­ket over samlingen, vil vi kun inkludere fem poster. Hvis du bruger MongoDB-fo­re­spørgs­ler i dit arbejde, kan du oprette mere om­fat­ten­de samlinger ved hjælp af metoden insertMany.

Sådan ser vores test­sam­ling ud:

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,
    }
}
] )

Når du kører denne post med de data, vi har brugt (eller med dine egne data), får du en liste over objekt-id’er tilbage. Disse er unikke og sikrer, at hvert dokument også kan findes via et til­sva­ren­de id. Hvis du vil sikre dig, at alle do­ku­men­ter er medtaget i samlingen, kan du bruge MongoDB find uden parametre:

db.customers.find ( )

Re­sul­ta­tet er en liste over alle objekt-ID’er med de komplette do­ku­men­ter. Du kan nu søge i dem ved hjælp af MongoDB-fo­re­spørgs­ler.

Sådan bruges MongoDB-fo­re­spørgs­ler med felter og arrays

Du kan bruge MongoDB-fo­re­spørgs­ler til at søge i enkelte felter, flere felter, arrays og ind­lej­re­de do­ku­men­ter. Vi vil se nærmere på hver af disse i af­snit­te­ne nedenfor.

Fo­re­spørgsel på in­di­vi­du­el­le felter med MongoDB-fo­re­spørgs­ler

Output fra MongoDB find viser, hvor nyttige MongoDB-fo­re­spørgs­ler kan være. Vores lille eksempel giver et output med lange tegn­stren­ger, så du kan fo­re­stil­le dig, hvordan det er, hvis du arbejder med et større eksempel.

I det følgende eksempel bruger vi også find, men denne gang opstiller vi et særligt krav, som et dokument skal opfylde for at blive udskrevet. Konkret vil vi søge efter alle do­ku­men­ter, der har navnet ‘ATS’.

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

Enkle MongoDB-fo­re­spørgs­ler som denne vil nu søge i alle do­ku­men­ter­ne i samlingen og matche dem, der har nav­ne­vær­di­en ‘ATS’. Dette gælder kun for én post i vores samling, så re­sul­ta­tet ser således ud:

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

Det fungerer også omvendt. Hvis du vil vise alle re­sul­ta­ter undtagen posten for ‘ATS’, skal du indtaste følgende:

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

Hvis du vil udskrive MongoDB-fo­re­spørgs­ler med for­skel­li­ge værdier, kan du gøre det med en matrix. Vi gør dette ved hjælp af kunderne ATS og Jorgensen.

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

Fo­re­spørgsel på flere felter med MongoDB-fo­re­spørgs­ler

Hvis du har brug for præcise re­sul­ta­ter, er det vigtigt at gøre din fo­re­spørgsel mere specifik. Du kan gøre dine MongoDB-fo­re­spørgs­ler mere præcise ved at bruge yder­li­ge­re parametre. Nedenfor angiver vi en værdi fra segmentet ‘units’ ud over fir­ma­nav­net ‘ATS’. På denne måde søger vores fo­re­spørgsel efter et dokument, der in­de­hol­der begge værdier:

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

Vi har et nøjagtigt match. Hvis kun én af de to værdier matcher, vises der ingen re­sul­ta­ter. Her er et eksempel på en fo­re­spørgsel uden re­sul­ta­ter:

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

Hvis du vil tage for­skel­li­ge værdier i be­tragt­ning, når du bruger MongoDB-fo­re­spørgs­ler, men ønsker, at fo­re­spørgs­len skal give et resultat, selvom kun et af kravene er opfyldt, skal du indtaste følgende:

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

Fo­re­spørgsel på værdier i arrays

Du kan også tage værdier i arrays i be­tragt­ning med MongoDB-fo­re­spørgs­ler. I vores samling er der virk­som­he­der, der har filialer i flere lande. Hvis du vil vise alle virk­som­he­der, der har mindst én filial i Tyskland, kan du indtaste følgende:

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

Re­sul­ta­tet in­de­hol­der nu alle tre kunder, der har mindst én filial i Tyskland. Hvis du vil udvide din ind­tast­ning og finde virk­som­he­der, der har filialer i Tyskland og Østrig ved hjælp af den samme fo­re­spørgsel, kan du bruge en matrix:

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

Du vil bemærke, at ind­tast­nin­gen kun viser ét resultat, selvom to virk­som­he­der teoretisk set matcher sø­ge­kri­te­ri­er­ne. Årsagen til dette er, at MongoDB-fo­re­spørgs­ler holder sig nøjagtigt til den ind­tast­ning, de får, hvilket in­klu­de­rer ræk­ke­føl­gen af ele­men­ter­ne. Hvis du ønsker, at metoden skal tage højde for værdier uanset den ræk­ke­føl­ge, de vises i, skal du skrive fo­re­spørgs­len som følger:

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

Fo­re­spørgsel på værdier i ind­lej­re­de do­ku­men­ter

I vores samling har vi også ind­lej­re­de do­ku­men­ter, som også kan udskrives ved hjælp af MongoDB-fo­re­spørgs­ler. For at gøre dette skal du tilføje et punktum for at signalere til MongoDB, at et felt i et indlejret dokument skal ana­ly­se­res. Hvis du f.eks. ønsker en liste over alle kunder, der har mere end ti transak­tio­ner, skal du indtaste følgende:

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

MongoDB åbner do­ku­men­tet “transa­ctions” og søger derefter efter det samlede antal transak­tio­ner under “total”.

Sådan begrænses outputtet fra MongoDB-fo­re­spørgs­ler

Outputtet fra MongoDB-fo­re­spørgs­ler kan være ret om­fat­ten­de, hvorfor det kan være en god idé at begrænse outputtet til blot et par felter. Du kan bruge pro­jek­tio­ner til at begrænse antallet af felter, der vises i outputtet. Disse in­de­hol­der værdien 1 (felter, der skal medtages i outputtet) og 0 (felter, der ikke skal medtages i outputtet).

I det følgende eksempel vil vi udføre en todelt fo­re­spørgsel. Først vil vi starte en søgning uden parametre ved hjælp af metoden find. I sig selv vil den udskrive alle dataene i samlingen. Men vi vil straks ef­ter­føl­gen­de lave en pro­jek­tion, der kun tager højde for nav­ne­fel­tet.

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

Alle kunder vises, men ud­skrif­ten er begrænset til virk­som­heds­nav­ne.

Hvad er cursors, og hvordan kan jeg bruge dem i MongoDB-fo­re­spørgs­ler?

Cursorer giver mulighed for at tilpasse visningen af Mongo DB-fo­re­spørgsels­re­sul­ta­ter uden at ændre de faktiske re­sul­ta­ter af fo­re­spørgs­len. Du kan f.eks. begrænse antallet af re­sul­ta­ter, der vises, eller ændre deres ræk­ke­føl­ge. Hvis du kun vil vise to af re­sul­ta­ter­ne, kan du bruge limit-metoden. Sådan gør du:

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

For at sortere outputtet kan du bruge følgende ind­tast­ning. Dette vil vise de tre kunder, der har bestilt færrest produkter:

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