{"canonical_url":"https://engineer.company/da/glossary/normalization/","content_markdown":"# Databasenormalisering\n\n## Hvad det er\n\nDatabasenormalisering er praksissen med at indrette en relationel database, så\nhver oplysning gemmes ét sted, i den tabel den beskriver, og alt andet henviser\ntil den med dens nøgle. Man taler også om normalisering af databaser, eller blot\nnormalisering, når sammenhængen gør det klart. En kundes adresse står i én række\ni en kundetabel; en ordre har kun kundens nøgle, og et join samler de to, når en\nforespørgsel har brug for begge.\n\nBåde idéen og ordet kommer fra Edgar F. Codd, der foreslog relationsmodellen i\nCommunications of the ACM i juni 1970. I den artikel betød normalisering ét\nbestemt skridt: at komme af med relationer, der rummer andre relationer, for\neksempel en medarbejderpost med sin egen liste over tidligere stillinger og sin\negen liste over børn. Codds fremgangsmåde kopierer forælderens primærnøgle ind i\nhver indlejret gruppe og løfter gruppen ud i en relation for sig, med\nforælderens nøgle plus det, der identificerer en række inden for gruppen, som\nnøgle. Tilbage står normalform, i dag kendt som første normalform: hver værdi i\nhver kolonne er én enkel værdi.\n\nCodd definerede siden strengere normalformer, blandt dem den, som Ronald Fagins\nartikel fra 1977 kalder Codds forbedrede tredje normalform eller\nBoyce–Codd-normalform. Fagins artikel tilføjer en fjerde. Den bygger på en ny\nslags afhængighed mellem kolonner, den flerværdige afhængighed, der omfatter den\nvelkendte funktionelle afhængighed som et specialtilfælde, og Fagin viste, at\nden fjerde form er strengt stærkere end Boyce–Codd-normalform.\n\nDe strengere former nås ved at dele op. En tabel erstattes af to eller flere af\ndens projektioner, tabeller med nogle af dens kolonner, valgt sådan, at et join\naf dem giver præcis originalen tilbage. Fagins artikel viser, at den garanti\nholder for hans egen form: enhver tabel kan deles op i tabeller på fjerde\nnormalform, uden at der går information tabt, fordi et join af dem genskaber\noriginalen. Denormalisering er det omvendte: med vilje at gemme en kopi af en\noplysning et andet sted, som regel for at spare et join.\n\n## Hvorfor det betyder noget\n\nEn tabel, der gemmer den samme oplysning mange gange, lægger op til tre slags\nproblemer. Forestil dig én række pr. medarbejder og projekt, hvor medarbejderens\nkontor står på hver række. Når nogen skifter kontor, skal flere rækker have den\nnye værdi, og glemmer man én, modsiger databasen sig selv. Når en medarbejders\nsidste projekt slutter, og rækken slettes, forsvinder oplysningen om, hvor\nvedkommende sidder. Og en nyansat, der ikke er på noget projekt, har intet sted\nat notere sit kontor. Det er opdaterings-, sletnings- og\nindsættelsesanomalierne, og deles tabellen i medarbejder–projekt og\nmedarbejder–kontor, forsvinder alle tre.\n\nI et teams daglige arbejde viser de anomalier sig som fejl. En faktura viser den\ngamle adresse, fordi én kopi blev overset. En rapport tæller en kunde to gange,\nfordi navnet blev tastet på to måder. Et normaliseret skema gør den slags fejl\nsvære at skrive i første omgang, og når primærnøgler, fremmednøgler og\ncheck-constraints er erklæret, afviser databasen selv dårlige data i stedet for\nat stole på, at al applikationskoden husker reglerne.\n\nÆndringer bliver også billigere. Et skema, hvor hver tabel beskriver én ting,\ntager som regel imod nye slags data med mindre omstrukturering: det er en mindre\nmigrering at tilføje en kolonne til den ene tabel, der ejer en oplysning, end at\nfinde hver tabel, der har kopieret den.\n\nPrisen er joins. En normaliseret database besvarer de fleste spørgsmål ved at\njoine tabellerne sammen igen, og hvert join er arbejde for serveren. Med indeks\npå de kolonner, der joines på, er det arbejde som regel lille, og derfor bør en\nmålt langsom forespørgsel og ikke en fornemmelse afgøre, hvornår en oplysning\nkopieres tilbage.\n\n## Sådan ser det ud i praksis\n\nEn lille webbutik starter med én flad tabel, indlæst fra et udtræk af et\nregneark:\n\n```sql\nCREATE TABLE order_flat (\n    order_no       integer,\n    ordered_on     date,\n    customer_email text,\n    customer_name  text,\n    customer_city  text,\n    sku            text,\n    product_name   text,\n    unit_price     numeric,\n    quantity       integer,\n    status         text\n);\n```\n\nHver række er én linje i én ordre, så en kundes navn og by gentages på hver\nlinje i hver ordre, og et produkts navn gentages på hver linje, der sælger det.\nEn kunde, der flytter, har snesevis af rækker at opdatere. Sletter man den\nsidste linje, der solgte et produkt, glemmer tabellen, at produktet findes.\nStatus er fri tekst, så `shipped`, `Shipped` og `shipd` kan alle dukke op.\n\nNormaliseret får hver oplysning ét hjem:\n\n```sql\nCREATE TABLE customers (\n    customer_id integer PRIMARY KEY,\n    email       text NOT NULL UNIQUE,\n    name        text NOT NULL,\n    city        text NOT NULL\n);\n\nCREATE TABLE products (\n    sku        text PRIMARY KEY,\n    name       text NOT NULL,\n    list_price numeric NOT NULL CHECK (list_price \u003e= 0)\n);\n\nCREATE TABLE order_status (\n    status_id smallint PRIMARY KEY,\n    label     text NOT NULL UNIQUE\n);\n\nCREATE TABLE orders (\n    order_id    integer PRIMARY KEY,\n    customer_id integer NOT NULL REFERENCES customers ON DELETE RESTRICT,\n    status_id   smallint NOT NULL REFERENCES order_status,\n    ordered_on  date NOT NULL\n);\n\nCREATE TABLE order_lines (\n    order_id   integer REFERENCES orders ON DELETE CASCADE,\n    sku        text NOT NULL REFERENCES products,\n    quantity   integer NOT NULL CHECK (quantity \u003e 0),\n    unit_price numeric NOT NULL CHECK (unit_price \u003e= 0),\n    PRIMARY KEY (order_id, sku)\n);\n```\n\nEn kundes by er nu gemt én gang, og en flytning er en opdatering af én række.\nStatusteksterne ligger i en lille opslagstabel med en `smallint` som nøgle, så\nhver ordre bærer et kort tal i stedet for en gentaget tekst, og en stavefejl i\nen status kan ikke slippe ind: fremmednøglen afviser enhver `status_id`, som\n`order_status` ikke har.\n\n`unit_price` bliver på `order_lines`, selv om `products` allerede har en pris.\nDet er ingen forglemmelse. Den pris, kunden betalte, er en oplysning om salget,\nikke om produktet, og den må ikke ændre sig, når kataloget gør. Normalisering\nspørger, hvor hver oplysning hører hjemme, og denne hører til linjen.\n\nDe to `ON DELETE`-klausuler siger, hvad en sletning betyder. Sletter man en\nordre, ryger dens linjer med, for en linje giver ingen mening uden sin ordre.\nSletning af en kunde, der har ordrer, fejler, fordi butikken skal beholde de\nordrer. PostgreSQL's standard, `NO ACTION`, afviser også den sletning;\n`RESTRICT` gør hensigten tydelig, og i modsætning til `NO ACTION` kan den ikke\nudskydes til slutningen af transaktionen.\n\nPostgreSQL opretter et indeks for hver primærnøgle, men ikke for den refererende\nside af en fremmednøgle. Dokumentationen foreslår at tilføje et, fordi sletning\neller opdatering af en refereret række skal finde hver række, der peger på den:\n\n```sql\nCREATE INDEX ON orders (customer_id);\nCREATE INDEX ON order_lines (sku);\n```\n\n`order_lines.order_id` behøver ikke noget ekstra: den er den første kolonne i\ntabellens primærnøgle.\n\nTil sidst giver et view den flade form tilbage til dem, der vil have den:\n\n```sql\nCREATE VIEW order_report AS\nSELECT o.order_id, o.ordered_on, c.email, c.name AS customer_name, c.city,\n       l.sku, p.name AS product_name, l.unit_price, l.quantity, s.label\nFROM   orders o\nJOIN   customers c    USING (customer_id)\nJOIN   order_status s USING (status_id)\nJOIN   order_lines l  USING (order_id)\nJOIN   products p     USING (sku);\n```\n\nRapporter kan læse `order_report` stort set, som de læste den gamle tabel, mens\nhver oplysning bag den er gemt én gang. PostgreSQL's vejledning argumenterer på\nsamme måde for views generelt: et view giver en forespørgsel et navn, der kan\nbruges som en tabel, og lader tabellerne nedenunder ændre sig bag en\ngrænseflade, der står fast.\n\nDe samme regler gælder i langt større skala. Den\n[maritime datamodel](/da/portfolio/modeled-348-tables-across-34-postgres-schemas/)\nfra grundlæggerens arbejde hos NextMariner er bygget op som normaliserede PostgreSQL-skemaer, organiseret efter domæne; i\noktober 2026 opgjorde siden den til 348 tabeller fordelt på 34 skemaer. Små,\nstabile mængder som statusser, typer og kategorier blev til\n`SMALLINT`-opslagstabeller, hvilket holder rækkerne kompakte og joins billige,\nog rigtige fremmednøgler og constraints holder relationerne sammen, så\nintegriteten er databasens opgave og ikke noget, applikationen skal huske.\n\n## Hvor det går galt\n\n**Lister pakket i én kolonne.** En `tags`-kolonne med `red,large,sale`, eller en\ntelefonkolonne med to numre, bryder første normalform. Databasen kan ikke\nkontrollere de enkelte værdier, pege en fremmednøgle på dem eller joine på dem,\nog hver forespørgsel må først splitte teksten op. Giv listen sin egen tabel med\nén række pr. værdi og forælderens nøgle plus værdien som nøgle: Codds\nfremgangsmåde fra 1970.\n\n**Historik, der normaliseres væk.** Prisen på en ordrelinje eller\nleveringsadressen på en ordre ligner en dublet af det, produkt- og\nkundetabellerne indeholder. Det er den ikke: den registrerer, hvad der gjaldt,\nda ordren blev afgivet. Udskift den med en nøgle til det aktuelle katalog, og\nhver gammel faktura ændrer sig, næste gang en pris gør. Gem oplysninger om en\nhændelse på hændelsen.\n\n**Fremmednøgler uden indeks.** Den refererede side af en fremmednøgle har altid\net indeks, fordi den skal være en primærnøgle, en unik constraint eller et unikt\nindeks. Den refererende side har ikke, så sletning af en kunde eller ændring af\net produkts SKU betyder, at hele den refererende tabel skal gennemsøges for\nrækker, der peger på den. Indeksér de refererende kolonner som ovenfor.\nPostgreSQL overlader det til dig, fordi det ikke altid er nødvendigt.\n\n**Kaskader, der sletter bilag.** `ON DELETE CASCADE` fra kunder til fakturaer\nbetyder, at én uforsigtig sletning af en kunde stille fjerner data, som\nforretningen skal opbevare. Lad kun sletninger kaskadere til rækker, der intet\nbetyder uden deres forælder, som ordrelinjer, og brug `RESTRICT` eller\nstandarden alle andre steder.\n\n**Et normaliseret design, som intet håndhæver.** Tabeller, der er oprettet i\nhånden eller indlæst fra regneark, kommer ofte uden primærnøgle og uden\nfremmednøgler, så intet forhindrer en dubletrække eller en ordre til en kunde,\nder ikke findes. PostgreSQL kræver ikke en primærnøgle, selv om dokumentationen\nbemærker, at relationsteorien kræver én i hver tabel. Erklær nøglerne, så\nafviser databasen den dårlige række med en fejl, der nævner constrainten ved\nnavn.\n\n**Gemte totaler, der skrider.** En `order_total`-kolonne på `orders`, holdt ved\nsiden af de linjer, den summerer, er en denormalisering, og hver kodevej, der\nændrer en linje, skal også opdatere den. En kodevej, der glemmer det, efterlader\nen forkert total uden at udløse nogen fejl. Beregn totalen i en forespørgsel\neller et view. Viser det sig at være for langsomt, så behold kopien, men\nvedligehold den ét sted, inden for den samme transaktion, der ændrer linjerne.\n\n**Denormalisering før måling.** Joins på indekserede nøgler er billige, og at\nkopiere kolonner for at undgå dem bytter en lille, kendt omkostning for de\nanomalier, der er beskrevet ovenfor. Læs forespørgselsplanen først. Når\nlæsninger virkelig er for langsomme, kan et materialiseret view eller en separat\nrapporteringsdatabase rumme den flade form, mens kildetabellerne beholder én\nkopi af hver oplysning. Rapportering er stedet, hvor denormalisering hører\nhjemme med vilje, som i stjerneskemaet i et datavarehus.\n\n**For meget opsplitning.** Normalisering beder om ét hjem til hver oplysning,\nikke om så mange tabeller som muligt. At dele en tabel, hvis kolonner allerede\nafhænger af nøglen og af intet andet, giver kun flere joins og flere tabelnavne,\nsom alle skal lære. Et skema, der kræver et dusin joins for at vise én ordre, er\nikke lettere at arbejde med end et fladt. Stop, når hver oplysning har ét hjem.\n\n## Læs mere\n\n- [A Relational Model of Data for Large Shared Data Banks](https://doi.org/10.1145/362384.362685)\n  — Codds artikel fra 1970 i Communications of the ACM, der introducerede\n  relationsmodellen, normalform og normalisering.\n- [Multivalued Dependencies and a New Normal Form](https://doi.org/10.1145/320557.320571)\n  — Fagins artikel fra 1977, der definerer den flerværdige afhængighed og fjerde\n  normalform og viser, at enhver tabel kan deles op på fjerde normalform, uden\n  at der går information tabt.\n- [Constraints](https://www.postgresql.org/docs/current/ddl-constraints.html) —\n  PostgreSQL om primærnøgler, fremmednøgler, check-constraints og\n  `ON DELETE`-handlingerne, og hvorfor refererende kolonner er værd at\n  indeksere.\n- [Views](https://www.postgresql.org/docs/current/tutorial-views.html) —\n  PostgreSQL-vejledningens argument for views som en stabil grænseflade over\n  tabeller, hvis struktur ændrer sig.\n\n\u003chttps://engineer.company/da/glossary/normalization/\u003e\n","date_modified":"2026-11-12T05:34:23Z","description":"Hvad databasenormalisering er: Codds normalformer, fremmednøgler i PostgreSQL, de anomalier den fjerner, og de fejl, der begås i dens navn.","formats":{"gemtext":"https://engineer.company/da/glossary/normalization/index.gmi","gopher":"https://engineer.company/da/glossary/normalization/gophermap","html":"https://engineer.company/da/glossary/normalization/","json":"https://engineer.company/da/glossary/normalization/index.json","markdown":"https://engineer.company/da/glossary/normalization/index.md","pdf":"https://engineer.company/da/glossary/normalization/index.pdf"},"kind":"page","language":"da","title":"Hvad er databasenormalisering?","url":"https://engineer.company/da/glossary/normalization/","version":1}