Hur man använder MongoDB för att skapa, uppdatera och fråga dokument

När du arbetar med MongoDB och dess dokumentorienterade struktur, kan det vara användbart att förstå hur man effektivt söker och hanterar data i databasen. En grundläggande aspekt av MongoDB är att bygga effektiva frågeställningar och förstå hur man använder olika metoder för att manipulera data. Här beskrivs några av de viktigaste aspekterna, inklusive att utföra sökningar, projicera specifika fält, samt skapa, uppdatera och ta bort dokument.

En grundläggande MongoDB-fråga för att hämta alla filmer från genren "Komedi" som släpptes efter 1945 i USA skulle se ut så här:

js
Copy code
db.movies.find({"year": {$gt: 1945}, "countries": "USA", "genres": "Comedy"})

Den här frågan använder $gt-operatorn för att filtrera filmer som är från ett år större än 1945. Vidare säkerställer villkoren för "countries" och "genres" att endast dokument som matchar båda dessa fält inkluderas. MongoDB:s find()-metod tillämpar en "AND"-operation, vilket betyder att alla tre villkoren måste uppfyllas för att ett dokument ska returneras.

För att ta reda på exakt hur många dokument som matchar dessa kriterier kan vi använda countDocuments()-metoden:

js
Copy code
db.movies.countDocuments({"year": {$gt: 1945}, "countries": "USA", "genres": "Comedy"})

I det här fallet kan vi konstatera att det finns 3521 dokument som matchar vår sökning. Några av de mest använda query-operatorerna i MongoDB är $gt (större än), $lt (mindre än) och $in (som tillåter att man anger en lista med värden). MongoDB:s dokumentation innehåller dock mycket fler operatorer, till exempel logiska operatorer som $and, $or, och $nor, samt geospatiala operatorer för att hitta närmaste punkter på en karta.

När du behöver ta ut specifika fält från dina dokument kan projektion vara ett bra verktyg. Projektion innebär att du kan specificera vilka fält som ska inkluderas eller exkluderas i resultaten. För att exempelvis endast få filmens titel, land och år kan du använda en projektion så här:

js
Copy code
db.movies.find({"year": {$gt: 1945}, "countries": "USA", "genres": "Comedy"}, {"_id":0, "title": 1, "countries": 1, "year": 1}).sort({"year": 1}).limit(5)

Här sätts _id till 0 för att utesluta det från resultatet, medan title, countries och year sätts till 1 för att inkluderas i det returnerade dokumentet. Frågan sorterar sedan resultaten efter år i stigande ordning och begränsar dem till fem dokument.

För att lägga till nya dokument i MongoDB används insertOne()-metoden. Exempelvis:

js
Copy code
db.movies.insertOne({"title": "Once upon a time on Moon", "genres":["Test"], "year": 2024})

Den här metoden ger en bekräftelse när den lyckas, inklusive ett unikt ObjectId för dokumentet. Du kan också lägga till flera dokument på en gång med insertMany():

js
Copy code
db.movies.insertMany([

  {"title": "Once upon a time on Moon", "genres":["Test"], "year": 2024},

  {"title": "Once upon a time on Mars", "genres":["Test"], "year": 2023},
  {"title": "Tiger Force in Paradise", "genres":["Test"], "year": 2019, "rating": "G"}
])

I detta exempel sätts "rating" fältet för en film, vilket visar på MongoDB:s flexibilitet när det gäller att hantera dokument utan strikt schema.

När du behöver uppdatera ett dokument används metoder som updateOne() och updateMany(). Till exempel, för att uppdatera den första filmen som har genren "Test" till att istället ha genren "PlaceHolder", kan du skriva:

js
Copy code
db.movies.updateOne({genres: "Test"}, {$set: {"genres.$": "PlaceHolder"}})

Om du istället vill uppdatera alla dokument som har genren "Test" och samtidigt öka året med ett kan du använda:

js
Copy code
db.movies.updateMany({ "genres": "Test" }, { $set: { "genres.$": "PlaceHolder" }, $inc: { "year": 1 } })

Den här metoden uppdaterar alla dokument som matchar kriterierna och ändrar värdet i flera fält samtidigt. Det är också viktigt att notera att uppdateringar i MongoDB är atomära; om flera uppdateringar sker samtidigt, kommer den som når servern först att genomföras.

När dokument ska tas bort används metoderna deleteOne() eller deleteMany(). Till exempel, för att ta bort alla dokument med genren "PlaceHolder", kan du skriva:

js
Copy code
db.movies.deleteMany({genres: "PlaceHolder"})

Det är också möjligt att ta bort hela samlingar med db.collection.drop(), men denna åtgärd bör användas med försiktighet eftersom den raderar alla dokument och index i samlingen.

MongoDB erbjuder även ett kraftfullt aggregeringsramverk som kan användas för att utföra komplexa operationer på samlingar, som att summera data eller gruppera den på specifika sätt. Aggregationsmetoden är ett kraftfullt verktyg för att bearbeta data och extrahera meningsfull information.

Hur kommunicerar FastAPI med REST?

Att titta på ett minimal FastAPI-program, som det klassiska "Hello World"-exemplet, ger en första inblick i hur FastAPI strukturerar sina endpoints. I denna kontext definieras en endpoint genom tre viktiga detaljer:

1. En unik URL-kombination: I utvecklingsservern blir detta alltid localhost:8000.

2. En path: Detta är delen av URL:en som kommer efter snedstrecket.

3. En HTTP-metod: Till exempel GET, POST, etc.

För att börja skapa en FastAPI-applikation, kan du skapa en Python-fil, exempelvis chapter4_01.py, i en mapp som heter Chapter4. Här är en grundläggande kodsnutt:

python
Copy code
from fastapi import FastAPI
app = FastAPI()
@app.get("/")
async def root():
    return {"message": "Hello FastAPI"}

När du har instansierat applikationen kan du definiera en endpoint. För att göra detta används en decorator, som i detta fall är @app.get("/"), som säger att applikationen ska svara på GET-förfrågningar som skickas till root-pathen (/). Den funktion som dekoratorn omger (här root) är ansvarig för att svara på dessa förfrågningar.

json
Copy code
{
   "message": "Hello FastAPI"
}

Det här är en enkel men fullt funktionell endpoint som bara hanterar GET-metoden för root-URL:en (/). Om du testar appen med en POST-förfrågan, kommer du att få ett 405 Method Not Allowed-fel.

För att skapa en endpoint som hanterar POST-metoden för samma root-URL, kan du bara lägga till följande kod:

python
Copy code
@app.post("/")

async def post_root():
    return {"message": "Post request success!"}

När du testar denna POST-endpoint med HTTPie får du svaret:

json
Copy code
{
   "message": "Post request success!"
}

Dokumentationen baseras på OpenAPI-specifikationen och använder Python-hints och Pydantic för att beskriva indata och utdata. Den låter också användaren ställa in JSON- eller formulärdata för att testa endpoints, visa svar eller felmeddelanden och hantera grundläggande autentisering, som det beskrivs i kapitel 6 om autentisering och auktorisering.

Skapa en ny fil, exempelvis chapter4_02.py, och skriv följande kod:

python
Copy code
from fastapi import FastAPI
app = FastAPI()
@app.get("/car/{id}")

async def get_car(id: int):

    return {"car_id": id}

Den här endpointen använder en dynamisk path för att ta emot ett ID och returnera ett JSON-svar som innehåller detta ID. Om du testar endpointen med ID = 1, får du svaret:

json
Copy code
{
   "car_id": 1
}

Det är också möjligt att skapa mer avancerade endpoints genom att använda query-parametrar och mer komplexa datatyper som skickas som JSON, vilket ger större flexibilitet och funktionalitet i API:et.

En annan viktig aspekt att notera är hur FastAPI hanterar data via Pydantic-modeller. Genom att använda dessa modeller kan du definiera strukturer för indata som säkerställer att användaren skickar korrekt formaterad data till API:et. Detta underlättar både validering och dokumentation och gör API:et både användarvänligt och robust.