Hur man använder MongoDB-frågor

Med MongoDB-frågor kan du söka och analysera din databas snabbt och effektivt. Metodens struktur är logisk och du kan använda många olika pa­ra­met­rar med den.

Hur man söker effektivt i samlingar

Som en do­ku­ment­ba­se­rad NoSQL-lösning ger MongoDB an­vän­dar­na möjlighet att enkelt lagra och hantera stora och va­ri­e­ran­de da­ta­mäng­der. Da­ta­bashan­te­rings­sy­ste­met är mycket flexibelt och kan enkelt skalas ho­ri­son­tellt.

Till skillnad från re­la­tions­da­ta­ba­ser lagras data i Mongo DB i BSON-dokument (binär JSON) och samlas i samlingar. För att denna metod ska fungera är det viktigt attha kraft­ful­la sök­me­ka­nis­mer som kan söka igenom databasen och pre­sen­te­ra den in­for­ma­tion som an­vän­dar­na behöver. Med MongoDB-sökningar kan databasen även söka i komplexa samlingar för att leverera den in­for­ma­tion du letar efter.

Vad är MongoDB-frågor?

MongoDB-frågor är ett an­vän­dar­vän­ligt verktyg som används för att söka i komplexa da­ta­struk­tu­rer. De följer logiska regler och fungerar som de fil­te­ral­ter­na­tiv som finns på de flesta webb­plat­ser. Detta gör att du kan formulera din sökning så precist som möjligt för att uppnå bästa möjliga resultat. Detta är särskilt viktigt eftersom MongoDB kan lagra många olika typer av data. Utan nöd­vän­di­ga fil­te­ral­ter­na­tiv skulle det vara svårt att hantera databasen. I följande avsnitt förklarar vi vad du behöver för att skapa MongoDB-frågor och hur du använder dem.

Vilka är kraven för MongoDB-frågor?

Det finns endast några få krav för att använda MongoDB-frågor.

1. Du måste ha MongoDB in­stal­le­rat på din dator. Databasen fungerar på många ope­ra­tiv­sy­stem, så in­struk­tio­ner­na nedan fungerar oavsett om du använder Linux, OS X eller Windows. Stegen efter in­stal­la­tio­nen är desamma på alla system och påverkar endast själva databasen. Du kan läsa om hur in­stal­la­tio­nen fungerar i vår MongoDB-hand­led­ning.
2. Du behöver ad­mi­nist­ra­törs­rät­tig­he­ter för att kunna använda sök­funk­tio­nen.
3. Det är bäst att skapa en testmiljö så att du kan prova Mongo DB-frågor utan risk.

Hur man struk­tu­re­rar en test­sam­ling

Öppna först skalet och logga in som ad­mi­nist­ra­tör. Skapa sedan en ny samling som kommer att fungera som en testmiljö för dina första MongoDB-frågor. Förutom att söka i enkla dokument kan metoden också söka i matriser, olika fält och inbäddade dokument, vilket är an­led­ning­en till att vi har beslutat att skapa en något mer komplex samling. På så sätt får du en bättre upp­fatt­ning om om­fatt­ning­en av MongoDB-frågor.

Vårt exempel består av en lista över kunder. Formatet för denna lista är följande:

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

Detta dokument in­ne­hål­ler följande in­for­ma­tion:

• namn: Namnet på det företag som köpt varorna.
• enheter: Det totala antalet produkter som företaget beställt.
• plats: Fö­re­ta­gets plats. Om det finns flera filialer kan dessa sparas i form av en matris.
• trans­ak­tio­ner: Detta fält in­ne­hål­ler ett yt­ter­li­ga­re dokument. Dokument som detta kallas för ”inbäddade dokument” eller ”nästlade dokument”. Varje trans­ak­tions­do­ku­ment in­ne­hål­ler in­for­ma­tion om hur länge företaget har varit kund (under ”första” posten), när den senaste be­ställ­ning­en gjordes (under ”sista” posten) och det totala antalet gånger företaget har beställt produkter (under ”totalt” posten).

I det här exemplet har vi lagt till yt­ter­li­ga­re dokument för att göra det enklare att lägga till in­for­ma­tion vid ett senare tillfälle. På så sätt får man en bra översikt över in­for­ma­tio­nen i databasen.

Skapa en test­sam­ling för MongoDB-frågor

Nu ska vi skapa en samling som heter “Kunder”. För att det ska vara enkelt att hålla reda på samlingen kommer vi bara att inkludera fem poster. Om du använder MongoDB-frågor i ditt arbete kan du skapa mer om­fat­tan­de samlingar med hjälp av metoden insertMany.

Så här ser vår test­sam­ling 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 kör denna post med de data vi har använt (eller med dina egna data) får du en lista med objekt-ID:n som svar. Dessa är unika och sä­ker­stäl­ler att varje dokument också kan hittas via ett mot­sva­ran­de ID. Om du vill sä­ker­stäl­la att alla dokument har in­klu­de­rats i samlingen kan du använda MongoDB find utan pa­ra­met­rar:

db.customers.find ( )

Re­sul­ta­tet är en lista över alla objekt-ID:n med de full­stän­di­ga do­ku­men­ten. Du kan nu söka efter dem med hjälp av MongoDB-frågor.

Hur man använder MongoDB-frågor med fält och matriser

Du kan använda MongoDB-frågor för att söka i enskilda fält, flera fält, matriser och inbäddade dokument. Vi tittar närmare på var och en av dessa i avsnitten nedan.

Fråga enskilda fält med MongoDB-frågor

Ut­mat­ning­en från MongoDB find visar hur an­vänd­ba­ra MongoDB-frågor kan vara. Vårt lilla exempel ger en utmatning med långa tec­ken­sträng­ar, så du kan fö­re­stäl­la dig hur det blir om du arbetar med ett större exempel.

I följande exempel använder vi också find, men den här gången skapar vi ett särskilt krav som ett dokument måste uppfylla för att kunna skrivas ut. Mer specifikt söker vi efter alla dokument som har namnet ”ATS”.

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

Enkla MongoDB-frågor som denna kommer nu att söka igenom alla dokument i samlingen och matcha de som har namnet “ATS”. Detta gäller endast en post i vår samling, så re­sul­ta­tet ser ut så här:

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

Det fungerar också tvärtom. Om du vill visa alla resultat utom posten för “ATS” anger du följande:

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

Om du vill mata ut MongoDB-frågor med olika värden kan du göra det med en matris. Vi gör detta med hjälp av kunderna ATS och Jorgensen.

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

Söka i flera fält med MongoDB-sökningar

Om du behöver exakta resultat är det viktigt att göra din sökning mer specifik. Du kan göra dina MongoDB-sökningar mer exakta genom att använda yt­ter­li­ga­re pa­ra­met­rar. Nedan kommer vi att ange ett värde från segmentet “enheter” utöver fö­re­tags­nam­net “ATS”. På så sätt söker vår sökning efter ett dokument som in­ne­hål­ler båda värdena:

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

Vi har en exakt matchning. Om endast ett av de två värdena matchar kommer inget resultat att visas. Här är ett exempel på en sökning utan resultat:

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

Om du vill ta hänsyn till olika värden när du använder MongoDB-frågor, men vill att frågan ska ge ett resultat även om endast ett av kraven är uppfyllt, anger du följande:

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

Fråga värden i matriser

Du kan också ta hänsyn till värden i matriser med MongoDB-frågor. I vår samling finns företag som har filialer i flera länder. Om du vill visa alla företag som har minst en filial i Tyskland kan du ange följande:

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

Re­sul­ta­tet in­ne­hål­ler nu alla tre kunder som har minst en filial i Tyskland. Om du vill utöka din inmatning och hitta företag som har filialer i Tyskland och Österrike med samma sökfråga kan du använda en matris:

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

Du kommer att märka att in­mat­ning­en endast visar ett resultat, även om två företag te­o­re­tiskt sett matchar sök­kri­te­ri­er­na. An­led­ning­en till detta är att MongoDB-frågor följer exakt den inmatning de får, vilket in­klu­de­rar ele­men­tens ordning. Om du vill att metoden ska ta hänsyn till värden oavsett i vilken ordning de visas, skriver du frågan enligt följande:

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

Söka värden i inbäddade dokument

I vår samling har vi också inbäddade dokument, som också kan matas ut med hjälp av MongoDB-frågor. För att göra detta måste du lägga till en punkt för att signalera till MongoDB att ett fält i ett inbäddat dokument ska ana­ly­se­ras. Om du till exempel vill ha en lista över alla kunder som har mer än tio trans­ak­tio­ner anger du följande:

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

MongoDB öppnar do­ku­men­tet “trans­ac­tions” och letar sedan efter antalet trans­ak­tio­ner under “total”.

Hur man begränsar utdata från MongoDB-frågor

Re­sul­ta­tet av MongoDB-frågor kan vara ganska om­fat­tan­de, vilket är an­led­ning­en till att det kan vara vettigt att begränsa re­sul­ta­tet till endast några få fält. Du kan använda pro­jek­tio­ner för att begränsa antalet fält som visas i re­sul­ta­tet. Dessa in­ne­hål­ler värdet 1 (fält som ska in­klu­de­ras i re­sul­ta­tet) och 0 (fält som inte ska in­klu­de­ras i re­sul­ta­tet).

I följande exempel ska vi utföra en tvådelad sökning. Först ska vi initiera en sökning utan pa­ra­met­rar med hjälp av metoden find. I sig skulle den visa alla data i samlingen. Men vi ska ome­del­bart följa upp den med en pro­jek­tion som endast tar hänsyn till fältet namn.

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

Alla kunder visas, men utdata begränsas till fö­re­ta­gens namn.

Vad är markörer och hur kan jag använda dem i MongoDB-frågor?

Cursorer erbjuder ett sätt att anpassa hur Mongo DB-sökre­sul­tat visas, utan att ändra de faktiska re­sul­ta­ten av sökningen. Du kan till exempel begränsa antalet resultat som visas eller ändra deras ordning. Om du bara vill visa två av re­sul­ta­ten kan du använda be­gräns­nings­me­to­den. Så här gör du:

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

För att sortera re­sul­ta­tet kan du använda följande inmatning. Detta visar de tre kunder som har beställt minst antal produkter:

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