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 parametrar med den.

Hur man söker effektivt i samlingar

Som en dokumentbaserad NoSQL-lösning ger MongoDB användarna möjlighet att enkelt lagra och hantera stora och varierande datamängder. Databashanteringssystemet är mycket flexibelt och kan enkelt skalas horisontellt.

Till skillnad från relationsdatabaser 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 kraftfulla sökmekanismer som kan söka igenom databasen och presentera den information som användarna behöver. Med MongoDB-sökningar kan databasen även söka i komplexa samlingar för att leverera den information du letar efter.

Vad är MongoDB-frågor?

MongoDB-frågor är ett användarvänligt verktyg som används för att söka i komplexa datastrukturer. De följer logiska regler och fungerar som de filteralternativ som finns på de flesta webbplatser. 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ödvändiga filteralternativ 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 installerat på din dator. Databasen fungerar på många operativsystem, så instruktionerna nedan fungerar oavsett om du använder Linux, OS X eller Windows. Stegen efter installationen är desamma på alla system och påverkar endast själva databasen. Du kan läsa om hur installationen fungerar i vår MongoDB-handledning.
2. Du behöver administratörsrättigheter för att kunna använda sökfunktionen.
3. Det är bäst att skapa en testmiljö så att du kan prova Mongo DB-frågor utan risk.

Hur man strukturerar en testsamling

Öppna först skalet och logga in som administratö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 anledningen till att vi har beslutat att skapa en något mer komplex samling. På så sätt får du en bättre uppfattning om omfattningen 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 innehåller följande information:

• namn: Namnet på det företag som köpt varorna.
• enheter: Det totala antalet produkter som företaget beställt.
• plats: Företagets plats. Om det finns flera filialer kan dessa sparas i form av en matris.
• transaktioner: Detta fält innehåller ett ytterligare dokument. Dokument som detta kallas för ”inbäddade dokument” eller ”nästlade dokument”. Varje transaktionsdokument innehåller information om hur länge företaget har varit kund (under ”första” posten), när den senaste beställningen 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 ytterligare dokument för att göra det enklare att lägga till information vid ett senare tillfälle. På så sätt får man en bra översikt över informationen i databasen.

Skapa en testsamling 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 omfattande samlingar med hjälp av metoden insertMany.

Så här ser vår testsamling 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äkerställer att varje dokument också kan hittas via ett motsvarande ID. Om du vill säkerställa att alla dokument har inkluderats i samlingen kan du använda MongoDB find utan parametrar:

db.customers.find ( )

Resultatet är en lista över alla objekt-ID:n med de fullständiga dokumenten. 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

Utmatningen från MongoDB find visar hur användbara MongoDB-frågor kan vara. Vårt lilla exempel ger en utmatning med långa teckensträngar, så du kan föreställa 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å resultatet 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 ytterligare parametrar. Nedan kommer vi att ange ett värde från segmentet “enheter” utöver företagsnamnet “ATS”. På så sätt söker vår sökning efter ett dokument som innehåller 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" }
)

Resultatet innehåller 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 inmatningen endast visar ett resultat, även om två företag teoretiskt sett matchar sökkriterierna. Anledningen till detta är att MongoDB-frågor följer exakt den inmatning de får, vilket inkluderar elementens 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 analyseras. Om du till exempel vill ha en lista över alla kunder som har mer än tio transaktioner anger du följande:

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

MongoDB öppnar dokumentet “transactions” och letar sedan efter antalet transaktioner under “total”.

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

Resultatet av MongoDB-frågor kan vara ganska omfattande, vilket är anledningen till att det kan vara vettigt att begränsa resultatet till endast några få fält. Du kan använda projektioner för att begränsa antalet fält som visas i resultatet. Dessa innehåller värdet 1 (fält som ska inkluderas i resultatet) och 0 (fält som inte ska inkluderas i resultatet).

I följande exempel ska vi utföra en tvådelad sökning. Först ska vi initiera en sökning utan parametrar med hjälp av metoden find. I sig skulle den visa alla data i samlingen. Men vi ska omedelbart följa upp den med en projektion som endast tar hänsyn till fältet namn.

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

Alla kunder visas, men utdata begränsas till företagens 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ökresultat visas, utan att ändra de faktiska resultaten av sökningen. Du kan till exempel begränsa antalet resultat som visas eller ändra deras ordning. Om du bara vill visa två av resultaten kan du använda begränsningsmetoden. Så här gör du:

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

För att sortera resultatet 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 } )