20TD02U_ForAlle_Blooms_Side_53_Database_Normalisering - itnett/FTD02H-N GitHub Wiki

For å gi en grundig forståelse og programmatisert tilnærming til temaet "Normalisering", vil vi bruke Blooms taksonomi for å strukturere læringen fra grunnleggende til avansert nivå. Normalisering er en kritisk prosess i databasesystemer som hjelper med å organisere data for å redusere redundans og forbedre dataintegritet. Vi vil dekke de ulike normalformene (1NF, 2NF, 3NF), og vi vil inkludere programmatiske, logiske og praktiske tilnærminger.

Videregående Skole Nivå

1. Kunnskap (Remembering)

Emne: Grunnleggende Begreper i Normalisering

Logisk tilnærming: Start med å lære de grunnleggende konseptene for normalisering, inkludert hva normalisering er, hvorfor det er viktig, og hva som menes med 1NF, 2NF, og 3NF.
Programmatisk tilnærming: Bruk Python for å opprette en enkel tabell i SQLite som ikke er normalisert, og deretter opprett en normalisert versjon av samme tabell.
Praktisk tilnærming: Opprett en database som inneholder redundante data (ikke-normalisert) og diskuter hvordan disse dataene kan forbedres ved normalisering.

import sqlite3

# Ikke-normalisert tabell
connection = sqlite3.connect('skole.db')
cursor = connection.cursor()

cursor.execute('''
CREATE TABLE elever (
    id INTEGER PRIMARY KEY,
    navn TEXT,
    klasse TEXT,
    lærer TEXT
)
''')

cursor.execute("INSERT INTO elever (navn, klasse, lærer) VALUES ('Ola Nordmann', '10A', 'Lærer A')")
cursor.execute("INSERT INTO elever (navn, klasse, lærer) VALUES ('Kari Nordmann', '10B', 'Lærer B')")
cursor.execute("INSERT INTO elever (navn, klasse, lærer) VALUES ('Per Hansen', '10A', 'Lærer A')")

connection.commit()
connection.close()

2. Forståelse (Understanding)

Emne: 1NF (Første Normalform)

Logisk tilnærming: Forstå prinsippene for 1NF, hvor tabellen må oppfylle kravet om at alle attributter skal være atomære, dvs. hver celle skal inneholde en enkelt verdi, og hver rad skal være unik.
Programmatisk tilnærming: Modifiser den eksisterende tabellen slik at den oppfyller 1NF ved å sikre at ingen kolonner inneholder flere verdier.
Praktisk tilnærming: Gå gjennom eksempler på tabeller som ikke er i 1NF, og implementer endringer som bringer dem til 1NF.

# Modifisert tabell for å oppfylle 1NF (ingen flere verdier i en enkelt celle)
connection = sqlite3.connect('skole.db')
cursor = connection.cursor()

cursor.execute('''
CREATE TABLE elever_1NF (
    id INTEGER PRIMARY KEY,
    navn TEXT,
    klasse TEXT,
    lærer TEXT
)
''')

cursor.execute("INSERT INTO elever_1NF (navn, klasse, lærer) VALUES ('Ola Nordmann', '10A', 'Lærer A')")
cursor.execute("INSERT INTO elever_1NF (navn, klasse, lærer) VALUES ('Kari Nordmann', '10B', 'Lærer B')")
cursor.execute("INSERT INTO elever_1NF (navn, klasse, lærer) VALUES ('Per Hansen', '10A', 'Lærer A')")

connection.commit()
connection.close()

Høyskole Nivå

3. Anvendelse (Applying)

Emne: 2NF (Andre Normalform)

Logisk tilnærming: Forstå prinsippene for 2NF, som krever at tabellen først er i 1NF og at alle ikke-nøkkelattributter er fullstendig funksjonelt avhengige av primærnøkkelen (ingen delvis avhengighet).
Programmatisk tilnærming: Del opp tabellen fra 1NF til 2NF ved å skille ut delvis avhengige kolonner til egne tabeller.
Praktisk tilnærming: Identifiser tabeller som har delvis avhengighet, og normaliser dem til 2NF.

# Splitte tabellen fra 1NF til 2NF
connection = sqlite3.connect('skole.db')
cursor = connection.cursor()

# Opprette separate tabeller for klasser og lærere for å eliminere delvis avhengighet
cursor.execute('''
CREATE TABLE klasser (
    klasse_id INTEGER PRIMARY KEY,
    klasse_navn TEXT
)
''')

cursor.execute('''
CREATE TABLE lærere (
    lærer_id INTEGER PRIMARY KEY,
    lærer_navn TEXT
)
''')

cursor.execute('''
CREATE TABLE elever_2NF (
    id INTEGER PRIMARY KEY,
    navn TEXT,
    klasse_id INTEGER,
    lærer_id INTEGER,
    FOREIGN KEY (klasse_id) REFERENCES klasser (klasse_id),
    FOREIGN KEY (lærer_id) REFERENCES lærere (lærer_id)
)
''')

# Legge til data i de normaliserte tabellene
cursor.execute("INSERT INTO klasser (klasse_navn) VALUES ('10A')")
cursor.execute("INSERT INTO klasser (klasse_navn) VALUES ('10B')")
cursor.execute("INSERT INTO lærere (lærer_navn) VALUES ('Lærer A')")
cursor.execute("INSERT INTO lærere (lærer_navn) VALUES ('Lærer B')")

cursor.execute("INSERT INTO elever_2NF (navn, klasse_id, lærer_id) VALUES ('Ola Nordmann', 1, 1)")
cursor.execute("INSERT INTO elever_2NF (navn, klasse_id, lærer_id) VALUES ('Kari Nordmann', 2, 2)")
cursor.execute("INSERT INTO elever_2NF (navn, klasse_id, lærer_id) VALUES ('Per Hansen', 1, 1)")

connection.commit()
connection.close()

4. Analyse (Analyzing)

Emne: 3NF (Tredje Normalform)

Logisk tilnærming: Forstå prinsippene for 3NF, som krever at tabellen først er i 2NF og at alle ikke-nøkkelattributter er direkte avhengige av primærnøkkelen (ingen transitive avhengigheter).
Programmatisk tilnærming: Del opp tabellen fra 2NF til 3NF ved å eliminere transitive avhengigheter.
Praktisk tilnærming: Identifiser tabeller med transitive avhengigheter og normaliser dem til 3NF.

# Eksempel på normalisering til 3NF ved å eliminere transitive avhengigheter
connection = sqlite3.connect('skole.db')
cursor = connection.cursor()

# Anta at vi har en situasjon hvor lærere har en avdelingsavhengighet som er transitive
cursor.execute('''
CREATE TABLE avdelinger (
    avdeling_id INTEGER PRIMARY KEY,
    avdeling_navn TEXT
)
''')

# Oppdater lærere tabellen for å inkludere avdeling_id
cursor.execute('''
CREATE TABLE lærere_3NF (
    lærer_id INTEGER PRIMARY KEY,
    lærer_navn TEXT,
    avdeling_id INTEGER,
    FOREIGN KEY (avdeling_id) REFERENCES avdelinger (avdeling_id)
)
''')

# Opprette en normalisert elever tabell i 3NF
cursor.execute('''
CREATE TABLE elever_3NF (
    id INTEGER PRIMARY KEY,
    navn TEXT,
    klasse_id INTEGER,
    FOREIGN KEY (klasse_id) REFERENCES klasser (klasse_id)
)
''')

# Legge til data i de normaliserte tabellene
cursor.execute("INSERT INTO avdelinger (avdeling_navn) VALUES ('Matematikk')")
cursor.execute("INSERT INTO lærere_3NF (lærer_navn, avdeling_id) VALUES ('Lærer A', 1)")

cursor.execute("INSERT INTO elever_3NF (navn, klasse_id) VALUES ('Ola Nordmann', 1)")

connection.commit()
connection.close()

Universitets Nivå

5. Syntese (Synthesizing)

Emne: Normalisering for Kompleks Datamodellering

Logisk tilnærming: Lær hvordan du kombinerer flere normalformer for å designe komplekse databasestrukturer som eliminerer alle typer redundans og sikrer dataintegritet.
Programmatisk tilnærming: Implementer en kompleks datamodell ved hjelp av SQL, der data er delt på tvers av flere tabeller for å oppnå optimal normalisering.
Praktisk tilnærming: Bruk et ER-diagramverktøy for å visualisere den normaliserte databasen og implementer modellen i en SQL-database.

# Fullstendig normalisering for en kompleks datamodell
connection = sqlite3.connect('skole.db')
cursor = connection.cursor()

# Definerer tabeller og deres relasjoner
cursor.execute('''
CREATE TABLE studenter (
    student_id INTEGER PRIMARY KEY,
    navn TEXT
)
''')

cursor.execute('''
CREATE TABLE kurs (
    kurs_id INTEGER PRIMARY KEY,
    kurs_navn TEXT,
    lærer_id INTEGER,
    FOREIGN KEY (lærer_id) REFERENCES lærere_3NF (

lærer_id)
)
''')

cursor.execute('''
CREATE TABLE student_kurs (
    student_id INTEGER,
    kurs_id INTEGER,
    PRIMARY KEY (student_id, kurs_id),
    FOREIGN KEY (student_id) REFERENCES studenter (student_id),
    FOREIGN KEY (kurs_id) REFERENCES kurs (kurs_id)
)
''')

# Legge til data i de normaliserte tabellene
cursor.execute("INSERT INTO studenter (navn) VALUES ('Ola Nordmann')")
cursor.execute("INSERT INTO kurs (kurs_navn, lærer_id) VALUES ('Matematikk', 1)")
cursor.execute("INSERT INTO student_kurs (student_id, kurs_id) VALUES (1, 1)")

connection.commit()
connection.close()

6. Evaluering (Evaluating)

Emne: Evaluering av Normalisering og Dekomponering

Logisk tilnærming: Lær hvordan du evaluerer om en database er riktig normalisert, og hvilke kompromisser som kan gjøres mellom normalisering og ytelse.
Programmatisk tilnærming: Skriv skript for å analysere en databasestruktur og identifisere eventuelle normaliseringsproblemer, og vurder mulige løsninger.
Praktisk tilnærming: Gjennomfør en revisjon av en eksisterende database for å vurdere nivået av normalisering og anbefale forbedringer.

# Evaluerer om en database er riktig normalisert
def evaluer_normalisering(cursor):
    cursor.execute('PRAGMA foreign_key_list(elever_3NF)')
    result = cursor.fetchall()
    if not result:
        print("Tabellen elever_3NF har ingen utenlandske nøkler, mulig mangel på normalisering.")
    else:
        print("Tabellen elever_3NF har riktige relasjoner.")
        
connection = sqlite3.connect('skole.db')
cursor = connection.cursor()

evaluer_normalisering(cursor)

connection.close()

Konklusjon

Denne fullstendige tilnærmingen til normalisering dekker alle nivåer fra videregående skole til universitetsnivå, basert på Blooms taksonomi. Ved å bruke logiske, programmatiske og praktiske eksempler, vil du utvikle en dyp forståelse for hvordan normalisering fungerer, hvordan det forbedrer dataintegritet, og hvordan det kan implementeres i virkelige databaser for å håndtere kompleks datamodellering. Dette vil ruste deg med de nødvendige ferdighetene for å sikre at dine databasesystemer er optimalisert for både ytelse og sikkerhet.

Denne veiledningen er optimalisert for studenter, utviklere, og IT-fagfolk som ønsker en grundig forståelse av normalisering og hvordan det brukes til å designe effektive og sikre databaser.