{"canonical_url":"https://engineer.company/da/glossary/etl/","content_markdown":"# ETL\n\n## Hvad det er\n\nETL, en forkortelse af extract, transform, load, er arbejdet med at kopiere data\nud af de systemer, der skaber dem, give dem den form og betydning, et andet\nsystem forventer, og skrive dem dertil, som regel ind i et datawarehouse. En nær\nvariant, ELT, beholder de tre trin, men indlæser rådata først og transformerer\ndem inde i målet, og mange skriver ETL/ELT for at dække begge.\n\nHvert bogstav er et selvstændigt stykke arbejde. Udtrækket læser fra en kilde:\nen hel tabel, en eksportfil, et API eller kun de rækker, der er ændret siden\nsidste kørsel, fundet via et `updated_at`-tidsstempel eller via change data\ncapture (CDC), som læser databasens egen log over hver ændring. Transformationen\ner der, hvor data renses og afstemmes: tekst bliver til datoer og tal, enheder\nog tidszoner gøres ensartede, dubletter fjernes, koder slås op i\nreferencetabeller, og resultatet formes om til den model, målet bruger, for\neksempel fakta- og dimensionstabeller. Indlæsningen skriver resultatet, enten\nsom en masseindsættelse i en tom tabel eller som en fletning, der opdaterer de\nrækker, der allerede findes, og tilføjer de nye.\n\nRækkefølgen af de to sidste trin afgør, hvor arbejdet foregår. Klassisk ETL\ntransformerer på en separat server, før noget når målet, og det gav mening,\ndengang lagerplads og regnekraft i et datawarehouse var knappe og dyre. ELT\nlægger rådata i staging-tabeller inde i målet og kører transformationen dér i\nSQL. Råkopien bliver liggende, så når en regel ændres, kan transformationen\nkøres igen over hele historikken uden et nyt udtræk. Prisen er, at alt, hvad\nkilden sendte, også kolonner, ingen har bedt om, nu ligger i datawarehouset og\nskal styres dér.\n\nPostgreSQL har et værktøj til hvert trin. `COPY` flytter rækker mellem en tabel\nog en fil i tekst-, CSV- eller binært format og er den hurtigste vej ind. At\nlæse en fil på serveren kræver superbrugerrettigheder eller rollen\n`pg_read_server_files`, mens psql-kommandoen `\\copy` læser filen på klienten i\nstedet. `INSERT ... ON CONFLICT` og `MERGE` fletter nye rækker ind i de\neksisterende. Logisk dekodning gør write-ahead-loggen til en strøm af\nrækkeændringer til CDC, og en PL/pgSQL-procedure kan holde transformationen tæt\npå de data, den ændrer.\n\n## Hvorfor det betyder noget\n\nDe fleste spørgsmål, der er værd at stille i en virksomhed, kræver data fra mere\nend ét system. Ordrerne ligger i én database, betalingerne i en udbyders\neksport, kunderne i et CRM. Indtil noget samler dem ét sted under ét sæt regler,\nbliver hvert svar stykket sammen i hånden, og svaret afhænger af, hvem der\nstykker det sammen. ETL er det, der samler dem, og en fejl i indlæsningen går videre til\nhver rapport, der bygger på den.\n\nTransformationen er også stedet, hvor en virksomhed skriver ned, hvad dens data\nbetyder. Hvilke rækker tæller som et salg, hvilken dag en betaling ved midnat\nhører til, hvilken post der vinder, når to kunder ligner hinanden: afgøres det\nén gang i indlæsningen, gælder svaret for hver eneste rapport bagefter.\nOverlades det til hver rapport, glider svarene fra hinanden, og to dashboards\nviser to totaler.\n\nMåden, en indlæsning udtrækker på, bestemmer, hvordan den vokser. En fuld\ngenindlæsning kopierer alt hver gang. Den er enkel og retter sig selv, fordi\ngårsdagens fejl bliver overskrevet i nat, men prisen stiger med den samlede\ndatamængde. En inkrementel indlæsning flytter kun det, der er ændret, så prisen\ni stedet stiger med ændringstakten. Den skal huske, hvor sidste kørsel stoppede,\nopdage rækker, der er slettet i kilden, og tage imod rækker, der kommer sent med\ngamle tidsstempler. De fleste systemer begynder med fulde genindlæsninger og\nskifter tabel for tabel, når natten ikke længere er lang nok.\n\nDen løbende pris er, at indlæsninger er kode, der kører uden opsyn, som regel om\nnatten, mod kilder, der ændrer sig uden varsel. De har brug for logning, der\nviser, hvad der kørte, og hvor mange rækker der flyttede sig, alarmer, når en\nkørsel stopper, og frem for alt én egenskab: en kørsel, der gentages med samme\ninput, skal efterlade målet præcis, som én kørsel ville. En indlæsning med den\negenskab kan startes igen efter enhver fejl, uden at nogen behøver at tjekke\nførst.\n\n## Sådan ser det ud i praksis\n\nFragmenterede pipelines forsinkede forretningskritisk rapportering\npå tværs af flere PostgreSQL-udviklings- og produktionsmiljøer, og\n[600 ETL/ELT-pipelines blev udviklet i PL/pgSQL](/da/portfolio/engineered-600-pl-pgsql-etl-elt-pipelines/)\nfor at afløse dem: ETL i en skala af hundredvis af rutinemæssige\nindlæsninger. Primary- og foreign key-constraints bevarede den\nreferentielle integritet under transformationer, unikke og\nsammensatte indeks understøttede joins, og exception handling med\ntransaktionskontrol rullede en kørsel tilbage, når noget gik galt.\nInkrementelle indlæsninger brugte CDC og tidsstempelbaserede deltaer,\nog logning og revision af kørsler understøttede sporing og\nfejlsøgning. Det leverede arbejde omfatter transformationslogik,\nconstraints, inkrementel indlæsning og logning af kørsler;\nbeskrivelsen dokumenterer ikke et sammenlignende benchmark eller\nen beregning af fejlprocenten.\n\nEn migrering er ETL, der kører én gang. At flytte en kortapplikation fra\nMicrosoft SQL Server til PostgreSQL med PostGIS betød, at\n[over 50 millioner spatiale records gik gennem ETL-pipelines](/da/portfolio/improved-gis-map-performance-10x-on-postgresql/),\nhvis transformationstrin konverterede hver koordinat til referencesystemet\nEPSG:4326. Migreringen som helhed, med GiST- og SP-GiST-indeks og en tunet\nkonfiguration på den nye side, gjorde de spatiale forespørgsler ti gange\nhurtigere: hvor et svar før tog 2,5 sekunder i gennemsnit, kom det nu på under\n250 millisekunder, og backendens CPU-belastning faldt med 65 %.\n\nPå tværs af en netværksgrænse er hvert bogstav i navnet i brug i\n[seks ETL/ELT-pipelines](/da/portfolio/designed-and-ran-6-etl-elt-pipelines/).\nUdtrækket bestod af planlagte downloads af komprimerede arkiver fra en server,\nder kun kunne nås gennem en IPsec VPN, hvor Bash- og Python-scripts pakkede\nParquet-, CSV- og .bak-filerne ud og klassificerede dem, og .bak-filerne blev\ngendannet i en lokal MSSQL Server-instans. Dataene blev lagt i staging-skemaer i\nMSSQL og PostgreSQL med bcp, psql og SSIS, renset og beriget af modulære\nPL/pgSQL- og T-SQL-procedurer og til sidst lagt op i Google BigQuery med bq CLI\nog Python-baseret indtagelse, der også tog sig af skemamappingen. Det, der havde\nværet mindst tre timers manuelt arbejde, tog under 20 minutter fra ende til anden,\nog synkroniseringen gik fra ugentlig til daglig.\n\n## Hvor det går galt\n\n**En kørsel, der startes igen, indlæser de samme rækker to gange.** Et job\nindsætter med almindelig `INSERT`, stopper halvvejs på en netværksfejl, og\nscheduleren kører det igen fra begyndelsen. De rækker, der nåede ind første\ngang, ligger der nu to gange, og hver total bygget på dem er for høj. Giv målet\nen nøgle, der identificerer en række i forretningens termer, og flet batchen ind\nmed `INSERT ... ON CONFLICT DO UPDATE`, som PostgreSQL dokumenterer som en\natomisk indsæt-eller-opdatér selv ved høj samtidighed, eller med `MERGE`. Der er\nén hage: en enkelt `ON CONFLICT DO UPDATE`-sætning nægter at ændre den samme\nrække to gange og melder en cardinality violation, så en batch med gentagne\nnøgler først skal skæres ned til én række pr. nøgle.\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 masseindlæsning stopper tæt på slutningen og efterlader disken mere fyldt\nend før.** `COPY FROM` skriver rækkerne ind i tabellen undervejs. Stopper den på\nen dårlig række, bliver de allerede skrevne rækker liggende i slettet tilstand,\nusynlige for forespørgsler, men stadig på disken, indtil `VACUUM` frigør\npladsen, og et stop sent i en stor fil kan koste meget plads. PostgreSQL 17\ntilføjede `ON_ERROR ignore`, der springer rækker over i tekst- eller CSV-input,\nhvis værdier ikke lader sig konvertere til kolonnens type, og PostgreSQL 18\ntilføjede `REJECT_LIMIT`, der sætter et loft over, hvor mange der må springes\nover. Det dækker kun typekonvertering; en række, der bryder en constraint,\nstopper stadig kommandoen. Indlæs i en staging-tabel først, tjek den dér, og\nflyt de gode rækker over i den rigtige tabel i én transaktion, så holdes en\ndårlig fil væk fra de data, folk læser.\n\n**Change data capture fylder disken.** Logisk dekodning læser ændringer gennem\nen replikeringsslot, og en slot gemmer hvert stykke write-ahead-log, som dens\nforbruger stadig mangler, uanset om en forbruger er forbundet. Holder læseren\nop, hober loggen sig op, til disken er fuld, og i ekstreme tilfælde lukker\nserveren ned for at forhindre transaction ID wraparound.\nPostgreSQL-dokumentationen siger det ligeud: en slot, der ikke længere er brug\nfor, skal droppes. Efter et nedbrud kan en slot også sende de seneste ændringer\nen gang til, så forbrugeren skal kunne tåle dubletter, og det er den samme\ngenkørselsegenskab igen.\n\n**Morgenens første rapport er langsom efter en stor indlæsning.** Planneren\nvælger, hvordan en forespørgsel skal køres, ud fra statistik om hver tabel, og\nen masseindlæsning ændrer dataene under statistikken. Autovacuum kan opdatere\nden af sig selv, men ikke altid før den første rapport kører. At køre `ANALYZE`\nsom sidste trin i indlæsningen løser det. Ved meget store indlæsninger i en\neksisterende tabel tilføjer PostgreSQL-vejledningen om at fylde en database, at\ndet kan betale sig at droppe indeks og fremmednøgler og oprette dem igen\nbagefter, fordi de bygges hurtigere samlet end række for række. Til gengæld\nforsvinder fejlkontrollen, mens de er væk, så et unikt indeks fortjener en\nekstra overvejelse, før det fjernes.\n\n## Læs mere\n\n- [COPY](https://www.postgresql.org/docs/current/sql-copy.html) — kommandoen til\n  masseindlæsning, dens formater og indstillinger, og hvad en afbrudt indlæsning\n  efterlader.\n- [Populating a Database](https://www.postgresql.org/docs/current/populate.html)\n  — PostgreSQL's råd om store indlæsninger, fra én transaktion og `COPY` til at\n  genopbygge indeks og køre `ANALYZE` bagefter.\n- [MERGE](https://www.postgresql.org/docs/current/sql-merge.html) — indsæt,\n  opdatér og slet i én sætning, styret af, hvordan hver kilderække matcher\n  målet.\n- [INSERT](https://www.postgresql.org/docs/current/sql-insert.html)\n  — `ON CONFLICT`-klausulen, dens atomiske upsert og dens regel mod at røre den\n  samme række to gange.\n- [Logical Decoding Concepts](https://www.postgresql.org/docs/current/logicaldecoding-explanation.html)\n  — hvordan ændringer læses fra write-ahead-loggen, og hvorfor en ubrugt\n  replikeringsslot skal væk.\n\n\u003chttps://engineer.company/da/glossary/etl/\u003e\n","date_modified":"2026-11-12T05:34:23Z","description":"Udtræk, transformation og indlæsning: de tre trin, der fylder et datawarehouse, hvornår ELT er bedre, og fire måder, en natlig indlæsning går galt på.","formats":{"gemtext":"https://engineer.company/da/glossary/etl/index.gmi","gopher":"https://engineer.company/da/glossary/etl/gophermap","html":"https://engineer.company/da/glossary/etl/","json":"https://engineer.company/da/glossary/etl/index.json","markdown":"https://engineer.company/da/glossary/etl/index.md","pdf":"https://engineer.company/da/glossary/etl/index.pdf"},"kind":"page","language":"da","title":"Hvad er ETL?","url":"https://engineer.company/da/glossary/etl/","version":1}