{"canonical_url":"https://engineer.company/nb/glossary/etl/","content_markdown":"# ETL\n\n## Hva det er\n\nBokstavene i ETL står for extract, transform, load, på norsk uttrekk, transformering og lasting.\nSammen beskriver de arbeidet med å kopiere data ut av systemene som skaper dem, gi dem den formen og\nbetydningen et annet system forventer, og skrive dem inn der, som oftest i et datavarehus. En nær\nvariant, ELT, beholder de tre stegene, men laster rådataene først og transformerer dem inne i\nmålsystemet, og mange team skriver ETL/ELT for å dekke begge.\n\nHver bokstav er en egen jobb. Uttrekket leser fra en kilde: en hel tabell, en eksportfil, et API,\neller bare radene som er endret siden forrige kjøring, funnet gjennom et tidsstempel som\n`updated_at` eller gjennom change data capture (CDC), som leser databasens egen oversikt over hver\nendring. Transformeringen er der dataene renses og avstemmes: tekst blir til datoer og tall, enheter\nog tidssoner gjøres ensartede, duplikater fjernes, koder slås opp mot referansetabeller, og\nresultatet formes om til modellen målsystemet bruker, f.eks. fakta- og dimensjonstabeller. Lastingen\nskriver resultatet, enten som en masseinnsetting i en tom tabell eller som en sammenslåing (merge)\nsom oppdaterer radene som allerede finnes, og legger til de nye.\n\nRekkefølgen på de to siste stegene avgjør hvor arbeidet gjøres. Klassisk ETL transformerer på en\negen server før noe når målsystemet, og det ga mening den gang datalagring og regnekraft i et\ndatavarehus var knappe og dyre. ELT legger rådataene i mellomtabeller (staging-tabeller) inne i\nmålsystemet og kjører transformeringen der, i SQL. Råkopien blir værende, så når en regel endres,\nkan transformeringen kjøres på nytt over hele historikken uten et nytt uttrekk. Prisen er at alt\nkilden sendte, også kolonner ingen ba om, nå ligger i datavarehuset og må forvaltes der.\n\nPostgreSQL dekker hvert steg med egne verktøy. `COPY` flytter rader mellom en tabell og en fil i\ntekst-, CSV- eller binærformat og er den raskeste veien inn. For å lese en fil på selve serveren må\ndu være superbruker eller ha rollen `pg_read_server_files`, mens psql-kommandoen `\\copy` i stedet\nleser filen på klienten. `INSERT ... ON CONFLICT` og `MERGE` fletter nye rader inn i dem som\nallerede finnes. Logisk dekoding gjør write-ahead-loggen (WAL) om til en strøm av radendringer for\nCDC, og en prosedyre i PL/pgSQL kan holde transformeringen tett ved dataene den endrer.\n\n## Hvorfor det er viktig\n\nDe fleste spørsmål som er verdt å stille om en virksomhet, krever data fra mer enn ett system.\nOrdrene ligger i én database, betalingene i en eksport fra en leverandør, kundeopplysningene i et\nkundesystem (CRM). Inntil noe flytter dem til ett sted under ett sett regler, blir hvert svar satt\nsammen for hånd, og fremgangsmåten varierer med personen som gjør jobben. ETL er det som flytter dem, og et\ndatavarehus er bare så riktig som lastingene som fyller det.\n\nTransformeringssteget er også der en virksomhet skriver ned hva dataene betyr. Hvilke rader som\nteller som et salg, hvilken dag en betaling ved midnatt hører til, hvilken post som vinner når to\nkunder ser ut til å være den samme: avgjort én gang i lastingen gjelder svaret for hver rapport\nlenger ut i kjeden. Overlatt til hver enkelt rapport glir svarene fra hverandre, og to dashbord\nviser to forskjellige summer.\n\nMåten en lasting henter ut data på, avgjør hvordan den vokser. En full omlasting kopierer alt hver\ngang. Den er enkel og retter seg selv, siden gårsdagens feil blir overskrevet i natt, men kostnaden\nstiger med den samlede datamengden. En inkrementell lasting flytter bare det som er endret, så der\nstiger kostnaden i stedet med endringstakten. Den må huske hvor forrige kjøring stoppet, merke seg\nrader som er slettet i kilden, og ta imot rader som kommer sent med gamle tidsstempler. De fleste\nsystemer begynner med fulle omlastinger og bytter over, tabell for tabell, når natten ikke lenger er\nlang nok.\n\nDen løpende kostnaden er at lastinger er kode som kjører uten tilsyn, som regel om natten, mot\nkilder som endres uten forvarsel. De trenger logging som forteller hva som kjørte og hvor mange\nrader som ble flyttet, et driftsvarsel når en kjøring stopper, og framfor alt én egenskap: en\nkjøring som gjentas med de samme inndataene, skal etterlate målet nøyaktig slik én kjøring ville\ngjort. En lasting med den egenskapen er idempotent, og den kan kjøres på nytt etter hvilken som\nhelst feil uten at noen må sjekke noe først.\n\n## Slik ser det ut i praksis\n\nFragmenterte pipeliner forsinket forretningskritisk rapportering på tvers av flere utviklings- og produksjonsmiljøer i PostgreSQL, og [600 ETL/ELT-pipeliner ble skrevet i PL/pgSQL](/nb/portfolio/engineered-600-pl-pgsql-etl-elt-pipelines/) for å erstatte dem: ETL i en skala på flere hundre rutinemessige lastinger. Primær- og fremmednøkkelbegrensninger ivaretok referanseintegriteten under transformasjonene, unike og sammensatte indekser støttet join-operasjonene, og unntakshåndtering med transaksjonskontroll rullet en kjøring tilbake når den gikk galt. Inkrementelle lastinger brukte CDC og tidsstempelbaserte deltaer, og logging og revisjon av kjøringer støttet sporing og feilsøking. Leveransen omfatter transformasjonslogikk, integritetsregler, inkrementell lasting og kjøringslogging; dokumentasjonen fastslår ingen sammenlignende ytelsesmåling eller beregning av feilrate.\n\nEn migrering mellom databaser er ETL som kjører én gang. Å flytte en kartapplikasjon fra Microsoft\nSQL Server til PostgreSQL med PostGIS betydde å føre\n[over 50 millioner romlige poster gjennom ETL-pipeliner](/nb/portfolio/improved-gis-map-performance-10x-on-postgresql/)\nmed transformasjonssteg som gjorde om hver eneste koordinat til referansesystemet EPSG:4326. Romlige\nspørringer fikk ti ganger bedre ytelse av migreringen som helhet, der ETL-jobben virket sammen med\nGiST- og SP-GiST-indekser og en justert konfigurasjon på den nye siden: svartiden, i snitt 2,5\nsekunder før, havnet under 250 millisekunder, og CPU-belastningen i backend falt med 65 %.\n\nOver en nettverksgrense viser\n[seks ETL/ELT-pipeliner](/nb/portfolio/designed-and-ran-6-etl-elt-pipelines/)\nalle bokstavene i navnet i arbeid. Uttrekket besto av planlagte nedlastinger av komprimerte arkiver\nfra en server som bare kunne nås gjennom et IPsec-VPN, med Bash- og Python-skript som sorterte\nParquet-, CSV- og .bak-filene i dem etter type og skjema, og .bak-sikkerhetskopiene ble\ngjenopprettet i en lokal MSSQL Server-instans. Dataene ble lastet inn i staging-skjemaer i MSSQL og\nPostgreSQL med bcp, psql eller SSIS, alt etter formatet, så renset, normalisert og beriket av\nprosedyrer i PL/pgSQL og T-SQL, og til slutt komprimert med gzip og fraktet gjennom en Google Cloud\nStorage-bucket inn i Google BigQuery. Arbeid som hadde tatt minst tre timer for hånd, kjørte på\nunder 20 minutter fra ende til ende, og synkroniseringen gikk fra ukentlig til daglig.\n\n## Hvor det går galt\n\n**En kjøring som startes på nytt, laster de samme radene to ganger.** En jobb setter inn med vanlig\n`INSERT`, stopper halvveis på en nettverksfeil, og jobbplanleggeren kjører den på nytt fra starten.\nRadene som kom inn første gang, ligger nå der to ganger, og hver sum som bygger på dem, blir for\nhøy. Gi målet en nøkkel som identifiserer en rad i forretningstermer, og flett inn partiet med\n`INSERT ... ON CONFLICT DO UPDATE`, som PostgreSQL dokumenterer som en atomisk innsetting eller\noppdatering også ved høy samtidighet, eller med `MERGE`. Én hake finnes: en enkelt `ON CONFLICT DO\nUPDATE`-setning nekter å endre den samme raden to ganger og gir et kardinalitetsbrudd (cardinality\nviolation), så et parti med gjentatte nøkler må først reduseres til én rad per nøkkel.\n\n```sql\nINSERT INTO meter_reading (meter_id, read_at, kwh)\nSELECT DISTINCT ON (meter_id, read_at) meter_id, read_at, kwh\nFROM staging_meter_reading\nORDER BY meter_id, read_at, received_at DESC\nON CONFLICT (meter_id, read_at)\nDO UPDATE SET kwh = EXCLUDED.kwh;\n```\n\n**En masselasting stopper nær slutten og etterlater disken fullere enn før.** `COPY FROM` skriver\nrader inn i tabellen etter hvert som den leser dem. Når den stopper på en dårlig rad, blir radene\nden allerede har skrevet, liggende igjen i slettet tilstand, usynlige for spørringer, men fortsatt\npå disken til `VACUUM` tar plassen tilbake, og en feil sent i en stor fil kan sløse bort mye plass.\nPostgreSQL 17 la til `ON_ERROR ignore`, som hopper over rader i tekst- eller CSV-inndata der\nverdiene ikke lar seg konvertere til kolonnens type, og PostgreSQL 18 la til `REJECT_LIMIT` for å\nsette et tak på hvor mange rader den kan hoppe over. Det dekker bare typekonvertering; en rad som\nbryter en begrensning, stopper fortsatt kommandoen. Last inn i en mellomtabell først, sjekk dataene\nder, og flytt de gode radene inn i den virkelige tabellen i én transaksjon, så holdes en dårlig fil\nunna dataene folk leser.\n\n**Change data capture fyller disken.** Logisk dekoding leser endringer gjennom et replikeringsspor\n(replication slot), og et slikt spor holder på hver bit av write-ahead-loggen som mottakeren\nfortsatt trenger, enten en mottaker er koblet til eller ikke. Når leseren stopper, hoper loggen seg\nopp til disken er full, og i ytterste konsekvens slår serveren seg av for å hindre omløp av\ntransaksjons-ID-ene (transaction ID wraparound). PostgreSQL-dokumentasjonen sier det rett ut: et\nspor som ikke lenger trengs, skal fjernes. Etter et krasj kan et spor også sende nylige endringer én\ngang til, så mottakeren må tåle duplikater, og det er den samme egenskapen ved nye kjøringer igjen.\n\n**Morgenens første rapport er treg etter en stor lasting.** Spørringsplanleggeren velger hvordan en\nspørring skal kjøres, ut fra statistikk om hver tabell, og en masselasting endrer dataene under den\nstatistikken. Autovacuum kan oppdatere statistikken på egen hånd, men ikke alltid før den første\nrapporten kjører. Å kjøre `ANALYZE` som siste steg i lastingen løser det. For svært store lastinger\ninn i en eksisterende tabell legger PostgreSQL-veiledningen om å fylle en database til at det kan\nlønne seg å fjerne indekser og fremmednøkler og opprette dem på nytt etterpå, fordi det går raskere\nå bygge dem samlet enn å oppdatere dem rad for rad. Da gir du fra deg feilsjekkingen mens de er\nborte, så en unik indeks fortjener en ekstra tanke før den fjernes.\n\n## Les mer\n\n- [COPY](https://www.postgresql.org/docs/current/sql-copy.html) — kommandoen for masselasting,\n  formatene og opsjonene, og hva en mislykket lasting etterlater seg.\n- [Populating a Database](https://www.postgresql.org/docs/current/populate.html)\n  — rådene fra PostgreSQL for store lastinger, fra én transaksjon og `COPY` til å bygge indekser på\n  nytt og kjøre `ANALYZE` etterpå.\n- [MERGE](https://www.postgresql.org/docs/current/sql-merge.html) — innsetting, oppdatering og\n  sletting i én setning, styrt av hvordan hver kilderad passer med målet.\n- [INSERT](https://www.postgresql.org/docs/current/sql-insert.html) — leddet `ON CONFLICT`, den\n  atomiske upserten og regelen mot å røre den samme raden to ganger.\n- [Logical Decoding Concepts](https://www.postgresql.org/docs/current/logicaldecoding-explanation.html)\n  — hvordan endringer leses fra write-ahead-loggen, og hvorfor et replikeringsspor som ikke brukes,\n  må fjernes.\n\n\u003chttps://engineer.company/nb/glossary/etl/\u003e\n","date_modified":"2026-11-12T05:34:23Z","description":"Uttrekk, transformering og lasting: stegene som fyller et datavarehus, når det lønner seg å laste først, og fire måter en nattlig lasting går galt på.","formats":{"gemtext":"https://engineer.company/nb/glossary/etl/index.gmi","gopher":"https://engineer.company/nb/glossary/etl/gophermap","html":"https://engineer.company/nb/glossary/etl/","json":"https://engineer.company/nb/glossary/etl/index.json","markdown":"https://engineer.company/nb/glossary/etl/index.md","pdf":"https://engineer.company/nb/glossary/etl/index.pdf"},"kind":"page","language":"nb","title":"Hva er ETL?","url":"https://engineer.company/nb/glossary/etl/","version":1}