{"canonical_url":"https://engineer.company/sv/glossary/etl/","content_markdown":"# ETL\n\n## Vad det är\n\nETL, kort för extract, transform, load, alltså extrahera, transformera och ladda, är arbetet med att\nkopiera data ut ur de system som skapar dem, ge dem den form och betydelse som ett annat system\nförväntar sig och skriva in dem där, oftast i ett analysdatalager. En nära variant, ELT, behåller\nde tre stegen men laddar först rådata och transformerar dem inuti målsystemet, och många team\nskriver ETL/ELT för att täcka båda.\n\nVarje bokstav är ett eget jobb. Extraheringen läser från en källa: en hel tabell, en exportfil, ett\nAPI, eller bara de rader som har ändrats sedan förra körningen, som hittas genom en tidsstämpel i\n`updated_at` eller genom change data capture (CDC), som läser databasens egen förteckning över varje\nändring. Transformeringen är där data rensas och stäms av: text görs om till datum och tal, enheter\noch tidszoner görs enhetliga, dubbletter tas bort, koder slås upp mot referenstabeller, och\nresultatet formas om till den modell som målet använder, t.ex. fakta- och dimensionstabeller.\nLaddningen skriver resultatet, antingen som en massinsättning i en tom tabell eller som en\nsammanslagning som uppdaterar de rader som redan finns och lägger till de nya.\n\nOrdningen mellan de två sista stegen avgör var arbetet körs. Klassisk ETL transformerar på en\nseparat server innan något når målet, vilket var rimligt när lagring och beräkningskraft i\nanalysdatalagret var knappa och dyra. ELT lägger rådata i mellanlagringstabeller, så kallade\nstaging-tabeller, inuti målet och kör transformeringen där i SQL. Råkopian finns kvar, så när en\nregel ändras kan transformeringen köras om över historiken utan att den behöver extraheras en gång\ntill. Priset är att allt som källan skickade, även kolumner som ingen bad om, nu bor i\nanalysdatalagret och måste förvaltas där.\n\nPostgreSQL täcker varje steg med egna verktyg. `COPY` flyttar rader mellan en tabell och en fil i\ntext-, CSV- eller binärformat och är den snabbaste vägen in. Att läsa en fil på servern kräver\nsuperanvändarrättigheter eller rollen `pg_read_server_files`, medan psql-kommandot `\\copy` i stället\nläser filen på klienten. `INSERT ... ON CONFLICT` och `MERGE` fogar in nya rader i befintliga.\nLogisk avkodning gör om transaktionsloggen, write-ahead log, till en ström av radändringar för CDC,\noch en procedur i PL/pgSQL kan hålla transformeringen nära de data den ändrar.\n\n## Varför det spelar roll\n\nDe flesta frågor som är värda att ställa till en verksamhet behöver data från mer än ett system.\nOrdrar ligger i en databas, betalningar i en export från en leverantör, kunduppgifter i ett\nCRM-system. Tills något flyttar dem till ett och samma ställe under ett och samma regelverk sätts\nvarje svar ihop för hand, och tillvägagångssättet varierar med personen som gör jobbet. ETL är det där något, och\nett analysdatalager är bara så korrekt som de laddningar som fyller det.\n\nTransformeringssteget är också där en verksamhet skriver ned vad dess data betyder. Vilka rader som\nräknas som en försäljning, vilken dag en betalning vid midnatt hör till, vilken post som vinner när\ntvå kunder matchar: avgjort en gång i laddningen gäller svaret för varje rapport längre ned i\nkedjan. Lämnas frågan åt varje rapport glider svaren isär, och två dashboards visar två olika\nsummor.\n\nHur en laddning extraherar avgör hur den växer. En full omladdning kopierar allt varje gång. Den är\nenkel och rättar sig själv, eftersom gårdagens misstag skrivs över i natt, men kostnaden växer med\nden totala datamängden. En inkrementell laddning flyttar bara det som har ändrats, så kostnaden\nväxer i stället med ändringstakten. Den måste komma ihåg var förra körningen slutade, märka rader\nsom har raderats i källan och ta emot rader som kommer sent med gamla tidsstämplar. De flesta\nsystem börjar med fulla omladdningar och byter tabell för tabell när natten inte längre räcker till.\n\nDen löpande kostnaden är att laddningar är kod som körs utan tillsyn, oftast på natten, mot källor\nsom ändras utan förvarning. De behöver loggning som säger vad som kördes och hur många rader som\nflyttades, larm när en körning stannar, och framför allt en egenskap: en körning som upprepas med\nsamma indata ska lämna målet exakt som en enda körning skulle ha gjort. En laddning med den\negenskapen kan köras om efter vilket avbrott som helst utan att någon först behöver undersöka läget.\n\n## Så ser det ut i praktiken\n\n600 pipelines, en migrering som kördes en enda gång och sex laddningar genom ett VPN: samma\ntre steg återkommer här i mycket olika skala.\n\nFragmenterade pipelines försenade affärskritisk rapportering i flera\nutvecklings- och produktionsmiljöer för PostgreSQL, och [600 ETL/ELT-pipelines\nskrevs i PL/pgSQL](/sv/portfolio/engineered-600-pl-pgsql-etl-elt-pipelines/) för\natt ersätta dem: ETL i en skala av hundratals rutinmässiga laddningar. Villkor\nför primärnycklar och främmande nycklar skyddade referensintegriteten under\ntransformeringarna, unika och sammansatta index stödde JOIN-operationerna, och\nundantagshantering med transaktionsstyrning rullade tillbaka en körning när\nnågot gick snett. Inkrementella laddningar använde CDC och tidsstämpelbaserade\ndeltan, och loggning och granskning av körningar stödde spårning och felsökning.\nDet levererade arbetet omfattar transformeringslogik, integritetsvillkor,\ninkrementell laddning och loggning av körningar; beskrivningen fastställer inte\nnågot jämförande prestandatest eller någon beräkning av felfrekvensen.\n\nEn migrering är ETL som körs en gång. Att flytta en kartapplikation från Microsoft SQL Server till\nPostgreSQL med PostGIS innebar att föra\n[över 50 miljoner spatiala poster genom ETL-pipelines](/sv/portfolio/improved-gis-map-performance-10x-on-postgresql/)\nvars transformeringssteg räknade om varje koordinat till referenssystemet EPSG:4326. På den nya\nsidan fanns index av typerna GiST och SP-GiST och en finjusterad konfiguration. Migreringen som\nhelhet gav tio gånger bättre prestanda för spatiala databasfrågor och 65 % lägre processorbelastning\ni backend, och i genomsnitt kom svaren på under 250 millisekunder, mot 2,5 sekunder före flytten.\n\nÖver en nätverksgräns visar\n[sex ETL/ELT-pipelines](/sv/portfolio/designed-and-ran-6-etl-elt-pipelines/)\nvarje bokstav i namnet i arbete. Extraheringen bestod av schemalagda nedladdningar av komprimerade\narkiv från en server som bara gick att nå genom ett IPsec-VPN, där skript i Bash och Python\nsorterade filerna i Parquet, CSV och .bak efter typ och schema, och säkerhetskopiorna i .bak\nåterställdes till en lokal MSSQL-instans. Data lästes in i staging-scheman i MSSQL och\nPostgreSQL med bcp, psql eller SSIS beroende på formatet, rensades, normaliserades och berikades av\nprocedurer i PL/pgSQL och T-SQL, komprimerades sedan med gzip och fördes via en bucket i Google\nCloud Storage till Google BigQuery. Arbete som hade tagit minst tre timmar för hand gick på under\n20 minuter från början till slut, och synkroniseringen gick från veckovis till daglig.\n\n## Var det går fel\n\n**En omkörning laddar samma rader två gånger.** Ett jobb gör vanliga `INSERT`, stannar halvvägs på\nett nätverksfel, och schemaläggaren kör det igen från början. Rader som kom in första gången finns\nnu två gånger, och varje summa som bygger på dem blir för hög. Ge målet en nyckel som identifierar\nen rad i verksamhetens termer och foga in batchen med `INSERT ... ON CONFLICT DO UPDATE`, som\nPostgreSQL dokumenterar som en atomisk infogning eller uppdatering även vid hög samtidighet, eller\nmed `MERGE`. En hake finns: en enskild sats med `ON CONFLICT DO UPDATE` vägrar ändra samma rad två\ngånger och ger ett kardinalitetsfel, så en batch med upprepade nycklar måste först reduceras till\nen rad per nyckel.\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 massladdning stannar nära slutet och lämnar disken fullare än förut.** `COPY FROM` skriver\nrader till tabellen allteftersom. När kommandot stannar på en dålig rad blir de raderna kvar i\nraderat tillstånd, osynliga för databasfrågor men kvar på disken tills `VACUUM` återvinner dem, och\nett avbrott sent i en stor fil kan slösa mycket utrymme. PostgreSQL 17 lade till `ON_ERROR ignore`,\nsom hoppar över rader i text- eller CSV-indata vars värden inte går att konvertera till kolumnens\ntyp, och PostgreSQL 18 lade till `REJECT_LIMIT` för att begränsa hur många rader som får hoppas\növer. Det täcker bara typkonvertering; en rad som bryter mot ett villkor stoppar fortfarande\nkommandot. Att först ladda in i en staging-tabell, kontrollera den där och flytta de bra raderna\ntill den riktiga tabellen i en enda transaktion håller en dålig fil borta från de data som folk\nläser.\n\n**Change data capture fyller disken.** Logisk avkodning läser ändringar genom en replikeringsslot,\noch en slot behåller varje del av transaktionsloggen som dess konsument fortfarande behöver, oavsett\nom en konsument är ansluten eller inte. När läsaren stannar hopar sig loggen tills disken är full,\noch i extrema fall stänger servern av sig själv för att förhindra wraparound av transaktions-id.\nDokumentationen för PostgreSQL är tydlig: en slot som inte längre behövs ska tas bort. Efter en\nkrasch kan en slot också skicka nyliga ändringar en gång till, så konsumenten måste tåla\ndubbletter, alltså samma krav på säkra omkörningar som ovan.\n\n**Morgonens första rapport är långsam efter en stor laddning.** Planeraren väljer hur en\ndatabasfråga ska köras utifrån statistik om varje tabell, och en massladdning ändrar datan under\nstatistiken. Autovacuum kan uppdatera statistiken på egen hand, men inte alltid innan den första\nrapporten körs. Att köra `ANALYZE` som laddningens sista steg löser det. För mycket stora\nladdningar till en befintlig tabell tillägger guiden från PostgreSQL om att fylla en databas att det\nkan löna sig att ta bort index och främmande nycklar och skapa dem igen efteråt, eftersom det går\nsnabbare att bygga dem i ett svep än att uppdatera dem rad för rad. Under tiden kontrolleras\nvillkoren inte, så ett unikt index förtjänar en extra tanke innan det tas bort.\n\n## Läs mer\n\n- [COPY](https://www.postgresql.org/docs/current/sql-copy.html) — kommandot för massladdning, dess\n  format och inställningar, och vad en misslyckad laddning lämnar efter sig.\n- [Populating a Database](https://www.postgresql.org/docs/current/populate.html) — råden från\n  PostgreSQL för stora laddningar, från en enda transaktion och `COPY` till att bygga om index och\n  köra `ANALYZE` efteråt.\n- [MERGE](https://www.postgresql.org/docs/current/sql-merge.html) — infogning, uppdatering och\n  borttagning i en och samma sats, styrd av hur varje rad i källan matchar målet.\n- [INSERT](https://www.postgresql.org/docs/current/sql-insert.html) — satsdelen `ON CONFLICT`, dess\n  atomiska upsert och regeln mot att röra samma rad två gånger.\n- [Logical Decoding Concepts](https://www.postgresql.org/docs/current/logicaldecoding-explanation.html)\n  — hur ändringar läses ur transaktionsloggen och varför en oanvänd replikeringsslot måste bort.\n\n\u003chttps://engineer.company/sv/glossary/etl/\u003e\n","date_modified":"2026-11-12T05:34:23Z","description":"Vad ETL betyder, när ELT slår att transformera först och hur en nattlig laddning till ett analysdatalager räknar rader dubbelt eller fyller disken.","formats":{"gemtext":"https://engineer.company/sv/glossary/etl/index.gmi","gopher":"https://engineer.company/sv/glossary/etl/gophermap","html":"https://engineer.company/sv/glossary/etl/","json":"https://engineer.company/sv/glossary/etl/index.json","markdown":"https://engineer.company/sv/glossary/etl/index.md","pdf":"https://engineer.company/sv/glossary/etl/index.pdf"},"kind":"page","language":"sv","title":"Vad är ETL?","url":"https://engineer.company/sv/glossary/etl/","version":1}