{"canonical_url":"https://engineer.company/sv/glossary/normalization/","content_markdown":"# Databasnormalisering\n\n## Vad det är\n\nDatabasnormalisering är praxisen att lägga upp en relationsdatabas så att varje\nuppgift lagras på ett ställe, i den tabell den beskriver, och allt annat\nhänvisar till den med dess nyckel. Man säger också normalisering av databaser,\neller bara normalisering när sammanhanget gör det tydligt. En kunds adress står\ni en rad i en kundtabell; en order har bara kundens nyckel, och en join för\nsamman de två när en fråga behöver båda.\n\nBåde idén och ordet kommer från Edgar F. Codd, som föreslog relationsmodellen i\nCommunications of the ACM i juni 1970. I den artikeln betydde normalisering ett\nbestämt steg: att bli av med relationer som innehåller andra relationer, till\nexempel en post för en anställd med sin egen lista över tidigare tjänster och sin\negen lista över barn. Codds tillvägagångssätt kopierar förälderns primärnyckel\nin i varje nästlad grupp och lyfter ut gruppen i en egen relation, med\nförälderns nyckel plus det som identifierar en rad inom gruppen som nyckel. Det\nsom blir kvar är i normalform, i dag känd som första normalform: varje värde i\nvarje kolumn är ett enda, enkelt värde.\n\nCodd definierade sedan striktare normalformer, bland dem den som Ronald Fagins\nartikel från 1977 kallar Codds förbättrade tredje normalform eller\nBoyce–Codd-normalform. Fagins artikel lägger till en fjärde. Den bygger på en ny\nsorts beroende mellan kolumner, det flervärda beroendet, som omfattar det\nvälkända funktionella beroendet som ett specialfall, och Fagin visade att den\nfjärde formen är strikt starkare än Boyce–Codd-normalform.\n\nDe striktare formerna nås genom uppdelning. En tabell ersätts av två eller fler\nav sina projektioner, tabeller med några av dess kolumner, valda så att en join\nav dem ger tillbaka exakt originalet. Fagins artikel visar att den garantin\ngäller för hans egen form: varje tabell kan delas upp i tabeller i fjärde\nnormalform utan att information går förlorad, eftersom en join av dem återskapar\noriginalet. Denormalisering är motsatsen: att avsiktligt spara en kopia av en\nuppgift på ett andra ställe, oftast för att slippa en join.\n\n## Varför det spelar roll\n\nEn tabell som lagrar samma uppgift många gånger bäddar för tre sorters problem.\nTänk dig en rad per anställd och projekt, där den anställdas kontor står på\nvarje rad. När någon byter kontor behöver flera rader det nya värdet, och missar\nman en motsäger databasen sig själv. När en anställds sista projekt avslutas och\nraden tas bort försvinner uppgiften om var personen sitter. Och en nyanställd\nsom inte är med i något projekt har ingenstans att föra in sitt kontor. Det här\när uppdaterings-, borttagnings- och insättningsanomalierna, och delas tabellen i\nanställd–projekt och anställd–kontor försvinner alla tre.\n\nI ett teams vardag visar sig de här anomalierna som buggar. En faktura visar den\ngamla adressen för att en kopia missades. En rapport räknar en kund två gånger\nför att namnet skrevs på två sätt. Ett normaliserat schema gör sådana buggar\nsvåra att skriva från början, och när primärnycklar, främmande nycklar och\nCHECK-villkor är deklarerade avvisar databasen själv dåliga data i stället för\natt lita på att all applikationskod minns reglerna.\n\nÄndringar blir också billigare. Ett schema där varje tabell beskriver en sak tar\noftast emot nya slags data med mindre ombyggnad: det är en mindre migrering att\nlägga till en kolumn i den enda tabell som äger en uppgift än att hitta varje\ntabell som har kopierat den.\n\nPriset är joinar. En normaliserad databas besvarar de flesta frågor genom att\njoina ihop tabellerna igen, och varje join är arbete för servern. Med index på\nkolumnerna som joinas är det arbetet oftast litet, och därför bör en uppmätt\nlångsam fråga och inte en magkänsla avgöra när en uppgift kopieras tillbaka.\n\n## Så ser det ut i praktiken\n\nEn liten webbutik börjar med en enda platt tabell, inläst från en export av ett\nkalkylark:\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\nVarje rad är en rad i en order, så en kunds namn och stad upprepas på varje rad\ni varje order, och en produkts namn upprepas på varje rad som säljer den. En\nkund som flyttar har dussintals rader att uppdatera. Tar man bort den sista\nraden som sålde en produkt glömmer tabellen att produkten finns. Statusen är\nfritext, så `shipped`, `Shipped` och `shipd` kan alla dyka upp.\n\nNormaliserat får varje uppgift ett eget hem:\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 kunds stad lagras nu en gång, och en flytt är en uppdatering av en rad.\nStatustexterna ligger i en liten uppslagstabell med en `smallint` som nyckel, så\nvarje order bär ett kort tal i stället för en upprepad sträng, och en felstavad\nstatus kan inte slinka in: den främmande nyckeln avvisar varje `status_id` som\n`order_status` inte har.\n\n`unit_price` stannar på `order_lines`, fast `products` redan har ett pris. Det\när inget förbiseende. Priset kunden betalade är en uppgift om försäljningen,\ninte om produkten, och det får inte ändras när katalogen gör det. Normalisering\nfrågar var varje uppgift hör hemma, och den här hör till orderraden.\n\nDe två `ON DELETE`-satserna säger vad en borttagning betyder. Tar man bort en\norder följer dess rader med, eftersom en orderrad inte betyder något utan sin\norder. Att ta bort en kund som har ordrar misslyckas, eftersom butiken måste\nbehålla de ordrarna. PostgreSQL:s standard, `NO ACTION`, avvisar också den\nborttagningen; `RESTRICT` gör avsikten tydlig, och till skillnad från\n`NO ACTION` kan den inte skjutas upp till slutet av transaktionen.\n\nPostgreSQL skapar ett index för varje primärnyckel, men inte för den refererande\nsidan av en främmande nyckel. Dokumentationen föreslår att man lägger till ett,\neftersom en borttagning eller uppdatering av en refererad rad måste hitta varje\nrad som pekar 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 inget extra: den är den första kolumnen i\ntabellens primärnyckel.\n\nTill sist ger en vy den platta formen tillbaka åt dem som vill ha 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äsa `order_report` ungefär som de läste den gamla tabellen, medan\nvarje uppgift bakom den lagras en gång. Introduktionen i\nPostgreSQL-dokumentationen argumenterar likadant för vyer i allmänhet: en vy ger\nen fråga ett namn som kan användas som en tabell, och låter tabellerna därunder\nändras bakom ett gränssnitt som ligger fast.\n\nSamma regler gäller i mycket större skala. Den\n[maritima datamodellen](/sv/portfolio/modeled-348-tables-across-34-postgres-schemas/)\nfrån grundarens arbete hos NextMariner är uppbyggd som normaliserade PostgreSQL-scheman organiserade per domän; i\noktober 2026 angav sidan den till 348 tabeller fördelade på 34 scheman. Små,\nstabila mängder som statusar, typer och kategorier blev uppslagstabeller med\n`SMALLINT`, vilket håller raderna kompakta och joinarna billiga, och riktiga\nfrämmande nycklar och villkor håller ihop relationerna, så att integriteten är\ndatabasens uppgift och inte något som applikationen måste komma ihåg.\n\n## Var det går fel\n\n**Listor packade i en kolumn.** En `tags`-kolumn med `red,large,sale`, eller en\ntelefonkolumn med två nummer, bryter mot första normalform. Databasen kan inte\nkontrollera de enskilda värdena, låta en främmande nyckel peka på dem eller\njoina på dem, och varje fråga måste först dela upp strängen. Ge listan en egen\ntabell med en rad per värde och förälderns nyckel plus värdet som nyckel: Codds\ntillvägagångssätt från 1970.\n\n**Historik som normaliseras bort.** Priset på en orderrad eller leveransadressen\npå en order ser ut som en dubblett av det produkt- och kundtabellerna\ninnehåller. Det är det inte: det registrerar vad som gällde när ordern lades.\nByt ut det mot en nyckel till den aktuella katalogen, så ändras varje gammal\nfaktura nästa gång ett pris gör det. Spara uppgifter om en händelse på\nhändelsen.\n\n**Främmande nycklar utan index.** Den refererade sidan av en främmande nyckel\nhar alltid ett index, eftersom den måste vara en primärnyckel, ett\nunikhetsvillkor eller ett unikt index. Den refererande sidan har det inte, så\natt ta bort en kund eller ändra en produkts SKU innebär att hela den refererande\ntabellen söks igenom efter rader som pekar dit. Indexera de refererande\nkolumnerna, som ovan. PostgreSQL lämnar det åt dig eftersom det inte alltid\nbehövs.\n\n**Kaskader som raderar sådant som ska sparas.** `ON DELETE CASCADE` från kunder\ntill fakturor betyder att en vårdslös borttagning av en kund i tysthet tar bort\ndata som verksamheten måste bevara. Låt bara borttagningar kaskadera till rader\nsom inte betyder något utan sin förälder, som orderrader, och använd `RESTRICT`,\neller standarden, överallt annars.\n\n**En normaliserad design som inget upprätthåller.** Tabeller som skapats för\nhand eller lästs in från kalkylark kommer ofta utan primärnyckel och utan\nfrämmande nycklar, så inget stoppar en dubblettrad eller en order till en kund\nsom inte finns. PostgreSQL kräver ingen primärnyckel, även om dokumentationen\npåpekar att relationsteorin kräver en i varje tabell. Deklarera nycklarna, så\navvisar databasen den dåliga raden med ett fel som namnger villkoret.\n\n**Lagrade summor som glider isär.** En `order_total`-kolumn på `orders`, som\nhålls bredvid raderna den summerar, är en denormalisering, och varje kodväg som\nändrar en rad måste också uppdatera den. En kodväg som glömmer det lämnar en\nfelaktig summa utan att något fel uppstår. Räkna ut summan i en fråga eller en\nvy. Visar det sig vara för långsamt, behåll kopian, men underhåll den på ett\nställe, i samma transaktion som ändrar raderna.\n\n**Denormalisering före mätning.** Joinar på indexerade nycklar är billiga, och\natt kopiera kolumner för att slippa dem byter en liten, känd kostnad mot de\nanomalier som beskrivs ovan. Läs frågeplanen först. När läsningarna verkligen är\nför långsamma kan en materialiserad vy eller en separat rapportdatabas hålla den\nplatta formen medan källtabellerna behåller en kopia av varje uppgift.\nRapportering är där denormalisering hör hemma med avsikt, som i stjärnschemat i\nett datalager.\n\n**För mycket uppdelning.** Normalisering ber om ett hem för varje uppgift, inte\nom så många tabeller som möjligt. Att dela en tabell vars kolumner redan beror\npå nyckeln och på inget annat ger bara fler joinar och fler tabellnamn som alla\nmåste lära sig. Ett schema som behöver ett dussin joinar för att visa en order\när inte lättare att arbeta med än ett platt. Sluta när varje uppgift har ett\nenda hem.\n\n## Läs mer\n\n- [A Relational Model of Data for Large Shared Data Banks](https://doi.org/10.1145/362384.362685)\n  — Codds artikel från 1970 i Communications of the ACM, som introducerade\n  relationsmodellen, normalform och normalisering.\n- [Multivalued Dependencies and a New Normal Form](https://doi.org/10.1145/320557.320571)\n  — Fagins artikel från 1977, som definierar det flervärda beroendet och fjärde\n  normalform och visar att varje tabell kan delas upp i fjärde normalform utan\n  att information går förlorad.\n- [Constraints](https://www.postgresql.org/docs/current/ddl-constraints.html) —\n  PostgreSQL om primärnycklar, främmande nycklar, CHECK-villkor och\n  `ON DELETE`-åtgärderna, och varför refererande kolumner är värda att indexera.\n- [Views](https://www.postgresql.org/docs/current/tutorial-views.html) —\n  introduktionen i PostgreSQL-dokumentationen om vyer som ett stabilt gränssnitt\n  över tabeller vars struktur ändras.\n\n\u003chttps://engineer.company/sv/glossary/normalization/\u003e\n","date_modified":"2026-11-12T05:34:23Z","description":"Vad databasnormalisering är: Codds normalformer, främmande nycklar i PostgreSQL, anomalierna den tar bort och misstagen som görs i dess namn.","formats":{"gemtext":"https://engineer.company/sv/glossary/normalization/index.gmi","gopher":"https://engineer.company/sv/glossary/normalization/gophermap","html":"https://engineer.company/sv/glossary/normalization/","json":"https://engineer.company/sv/glossary/normalization/index.json","markdown":"https://engineer.company/sv/glossary/normalization/index.md","pdf":"https://engineer.company/sv/glossary/normalization/index.pdf"},"kind":"page","language":"sv","title":"Vad är databasnormalisering?","url":"https://engineer.company/sv/glossary/normalization/","version":1}