Avansert PostgreSQL: Indeksering, partisjonering og replikering · leksjon

Praktiske eksempler fra virkeligheten

Undersøk praktiske eksempler og lær av vellykkede implementeringer av indeksering og partisjonering i storskala systemer.

Leksjon 3 av 411 trinn

Praktiske eksempler fra virkeligheten er en gratis leksjon i Avansert PostgreSQL: Indeksering, partisjonering og replikering på CoddyKit. Dette er leksjon 3 av 4. Du kan lese hele leksjonen gratis nedenfor – og deretter øve praktisk i nettleseren med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i Avansert PostgreSQL: Indeksering, partisjonering og replikering, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i Avansert PostgreSQL: Indeksering, partisjonering og replikering inneholder totalt 4 leksjoner.

Indeksering og partisjonering i praksis

Velkommen til den siste leksjonen! De har lært om indekser og partisjonering hver for seg. Nå skal De utforske hvordan disse kraftige funksjonene kombineres i systemer i stor skala og fra virkeligheten.

Vi skal se på praktiske kasusstudier for å forstå hvordan databasearkitekter bruker disse strategiene til å løse komplekse utfordringer knyttet til ytelse og administrasjon.

Kasusstudie 1: Bestillinger i netthandel

Se for Dem en populær netthandelsplattform som behandler millioner av bestillinger hver dag. orders-tabellen vokser raskt og inneholder flere års transaksjonshistorikk.

Utfordring: Det går raskt å spørre etter nylige bestillinger, men historiske rapporter eller kundeserviceoppslag for gamle bestillinger går svært sakte.
Problem: Den ene, enorme orders-tabellen er vanskelig å vedlikeholde og sikkerhetskopiere, og indeksstørrelsene blir uhåndterlige.

Løsning: Intervallpartisjonering etter dato

For å løse utfordringen med netthandelen bestemmer teamet seg for å implementere intervallpartisjonering på kolonnen order_date. Dette deler den store tabellen inn i mindre og mer håndterbare partisjoner, vanligvis etter måned eller år.

Spørringer etter nyere data skanner bare de nyeste partisjonene, noe som gir en betydelig hastighetsøkning for vanlige operasjoner. Eldre partisjoner kan arkiveres eller brukes sjeldnere.

CREATE TABLE orders (
    order_id BIGINT NOT NULL,
    customer_id INT NOT NULL,
    order_date DATE NOT NULL,
    total_amount NUMERIC(10, 2)
) PARTITION BY RANGE (order_date);

CREATE TABLE orders_y2023m01 PARTITION OF orders
    FOR VALUES FROM ('2023-01-01') TO ('2023-02-01');

Løsning: Lokale indekser for bestillinger

Når partisjoneringen er på plass, opprettes indekser lokalt på hver partisjon. Det betyr at hver partisjon har sin egen mindre indeks, i stedet for én enorm indeks for hele tabellen.

Fordel: Mindre indekser er raskere å søke i og oppdatere.
Fordel: Spørringer som retter seg mot en bestemt partisjon (for eksempel etter kunde-ID innenfor én måned), bruker bare indeksen til denne partisjonen.

CREATE INDEX idx_orders_y2023m01_customer_id
ON orders_y2023m01 (customer_id);

CREATE INDEX idx_orders_y2023m01_order_id
ON orders_y2023m01 (order_id);

Resultat av kasusstudien om netthandel

Kombinasjonen av intervallpartisjonering og lokale indekser forbedret ytelsen til netthandelsplattformen betydelig:

Spørringstiden for nyere data gikk ned med 80%.
Vedlikeholdsoppgaver i databasen (som VACUUM) ble mye raskere på mindre partisjoner.
Gamle data kunne arkiveres eller slettes effektivt ved ganske enkelt å koble fra og slette gamle partisjoner.

Kasusstudie 2: IoT-sensordata

La oss deretter se på en Internet of Things-plattform (IoT) som samler inn sensordata fra millioner av enheter. Hver enhet sender avlesninger med noen sekunders mellomrom, noe som fører til petabyte med tidsseriedata.

Utfordring: Å ta imot data i svært høy hastighet og kjøre ulike analytiske spørringer (for eksempel «finn alle enheter som rapporterer temperatur > X i region Y den siste uken»).
Problem: Standard B-tree-indekser på tidsstempler blir for store og trege å oppdatere ved slike datamengder.

Løsning: Hybridpartisjonering

For IoT-data er en hybrid partisjoneringsstrategi ofte ideell. Teamet implementerte:

Intervallpartisjonering etter tid: Den primære partisjoneringsnøkkelen er timestamp, som deler dataene inn etter dag eller time.
Listepartisjonering etter enhetstype: Innenfor hver tids-partisjon partisjoneres dataene videre etter device_type (for eksempel «sensor», «actuator» og «gateway»).

Dette gjør det mulig å beskjære partisjoner effektivt basert på både tid og enhetsegenskaper.

CREATE TABLE sensor_data (
    timestamp TIMESTAMPTZ NOT NULL,
    device_id INT NOT NULL,
    device_type TEXT NOT NULL,
    reading_value NUMERIC(10, 2)
) PARTITION BY RANGE (timestamp);

CREATE TABLE sensor_data_2024_01_01 PARTITION OF sensor_data
    FOR VALUES FROM ('2024-01-01 00:00:00') TO ('2024-01-02 00:00:00')
    PARTITION BY LIST (device_type);

Løsning: Spesialiserte indekser

For å håndtere de ulike IoT-spørringene ble det brukt en kombinasjon av spesialiserte indekser:

BRIN-indeks på tidsstempel: For intervallspørringer på tid er BRIN (Block Range Index) svært effektiv på naturlig ordnede data og har et lite plassbehov.
B-Tree-indeks på enhets-ID: Lokale B-tree-indekser på device_id i hver underpartisjon sikrer raske oppslag for bestemte enheter.
GIN-indeks for tagger: Hvis enhetene har tilknyttede tagger (for eksempel tags JSONB), kan en GIN-indeks gjøre spørringer i disse JSONB-feltene raskere.

CREATE INDEX brin_idx_sensor_data_time
ON sensor_data USING BRIN (timestamp);

CREATE INDEX btree_idx_sensor_data_device_id
ON sensor_data_2024_01_01_sensor (device_id);

-- Example for a JSONB column
-- CREATE INDEX gin_idx_sensor_data_tags
-- ON sensor_data USING GIN (tags jsonb_path_ops);

Resultat av IoT-kasusstudien

Den kombinerte strategien for IoT-data ga betydelige forbedringer:

Data-inntakshastigheten ble opprettholdt på toppnivå uten forringelse av ytelsen.
Analytiske spørringer som omfattet store tidsintervaller, ble optimalisert ved hjelp av partisjonsbeskjæring og BRIN-indekser.
Oppslag etter bestemte enheter eller søk basert på tagger ble svært effektive takket være lokale B-tree- og GIN-indekser.

Denne fremgangsmåten ga både høy skrivekapasitet og fleksibel leseytelse.

Bruk kunnskapen din

Basert på kasusstudiene: Hvilke viktige hensyn må De ta når De utformer en strategi for indeksering og partisjonering av PostgreSQL-databaser i stor skala?

Besvar den i den interaktive leksjonen

Oppsummering: Lærdom fra kasusstudiene

I denne leksjonen utforsket vi to virkelige casestudier som demonstrerer kraften i å kombinere PostgreSQL-indeksering og partisjonering:

Netthandel: Det ble brukt områdepartisjonering etter dato med lokale B-tree-indekser for historiske ordredata, noe som forbedret spørringshastigheten og gjorde administrasjonen enklere.
IoT-data: Det ble brukt hybridpartisjonering (område etter tid, liste etter enhetstype) sammen med spesialiserte indekser som BRIN, B-tree og GIN for store datamengder og varierte spørringer.

Disse eksemplene viser at den beste strategien ofte innebærer en gjennomtenkt kombinasjon av teknikker, tilpasset de spesifikke dataene og arbeidsbelastningen.

Gratis å komme i gang

Lær deg Avansert PostgreSQL: Indeksering, partisjonering og replikering med en AI-veileder – gratis

Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.

Kurs: 11
Leksjoner: 44

Start læringen gratis Se hele kurset

Ofte stilte spørsmål

Er leksjonen «Praktiske eksempler fra virkeligheten» gratis?

Ja – hele teksten i «Praktiske eksempler fra virkeligheten» er gratis å lese her på nettet. For å øve interaktivt med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt, og for å låse opp resten av Avansert PostgreSQL: Indeksering, partisjonering og replikering-kurset, kan du oppgradere til CoddyKit PRO. Kurset i Avansert PostgreSQL: Indeksering, partisjonering og replikering inneholder totalt 4 leksjoner.

Hva lærer jeg i «Praktiske eksempler fra virkeligheten»?

Undersøk praktiske eksempler og lær av vellykkede implementeringer av indeksering og partisjonering i storskala systemer. Du øver på Avansert PostgreSQL: Indeksering, partisjonering og replikering med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.

Trenger jeg erfaring for å begynne med Avansert PostgreSQL: Indeksering, partisjonering og replikering?

Ingen tidligere erfaring er nødvendig. Avansert PostgreSQL: Indeksering, partisjonering og replikering på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 3 av 4.

Hvor lang tid tar leksjonen «Praktiske eksempler fra virkeligheten»?

De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.

Kan jeg skrive og kjøre kode i denne Avansert PostgreSQL: Indeksering, partisjonering og replikering-leksjonen?

Ja. Alle Avansert PostgreSQL: Indeksering, partisjonering og replikering-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.

Alle leksjonene i dette kurset

Skalere indekser med partisjonering
Velge strategier for indekser og partisjonering
Praktiske eksempler fra virkeligheten
BRIN-indekser for store partisjonerte tabeller

← Tilbake til Avansert PostgreSQL: Indeksering, partisjonering og replikering