Hvordan bruke MongoDB-spørsmål

1

Hvordan søke effektivt i samlinger

Som en dokumentbasert NoSQL-løsning gir MongoDB brukerne muligheten til enkelt å lagre og administrere store og varierte datamengder. Databasestyringssystemet er svært fleksibelt og kan enkelt skaleres horisontalt.

I motsetning til relasjonsdatabaser lagres data i Mongo DB i BSON-dokumenter (binær JSON) og samles i samlinger. For at denne tilnærmingen skal fungere, er det viktig åha sterke søkemekanismer som kan søke gjennom databasen og presentere informasjonen brukerne trenger. Med MongoDB-søk kan databasen til og med søke i samlinger med kompleks struktur for å levere den informasjonen du leter etter.

Hva er MongoDB-spørsmål?

MongoDB-spørsmål er et brukervennlig verktøy som brukes til å søke i komplekse datastrukturer. De følger logiske regler og fungerer som filteralternativene du finner på de fleste nettsteder. Dette gjør at du kan formulere søket ditt så presist som mulig, slik at du oppnår best mulig resultat. Dette er spesielt viktig siden MongoDB kan lagre mange forskjellige typer data. Uten de nødvendige filteralternativene ville det være vanskelig å administrere databasen. I de følgende avsnittene forklarer vi hva du trenger for å lage MongoDB-spørringer og hvordan du bruker dem.

Hva er kravene til MongoDB-spørringer?

Det er bare noen få krav for å bruke MongoDB-spørsmål.

1. Du må ha MongoDB installert på datamaskinen din. Databasen fungerer på mange operativsystemer, så instruksjonene nedenfor gjelder uansett om du bruker Linux, OS X eller Windows. Trinnene etter installasjonen er de samme på alle systemer og påvirker bare selve databasen. Du kan finne ut hvordan installasjonen fungerer i vår MongoDB-veiledning.
2. Du må ha administratorrettigheter for å kunne bruke søkefunksjonen.
3. Det er best å opprette et testmiljø, slik at du kan prøve ut Mongo DB-spørsmål uten risiko.

Hvordan strukturere en testsamling

Åpne først skallet og logg inn som administrator. Opprett deretter en ny samling som skal fungere som et testmiljø for dine første MongoDB-spørsmål. I tillegg til å søke i enkle dokumenter, kan metoden også søke i matriser, ulike felt og innebygde dokumenter, og derfor har vi valgt å opprette en litt mer kompleks samling. På denne måten får du et bedre inntrykk av omfanget av MongoDB-spørsmål.

Eksemplet vårt består av en liste over kunder. Formatet på denne listen er som følger:

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

Dette dokumentet inneholder følgende informasjon:

• navn: Navnet på selskapet som kjøpte varene.
• enheter: Det totale antallet produkter som selskapet har bestilt.
• sted: Selskapets beliggenhet. Hvis det er flere filialer, kan disse lagres i form av en matrise.
• transaksjoner: Dette feltet inneholder et tilleggsdokument. Dokumenter som dette kalles «innebygde dokumenter» eller «nestede dokumenter». Hvert av transaksjonsdokumentene inneholder informasjon om hvor lenge selskapet har vært kunde (under «første» element), når den siste bestillingen ble lagt inn (under «siste» element) og det totale antallet ganger selskapet har bestilt produkter (under «totalt» element).

I dette eksemplet har vi lagt til flere dokumenter for å gjøre det enklere å inkludere informasjon på et senere tidspunkt. Dette bidrar til å sikre en god oversikt over informasjonen i databasen.

Opprette en testsamling for MongoDB-spørringer

Nå skal vi opprette en samling kalt «Kunder». For å gjøre det enkelt å holde oversikt over samlingen, skal vi bare inkludere fem oppføringer. Hvis du bruker MongoDB-spørringer i arbeidet ditt, kan du opprette mer omfattende samlinger ved hjelp av insertMany.

Slik ser testkolleksjonen vår ut:

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 kjører denne oppføringen med dataene vi har brukt (eller med dine egne data), får du en liste over objekt-ID-er tilbake. Disse er unike og sikrer at hvert dokument også kan finnes via en tilsvarende ID. Hvis du vil forsikre deg om at alle dokumenter er inkludert i samlingen, kan du bruke MongoDB find uten parametere:

db.customers.find ( )

Resultatet er en liste over alle objekt-ID-er med de komplette dokumentene. Du kan nå søke i dem ved hjelp av MongoDB-spørsmål.

Hvordan bruke MongoDB-spørsmål med felt og matriser

Du kan bruke MongoDB-spørringer til å søke i enkeltfelt, flere felt, matriser og innebygde dokumenter. Vi skal se nærmere på hvert av disse i avsnittene nedenfor.

Spørre om individuelle felt med MongoDB-spørsmål

Utdataene fra MongoDB find viser hvor nyttige MongoDB-spørringer kan være. Vår lille prøve gir utdata med lange tegnstrenger, så du kan forestille deg hvordan det er å jobbe med en større prøve.

I det følgende eksemplet bruker vi også find, men denne gangen skal vi opprette et spesielt krav som et dokument må oppfylle for å kunne skrives ut. Nærmere bestemt skal vi søke etter alle dokumenter som har navnet «ATS».

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

Enkle MongoDB-spørsmål som dette vil nå søke gjennom alle dokumentene i samlingen og finne de som har navneverdien «ATS». Dette gjelder bare én oppføring i samlingen vår, så resultatet ser slik ut:

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å å gjøre det omvendt. Hvis du vil vise alle resultatene unntatt oppføringen for «ATS», skriver du inn følgende:

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

Hvis du vil skrive ut MongoDB-spørsmål med forskjellige verdier, kan du gjøre det med en matrise. Vi gjør dette ved å bruke kundene ATS og Jorgensen.

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

Spørre flere felt med MongoDB-spørsmål

Hvis du trenger presise resultater, er det viktig å gjøre søket mer spesifikt. Du kan gjøre MongoDB-søkene dine mer presise ved å bruke tilleggsparametere. Nedenfor skal vi spesifisere en verdi fra segmentet «units» i tillegg til firmanavnet «ATS». På denne måten søker søket vårt etter et dokument som inneholder begge verdiene:

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

Vi har en eksakt treff. Hvis bare én av de to verdiene er en treff, vil det ikke vises noe resultat. Her er et eksempel på en søk uten resultater:

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

Hvis du vil ta hensyn til forskjellige verdier når du bruker MongoDB-spørringer, men ønsker at spørringen skal gi et resultat selv om bare ett av kravene er oppfylt, skriver du inn dette:

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

Spørre om verdier i matriser

Du kan også ta hensyn til verdier i tabeller med MongoDB-spørringer. I vår samling finnes det selskaper som har filialer i flere land. Hvis du vil vise alle selskaper som har minst én filial i Tyskland, kan du skrive inn følgende:

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

Resultatet inneholder nå alle tre kundene som har minst én filial i Tyskland. Hvis du vil utvide søket og finne selskaper som har filialer i Tyskland og Østerrike ved hjelp av samme søk, kan du bruke en matrise:

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

Du vil legge merke til at inndataene bare viser ett resultat, selv om to selskaper teoretisk sett oppfyller søkekriteriene. Årsaken til dette er at MongoDB-spørsmål holder seg nøyaktig til inndataene de får, inkludert rekkefølgen på elementene. Hvis du vil at metoden skal ta hensyn til verdiene uavhengig av rekkefølgen de vises i, skriver du spørsmålet som følger:

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

Spørre om verdier i innebygde dokumenter

I samlingen vår har vi også innebygde dokumenter, som også kan vises ved hjelp av MongoDB-spørringer. For å gjøre dette må du legge til et punktum for å signalisere til MongoDB at et felt i et nestet dokument skal analyseres. Hvis du for eksempel vil ha en liste over alle kunder som har mer enn ti transaksjoner, skriver du inn følgende:

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

MongoDB åpner dokumentet «transaksjoner» og søker deretter etter antall totale transaksjoner under «total».

Hvordan begrense utdataene fra MongoDB-spørringer

Utdataene fra MongoDB-spørringer kan være ganske omfattende, og det kan derfor være lurt å begrense utdataene til bare noen få felt. Du kan bruke projeksjoner for å begrense antall felt som vises i utdataene. Disse inneholder verdien 1 (felt som skal inkluderes i utdataene) og 0 (felt som ikke skal inkluderes i utdataene).

I det følgende eksemplet skal vi utføre en todelt spørring. Først skal vi starte en søk uten parametere ved hjelp av metoden find. I seg selv vil den vise alle dataene i samlingen. Imidlertid skal vi umiddelbart følge opp med en projeksjon som bare tar hensyn til navnefeltet.

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

Alle kundene vil bli vist, men utdataene vil være begrenset til navnene på selskapene.

Hva er markører, og hvordan kan jeg bruke dem i MongoDB-spørringer?

Cursorer gir deg muligheten til å tilpasse hvordan Mongo DB-søkeresultatene vises, uten å endre selve søkeresultatene. Du kan for eksempel begrense antall resultater som vises eller endre rekkefølgen deres. Hvis du bare vil vise to av resultatene, kan du bruke limit-metoden. Slik gjør du det:

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

For å sortere utdataene kan du bruke følgende oppføring. Dette vil vise de tre kundene som har bestilt færrest produkter:

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

9378b1ddb0084eac26edf8b51e922ecb

b713997fc6bfc4f1f8d7a9ec6d65df69

c9ac60f2f370c12c4028af59a2fea6ae

7dd4860127d59f767354576150e2acbd

03b2f431bad31c7bebd9b9a784e591ba

641becce284983e6cc3064159285947f

26d82365945b0a5f7ffdff0728634590

790acfdc7a291dc8e88a484b74b322e9

e05a5d509fef4e5f73a0d04553ea04e5