Förberedelser inför SQL-intervjun · Lektion

Normalisering till 3NF

Första, andra och tredje normalformen samt vilka anomalier de eliminerar.

Lektion 1 av 413 steg

Normalisering till 3NF är en gratis lektion i Förberedelser inför SQL-intervjun på CoddyKit. Detta är lektion 1 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för Förberedelser inför SQL-intervjun, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Förberedelser inför SQL-intervjun innehåller totalt 4 lektioner.

Varför intervjuare frågar om normalisering

Normalisering är en grundläggande del av databasmodellering, och intervjuare använder den för att testa om Ni förstår dataintegritet på designnivå. Frågan låter ofta så här: "Vad är normalisering och varför är den viktig?"

Normalisering är processen att organisera kolumner och tabeller för att minska redundans och förhindra uppdaterings-, insättnings- och borttagningsanomalier. Varje normalform (1NF, 2NF, 3NF) lägger till en striktare regel.

Ett bra svar nämner vilka anomalier normalisering eliminerar, inte bara läroboksdefinitionerna.

De tre anomalierna

Innan Ni går igenom normalformerna bör Ni lära Er vilka problem de löser. En dåligt utformad tabell som lagrar allt på samma ställe drabbas av tre anomalier:

Uppdateringsanomali: samma faktum lagras på många rader, så en ändring måste göras på alla dessa rader, annars blir data inkonsekventa.
Insättningsanomali: Ni kan inte lägga till ett faktum utan att samtidigt ange orelaterade data (t.ex. lägga till en produkt utan en order).
Borttagningsanomali: när en rad tas bort raderas av misstag ett annat oberoende faktum.

Om Ni kan upptäcka dessa i en exempelstabell kan Ni motivera varje normaliseringssteg.

En onormaliserad utgångstabell

Här är ett klassiskt intervjuexempel: en bred tabell där order, kunder och produkter blandas. Lägg märke till den upprepade kundens e-postadress och produktens pris på flera rader. Det är här anomalierna uppstår.

Er uppgift under intervjun är att stegvis normalisera tabellen till 3NF och förklara varje uppdelning.

-- Unnormalized: everything in one table
CREATE TABLE orders_flat (
  order_id     INT,
  customer_id  INT,
  customer_email VARCHAR(255),
  product_id   INT,
  product_name VARCHAR(100),
  unit_price   DECIMAL(10,2),
  quantity     INT
);

Första normalformen (1NF)

1NF kräver att varje kolumn innehåller ett enda atomärt värde och att det inte finns några upprepande grupper eller matriser i en cell.

En tabell bryter mot 1NF om en kolumn innehåller en kommaseparerad lista som 'phone1, phone2' eller om Ni har kolumnerna product1, product2, product3.

Lösningen är att ge varje värde en egen rad. Intervjuaren vill höra "atomära värden, inga upprepande grupper och en nyckel som identifierar varje rad."

-- Violates 1NF: a list inside one column
-- phones = '555-1111, 555-2222'

-- 1NF fix: one phone per row
CREATE TABLE customer_phone (
  customer_id INT,
  phone       VARCHAR(20),
  PRIMARY KEY (customer_id, phone)
);

Funktionella beroenden

För att förklara 2NF och 3NF måste Ni använda termen funktionellt beroende. Vi skriver A -> B för att ange "A bestämmer B": för varje värde på A finns exakt ett värde på B.

I tabellen orders:

customer_id -> customer_email
product_id -> product_name, unit_price
order_id, product_id -> quantity

Normalisering handlar egentligen om att säkerställa att varje icke-nyckelkolumn beror på hela nyckeln och inget annat än nyckeln.

Andra normalformen (2NF)

2NF gäller när primärnyckeln är sammansatt. Den förbjuder en icke-nyckelkolumn att bero endast på en del av nyckeln (ett partiellt beroende).

Nyckeln för vår orderrad är (order_id, product_id). Men product_name och unit_price beror endast på product_id, inte på hela nyckeln. Det är ett partiellt beroende, så tabellen bryter mot 2NF.

Lösningen är att flytta produktattributen till en products-tabell med product_id som nyckel.

CREATE TABLE products (
  product_id   INT PRIMARY KEY,
  product_name VARCHAR(100),
  unit_price   DECIMAL(10,2)
);

CREATE TABLE order_items (
  order_id   INT,
  product_id INT,
  quantity   INT,
  PRIMARY KEY (order_id, product_id),
  FOREIGN KEY (product_id) REFERENCES products(product_id)
);

Tredje normalformen (3NF)

3NF eliminerar transitiva beroenden: en icke-nyckelkolumn som beror på en annan icke-nyckelkolumn i stället för direkt på nyckeln.

Anta att en orders-tabell innehåller customer_id och customer_email. Här gäller order_id -> customer_id -> customer_email. E-postadressen beror på nyckeln endast via customer_id, vilket är ett transitivt beroende.

Lösningen är att dela upp kunderna i en egen tabell. Nu beror varje tabells icke-nyckelkolumner endast på tabellens nyckel.

CREATE TABLE customers (
  customer_id    INT PRIMARY KEY,
  customer_email VARCHAR(255)
);

CREATE TABLE orders (
  order_id    INT PRIMARY KEY,
  customer_id INT,
  FOREIGN KEY (customer_id) REFERENCES customers(customer_id)
);

En minnesregel på en rad

Intervjuare uppskattar en kandidat som kan sammanfatta 3NF i en enda mening. Den klassiska formuleringen:

"Varje icke-nyckelkolumn måste bero på nyckeln, hela nyckeln och inget annat än nyckeln."

Nyckeln -> 1NF (det finns en nyckel och värdena är atomära).
Hela nyckeln -> 2NF (inget partiellt beroende).
Inget annat än nyckeln -> 3NF (inget transitivt beroende).

Denna enda rad gör att Ni kan återskapa alla tre former vid behov.

BCNF: följdfrågan

En skarpsinnig intervjuare kan fråga om Boyce-Codd-normalformen (BCNF), en striktare variant av 3NF.

BCNF kräver att X måste vara en supernyckel för varje funktionellt beroende X -> Y. 3NF tillåter ett sällsynt undantag när det beroende attributet ingår i en kandidatnyckel; BCNF tar bort även det undantaget.

Ni kommer sällan att se BCNF-brott i praktiken, men att nämna det och säga "BCNF är 3NF utan undantag för primattribut" signalerar djupare kunskaper.

När Ni INTE ska normalisera

Ett svar på seniornivå erkänner avvägningen. Normalisering förbättrar integriteten men kan försämra läsprestandan, eftersom det krävs fler joins för att besvara en fråga.

Avsiktlig denormalisering är godtagbar när:

Arbetsbelastningen är läsintensiv och joins är flaskhalsen.
Ni bygger ett analys- eller rapporteringslager (stjärnscheman, som tas upp senare).
Ni kan hålla den redundanta kopian synkroniserad (triggers, ETL, materialiserade vyer).

Säg: "Normalisera för OLTP-integritet; denormalisera medvetet för läshastighet i OLAP."

Så går Ni igenom det på whiteboarden

Sätt nu ihop allt. I en liveintervju, när Ni får en rörig tabell:

Ange kandidatnyckeln och lista funktionella beroenden.
Kontrollera atomära värden och upprepande grupper (1NF).
Om nyckeln är sammansatt, kontrollera partiella beroenden (2NF).
Kontrollera beroenden mellan icke-nyckelkolumner (3NF).
Rita upp de resulterande tabellerna med primär- och främmande nycklar.

Att beskriva dessa steg högt är precis det intervjuaren bedömer.

Snabbkontroll

Testa Er förståelse av normalformerna.

Besvara frågan i den interaktiva lektionen

Repetition: normalisering till och med 3NF

Nu kan Ni besvara den klassiska intervjufrågan om normalisering från början till slut:

Normalisering eliminerar uppdaterings-, insättnings- och borttagningsanomalier genom att minska redundansen.
1NF: atomära värden, inga upprepande grupper.
2NF: inget partiellt beroende av en sammansatt nyckel.
3NF: inget transitivt beroende (mellan icke-nyckelkolumner).
Sammanfatta det som "nyckeln, hela nyckeln och inget annat än nyckeln."
BCNF skärper 3NF; denormalisera medvetet för läsintensiv analys.

Gratis att börja

Lär dig SQL med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 30
Lektioner: 120

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Normalisering till 3NF” gratis?

Ja – hela texten till ”Normalisering till 3NF” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i Förberedelser inför SQL-intervjun, kan Ni uppgradera till CoddyKit PRO. Kursen i Förberedelser inför SQL-intervjun innehåller totalt 4 lektioner.

Vad lär jag mig i ”Normalisering till 3NF”?

Första, andra och tredje normalformen samt vilka anomalier de eliminerar. Ni övar på Förberedelser inför SQL-intervjun med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig Förberedelser inför SQL-intervjun?

Du behöver inga förkunskaper. Utbildningen i Förberedelser inför SQL-intervjun på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 1 av 4.

Hur lång tid tar lektionen ”Normalisering till 3NF”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här Förberedelser inför SQL-intervjun-lektionen?

Ja. Varje Förberedelser inför SQL-intervjun-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

Normalisering till 3NF
ER-modellering och relationskardinalitet
Stjärnschema och design av datalager
Komplett uppsättning övningsintervjuer

← Tillbaka till Förberedelser inför SQL-intervjun