FastAPI-backend-kehityksen intensiivikurssi · Oppitunti

Aggregointiputket ja monimutkaiset kyselyt

Suorittakaa suodatus-, ryhmittely- ja aggregointiputkia analytiikkatyyppisten päätepisteiden tehokkaaseen toteuttamiseen.

Oppitunti 3/413 vaihetta

Aggregointiputket ja monimutkaiset kyselyt on ilmainen FastAPI-backend-kehityksen intensiivikurssi-oppitunti CoddyKitissä. Tämä on oppitunti 3/4. Voit lukea tästä oppimispolusta kokonaan mitkä tahansa 3 oppituntia ilmaiseksi — sen jälkeen CoddyKit PRO avaa kaikki oppitunnit sekä käytännön harjoittelun sisäänrakennetulla koodieditorilla ja ympäri vuorokauden toimivalla tekoälytuutorilla. Oppitunti kuuluu FastAPI-backend-kehityksen intensiivikurssi-oppimispolkuun, ja edistymisesi synkronoituu verkon ja CoddyKit-sovelluksen välillä. FastAPI-backend-kehityksen intensiivikurssi-kurssilla on yhteensä 4 oppituntia.

Miksi aggregointiputkia käytetään?

Yksinkertaiset find-kyselyt palauttavat dokumentit sellaisinaan. Analytiikan päätepisteet tarvitsevat kuitenkin usein ryhmiteltyä, laskettua ja muotoiltua dataa: kuukausittaisen kokonaismyynnin, tuotekohtaisen keskiarvion tai kymmenen aktiivisinta käyttäjää.

MongoDB:n aggregointiputki suorittaa tämän työn tietokannan sisällä, joten verkon yli siirretään vain lopullinen tulos sen sijaan, että tuhansia dokumentteja haettaisiin Pythoniin käsiteltäviksi silmukassa.

Putki = järjestetty lista vaiheita
Jokainen vaihe vastaanottaa dokumenttivirran ja tuottaa dokumentteja
Beanie tarjoaa tähän Document.aggregate(pipeline)-rajapinnan

Beanie-mallimme

Käytämme tässä oppitunnissa Order-dokumenttia. Jokaisella tilauksella on asiakas, tila, kokonaissumma ja luontiaikaleima. Rakennamme sen päälle analytiikan päätepisteitä.

Beanie-dokumentit periytyvät luokasta beanie.Document, joka on Pydantic-malli ja samalla sidottu MongoDB-kokoelmaan.

from datetime import datetime
from beanie import Document
from pydantic import Field

class Order(Document):
    customer_id: str
    status: str  # "paid", "pending", "cancelled"
    total: float
    created_at: datetime = Field(default_factory=datetime.utcnow)

    class Settings:
        name = "orders"

$match-vaihe

$match suodattaa dokumentteja aivan kuten find-kysely. Sijoittakaa se mahdollisimman alkuun, jotta myöhemmät vaiheet käsittelevät vähemmän dokumentteja ja mahdollisia indeksejä voidaan hyödyntää.

Tämä putki säilyttää vain paid-tilassa olevat tilaukset. Beanien aggregate vastaanottaa tavallisen sanakirjojen listan ja suorittaa sen kokoelmalle.

pipeline = [
    {"$match": {"status": "paid"}}
]

paid_orders = await Order.aggregate(pipeline).to_list()

$group-vaihe

$group on analytiikan ydin. Se ryhmittelee dokumentit _id-lausekkeen perusteella ja laskee kullekin ryhmälle akumulaattoreita.

$sum — kentän summa (tai lukumäärä muodolla $sum: 1)
$avg, $min, $max
$push / $addToSet — kerää arvot taulukoksi

Tässä laskemme asiakaskohtaisen kokonaismyynnin ja tilausten lukumäärän.

pipeline = [
    {"$match": {"status": "paid"}},
    {"$group": {
        "_id": "$customer_id",
        "revenue": {"$sum": "$total"},
        "order_count": {"$sum": 1},
    }},
]

rows = await Order.aggregate(pipeline).to_list()
# [{"_id": "c1", "revenue": 240.0, "order_count": 3}, ...]

Kenttäpolut ja literaalit

Aggregointilausekkeissa merkillä $ alkava merkkijono on kenttäpolku (kentän arvon lukemista varten). Tavallinen merkkijono on literaali.

"$total" → total-kentän arvo
"total" → literaalimerkkijono "total"
{"$sum": 1} → lisää literaalin 1 jokaiselle dokumentille = lukumäärä

Näiden sekoittaminen on aloittelijoiden yleisin virhe. $sum: "$total" laskee summat yhteen; $sum: 1 laskee rivit.

Tulosten lajittelu ja rajoittaminen

Lisäämällä $sort- ja $limit-vaiheet ryhmittelyn jälkeen voitte muodostaa tulostaulukon. Lajittelussa 1 tarkoittaa nousevaa ja -1 laskevaa järjestystä.

Tämä palauttaa liikevaihdoltaan viisi parasta asiakasta — analytiikan päätepisteen tyypillisen vastauskuorman.

pipeline = [
    {"$match": {"status": "paid"}},
    {"$group": {
        "_id": "$customer_id",
        "revenue": {"$sum": "$total"},
    }},
    {"$sort": {"revenue": -1}},
    {"$limit": 5},
]

top_customers = await Order.aggregate(pipeline).to_list()

Muodon muuttaminen $project-vaiheella

$project valitsee säilytettävät kentät ja mahdollistaa niiden uudelleennimeämisen tai uusien kenttien laskemisen. $group-vaiheen jälkeen ryhmän avain on kentässä _id, joka on harvoin sama nimi, jota API:n käyttäjät odottavat.

Tässä nimeämme _id-kentän uudelleen muotoon customer_id ja poistamme tulosteesta oletusarvoisen _id-kentän.

pipeline = [
    {"$group": {
        "_id": "$customer_id",
        "revenue": {"$sum": "$total"},
    }},
    {"$project": {
        "_id": 0,
        "customer_id": "$_id",
        "revenue": 1,
    }},
]

Tulosten yhdistäminen Pydantic-malliin

Aggregointi palauttaa raakoja sanakirjoja, ei Order-dokumentteja (rakenne muuttui). Välittäkää projection_model, jotta Beanie validoi jokaisen rivin tyypitetyksi Pydantic-malliksi — tämä sopii erinomaisesti FastAPIn response_model-asetukseen.

from pydantic import BaseModel

class CustomerRevenue(BaseModel):
    customer_id: str
    revenue: float

pipeline = [
    {"$group": {"_id": "$customer_id", "revenue": {"$sum": "$total"}}},
    {"$project": {"_id": 0, "customer_id": "$_id", "revenue": 1}},
    {"$sort": {"revenue": -1}},
]

results = await Order.aggregate(
    pipeline, projection_model=CustomerRevenue
).to_list()  # List[CustomerRevenue]

Ryhmittely päivämäärän mukaan $dateToStringillä

Aikasarja-analytiikassa ryhmitelkää data muotoillun päivämäärän mukaan. $dateToString muuntaa aikaleiman merkkijonoksi, kuten "2026-06", jota voidaan käyttää kuukausittaisen myynnin ryhmittelyavaimena.

Tulos sopii erinomaisesti kaavioiden päätepisteisiin: yksi rivi kuukaudessa aikajärjestyksessä lajiteltuna.

pipeline = [
    {"$match": {"status": "paid"}},
    {"$group": {
        "_id": {"$dateToString": {
            "format": "%Y-%m", "date": "$created_at"
        }},
        "revenue": {"$sum": "$total"},
    }},
    {"$sort": {"_id": 1}},
]

monthly = await Order.aggregate(pipeline).to_list()

Liittäminen FastAPI-päätepisteeseen

Sijoittakaa putki asynkronisen reitin taakse. Koska aggregointi suoritetaan MongoDB:ssä, käsittelijä pysyy pienenä ja nopeana jopa miljoonien tilausten tapauksessa.

projection_model-mallin käyttäminen response_model-asetuksena tarjoaa automaattisen validoinnin ja OpenAPI-dokumentaation.

from fastapi import APIRouter

router = APIRouter()

@router.get("/analytics/top-customers", response_model=list[CustomerRevenue])
async def top_customers(limit: int = 5):
    pipeline = [
        {"$match": {"status": "paid"}},
        {"$group": {"_id": "$customer_id", "revenue": {"$sum": "$total"}}},
        {"$project": {"_id": 0, "customer_id": "$_id", "revenue": 1}},
        {"$sort": {"revenue": -1}},
        {"$limit": limit},
    ]
    return await Order.aggregate(pipeline, projection_model=CustomerRevenue).to_list()

Putken mallintaminen puhtaalla Pythonilla

Putkikaava — suodata, ryhmittele, summaa — on vain datan muuntamista. Tässä sama logiikka on toteutettu tavallisella Pythonilla, jotta näette, mitä MongoDB tekee sisäisesti: suodattaa, ryhmittelee avaimen perusteella ja laskee summan.

Tuotannossa MongoDB tekee tämän huomattavasti nopeammin ja hyödyntää indeksejä, mutta rakenteen ymmärtäminen auttaa kirjoittamaan oikeanlaisia vaiheita.

orders = [
    {"customer_id": "c1", "status": "paid", "total": 100.0},
    {"customer_id": "c2", "status": "paid", "total": 40.0},
    {"customer_id": "c1", "status": "paid", "total": 60.0},
    {"customer_id": "c2", "status": "pending", "total": 999.0},
]

revenue = {}
for o in orders:
    if o["status"] != "paid":  # $match
        continue
    revenue[o["customer_id"]] = revenue.get(o["customer_id"], 0) + o["total"]  # $group + $sum

top = sorted(revenue.items(), key=lambda kv: kv[1], reverse=True)  # $sort
for customer_id, total in top:
    print(f"{customer_id}: {total}")

Pikatarkistus

Haluatte laskea asiakaskohtaisen kokonaismyynnin ja ottaa mukaan vain maksetut tilaukset. Mikä putki on oikea?

Vastaa interaktiivisessa oppitunnissa

Kertaus

Osaatte nyt rakentaa analytiikan kaltaisia päätepisteitä Beanien aggregointiputkilla:

$match aikaisin suodatusta ja indeksien hyödyntämistä varten
$group akumulaattoreilla ($sum, $avg, lukumäärille $sum: 1)
Muistakaa, että kenttäpolut tarvitsevat alussa merkin $; tavalliset merkkijonot ovat literaaleja
$sort + $limit tulostaulukoihin ja $project rakenteen muuttamiseen sekä _id-kentän uudelleennimeämiseen
$dateToString aikasarjojen ryhmittelyyn
Välittäkää projection_model, jotta raakarivit muunnetaan tyypitetyiksi Pydantic-malleiksi ja FastAPIn response_model-tuloste pysyy selkeänä

Putki suoritetaan MongoDB:n sisällä, joten käsittelijät pysyvät pieninä ja päätepisteet nopeina.

Aloita maksutta

Opi FastAPI-backend-kehityksen intensiivikurssi tekoälytuutorin avulla — ilmaiseksi

Kirjoita ja suorita oikeaa koodia selaimessa, saa välitöntä apua tekoälytuutorilta ympäri vuorokauden ja jatka siitä, mihin jäit, verkossa tai sovelluksessa.

Kurssit: 21
Oppitunnit: 84

Aloita opiskelu maksutta Näytä koko kurssi

Usein kysytyt kysymykset

Onko oppitunti ”Aggregointiputket ja monimutkaiset kyselyt” ilmainen?

Kyllä — voit lukea täällä verkossa kokonaan ilmaiseksi mitkä tahansa FastAPI-backend-kehityksen intensiivikurssi-oppimispolun 3 oppituntia, myös oppitunnin “Aggregointiputket ja monimutkaiset kyselyt”. Sen jälkeen CoddyKit PRO avaa kaikki oppitunnit sekä interaktiiviset harjoitukset sisäänrakennetulla koodieditorilla ja ympäri vuorokauden toimivalla tekoälytuutorilla. FastAPI-backend-kehityksen intensiivikurssi-kurssilla on yhteensä 4 oppituntia.

Mitä opin oppitunnilla ”Aggregointiputket ja monimutkaiset kyselyt”?

Suorittakaa suodatus-, ryhmittely- ja aggregointiputkia analytiikkatyyppisten päätepisteiden tehokkaaseen toteuttamiseen. Harjoittelet FastAPI-backend-kehityksen intensiivikurssi-aihetta koodilla, jonka suoritat suoraan selaimessa. Ympäri vuorokauden käytettävissä oleva tekoälytuutori vastaa kysymyksiisi oppitunnin aikana.

Tarvitsenko kokemusta aloittaakseni FastAPI-backend-kehityksen intensiivikurssi-opiskelun?

Aiempi kokemus ei ole tarpeen. CoddyKitin FastAPI-backend-kehityksen intensiivikurssi-oppimispolku sopii vasta-alkajista edistyneisiin, joten voit aloittaa tästä tai alusta ja edetä omaan tahtiisi. Tämä on oppitunti 3/4.

Kuinka kauan ”Aggregointiputket ja monimutkaiset kyselyt”-oppitunnin suorittaminen kestää?

Useimmat CoddyKitin oppitunnit kestävät noin 5–10 minuuttia. Jokainen oppitunti on lyhyt ja interaktiivinen, joten edistyt tasaisesti ja voit jatkaa siitä, mihin jäit – sekä verkossa että sovelluksessa.

Voinko kirjoittaa ja suorittaa koodia tällä FastAPI-backend-kehityksen intensiivikurssi-oppitunnilla?

Kyllä. Jokainen FastAPI-backend-kehityksen intensiivikurssi-oppitunti sisältää sisäänrakennetun koodieditorin, joten voit kirjoittaa ja suorittaa oikeaa koodia suoraan selaimessa ja saada välitöntä palautetta tekoälyltä – paikallista asennusta ei tarvita.

Kaikki tämän kurssin oppitunnit

Asynkroninen MongoDB-yhteys Motorilla
Dokumenttimallinnus Beanie ODM:llä
Aggregointiputket ja monimutkaiset kyselyt
Skeeman kehitys ja dokumenttien migraatiot

← Takaisin: FastAPI-backend-kehityksen intensiivikurssi