20TD02U_ForAlle_Blooms_Side_52_Database_SQL - itnett/FTD02H-N GitHub Wiki

For å gi en grundig, programmatisert tilnærming til emnet "SQL" (Structured Query Language), vil vi strukturere læringen basert på Blooms taksonomi. Denne tilnærmingen dekker grunnleggende til avanserte konsepter innen SQL, og inkluderer programmatiske, logiske, og praktiske tilnærminger som tar leseren fra videregående skole til universitetsnivå. Fokus vil være på IT-drift og sikkerhet, med en fullstendig innføring i SQL for databaser.

Videregående Skole Nivå

1. Kunnskap (Remembering)

Emne: Grunnleggende SQL-kommandoer

  • Logisk tilnærming: Start med å lære grunnleggende SQL-kommandoer som SELECT, INSERT, UPDATE, DELETE.
  • Programmatisk tilnærming: Bruk Python for å kjøre SQL-kommandoer på en SQLite-database.
  • Praktisk tilnærming: Installer SQLite og bruk det til å lage en enkel database som inneholder informasjon om elever. Skriv SQL-kommandoer for å legge til, oppdatere, slette og hente data fra databasen.
import sqlite3

# Opprette en enkel SQLite-database og tabell
connection = sqlite3.connect('skole.db')
cursor = connection.cursor()

cursor.execute('''
CREATE TABLE elever (
    id INTEGER PRIMARY KEY,
    navn TEXT,
    alder INTEGER
)
''')

# Legge til data
cursor.execute("INSERT INTO elever (navn, alder) VALUES ('Ola Nordmann', 16)")
cursor.execute("INSERT INTO elever (navn, alder) VALUES ('Kari Nordmann', 17)")

# Hente ut data
cursor.execute("SELECT * FROM elever")
print(cursor.fetchall())

# Oppdatere data
cursor.execute("UPDATE elever SET alder = 18 WHERE navn = 'Ola Nordmann'")

# Slette data
cursor.execute("DELETE FROM elever WHERE navn = 'Kari Nordmann'")

connection.commit()
connection.close()

2. Forståelse (Understanding)

Emne: Filtrering og Sortering av Data

  • Logisk tilnærming: Forstå hvordan man bruker WHERE, ORDER BY, og LIMIT for å filtrere, sortere og begrense resultater i SQL.
  • Programmatisk tilnærming: Implementer filtrering og sortering i Python ved å bruke SQL-spørringer på en SQLite-database.
  • Praktisk tilnærming: Utfør praktiske øvelser ved å skrive SQL-spørringer som henter spesifikke data fra databasen basert på kriterier som alder eller navn, og sorter resultatene etter navn eller alder.
connection = sqlite3.connect('skole.db')
cursor = connection.cursor()

# Filtrere data med WHERE
cursor.execute("SELECT * FROM elever WHERE alder > 16")

# Sortere data med ORDER BY
cursor.execute("SELECT * FROM elever ORDER BY navn ASC")

# Begrense resultater med LIMIT
cursor.execute("SELECT * FROM elever ORDER BY alder DESC LIMIT 1")

print(cursor.fetchall())

connection.close()

Høyskole Nivå

3. Anvendelse (Applying)

Emne: Joins og Relasjoner

  • Logisk tilnærming: Forstå hvordan man bruker JOIN-kommandoer til å kombinere data fra flere tabeller basert på relasjoner mellom dem.
  • Programmatisk tilnærming: Bruk SQL til å opprette flere tabeller i en SQLite-database og koble dem sammen ved hjelp av INNER JOIN, LEFT JOIN, RIGHT JOIN.
  • Praktisk tilnærming: Skriv SQL-spørringer som kombinerer data fra tabellene elever, klasser, og fag for å vise hvilke elever som tar hvilke fag.
connection = sqlite3.connect('skole.db')
cursor = connection.cursor()

# Opprette flere tabeller og relasjoner
cursor.execute('''
CREATE TABLE klasser (
    klasse_id INTEGER PRIMARY KEY,
    klasse_navn TEXT
)
''')

cursor.execute('''
CREATE TABLE fag (
    fag_id INTEGER PRIMARY KEY,
    fag_navn TEXT
)
''')

cursor.execute('''
CREATE TABLE elever (
    id INTEGER PRIMARY KEY,
    navn TEXT,
    alder INTEGER,
    klasse_id INTEGER,
    fag_id INTEGER,
    FOREIGN KEY (klasse_id) REFERENCES klasser (klasse_id),
    FOREIGN KEY (fag_id) REFERENCES fag (fag_id)
)
''')

# Koble tabellene sammen med INNER JOIN
cursor.execute('''
SELECT elever.navn, klasser.klasse_navn, fag.fag_navn
FROM elever
INNER JOIN klasser ON elever.klasse_id = klasser.klasse_id
INNER JOIN fag ON elever.fag_id = fag.fag_id
''')

print(cursor.fetchall())

connection.close()

4. Analyse (Analyzing)

Emne: Aggregatfunksjoner og Gruppering

  • Logisk tilnærming: Forstå hvordan man bruker SQL-aggregeringsfunksjoner som COUNT, SUM, AVG, MAX, MIN sammen med GROUP BY for å oppsummere og analysere data.
  • Programmatisk tilnærming: Implementer SQL-spørringer som grupperer og oppsummerer data fra tabeller i SQLite.
  • Praktisk tilnærming: Analyser data ved å telle antall elever i hver klasse, beregne gjennomsnittsalder i hver klasse, eller finne den eldste eleven i hver klasse.
connection = sqlite3.connect('skole.db')
cursor = connection.cursor()

# Telle antall elever i hver klasse
cursor.execute('''
SELECT klasser.klasse_navn, COUNT(elever.id) AS antall_elever
FROM elever
INNER JOIN klasser ON elever.klasse_id = klasser.klasse_id
GROUP BY klasser.klasse_navn
''')

# Beregne gjennomsnittsalder per klasse
cursor.execute('''
SELECT klasser.klasse_navn, AVG(elever.alder) AS gjennomsnittsalder
FROM elever
INNER JOIN klasser ON elever.klasse_id = klasser.klasse_id
GROUP BY klasser.klasse_navn
''')

# Finne den eldste eleven i hver klasse
cursor.execute('''
SELECT klasser.klasse_navn, MAX(elever.alder) AS eldste_elev
FROM elever
INNER JOIN klasser ON elever.klasse_id = klasser.klasse_id
GROUP BY klasser.klasse_navn
''')

print(cursor.fetchall())

connection.close()

Universitets Nivå

5. Syntese (Synthesizing)

Emne: Underforespørsler og Kompleks SQL

  • Logisk tilnærming: Lær hvordan man skriver komplekse SQL-spørringer som bruker underforespørsler (subqueries) for å trekke ut mer komplekse data.
  • Programmatisk tilnærming: Implementer SQL-spørringer med underforespørsler for å løse komplekse dataproblemer i SQLite.
  • Praktisk tilnærming: Skriv SQL-spørringer som finner elever som er eldre enn gjennomsnittsalderen i klassen deres ved å bruke underforespørsler.
connection = sqlite3.connect('skole.db')
cursor = connection.cursor()

# Finne elever som er eldre enn gjennomsnittsalderen i klassen deres
cursor.execute('''
SELECT navn, alder
FROM elever
WHERE alder > (
    SELECT AVG(alder)
    FROM elever AS e
    WHERE e.klasse_id = elever.klasse_id
)
''')

print(cursor.fetchall())

connection.close()

6. Evaluering (Evaluating)

Emne: Databaseytelse og Indeksering

  • Logisk tilnærming: Forstå hvordan indeksering påvirker ytelsen til SQL-spørringer, og hvordan man kan optimalisere spørringer.
  • Programmatisk tilnærming: Opprett indekser på tabeller og sammenlign ytelsen til spørringer før og etter indeksering.
  • Praktisk tilnærming: Bruk SQL-verktøy som EXPLAIN for å analysere ytelsen til SQL-spørringer og optimaliser dem ved å legge til indekser.
connection = sqlite3.connect('skole.db')
cursor = connection.cursor()

# Opprette en indeks for å forbedre ytelsen til spørringer
cursor.execute('CREATE INDEX idx_navn ON elever (navn)')

# Sammenligne ytelsen med og uten indeks ved hjelp av EXPLAIN
cursor.execute('EXPLAIN QUERY PLAN SELECT * FROM elever WHERE navn = "Ola Nordmann"')
print(cursor.fetchall())

connection.close()

7. Skapelse (Creating)

Emne: Sikkerhet og Brukeradministrasjon i SQL

  • Logisk tilnærming: Forstå hvordan man implementerer sikkerhetsfunksjoner i SQL, inkludert tilgangskontroll og kryptering.
  • Programmatisk tilnærming: Opprett brukere med forskjellige tilgangsnivåer og implementer kryptering av sensitive data i en SQL-database.
  • Praktisk tilnærming: Konfigurer en SQL-server for å beskytte sensitive data ved

å kryptere felt som inneholder personnummer, og administrere brukertilgang med roller og rettigheter.

-- Opprette brukere og administrere tilgangsnivåer
CREATE USER 'student'@'localhost' IDENTIFIED BY 'passord123';
GRANT SELECT, INSERT ON skole.* TO 'student'@'localhost';

-- Kryptering av sensitive data
CREATE TABLE sensitive_data (
    id INT AUTO_INCREMENT PRIMARY KEY,
    data BLOB NOT NULL,
    encryption_key VARBINARY(32) NOT NULL
);

Konklusjon

Denne programmatiske tilnærmingen til SQL dekker alle nivåer fra videregående skole til universitetsnivå, basert på Blooms taksonomi. Ved å bruke praktiske, logiske og programmatiske eksempler, vil du utvikle en dyp forståelse for hvordan SQL fungerer, samt hvordan det kan brukes til å manipulere, analysere, og beskytte data i en database. Denne kunnskapen er avgjørende for å håndtere komplekse databaseløsninger innen IT-drift og sikkerhet.

Denne veiledningen er designet for studenter, utviklere, og IT-fagfolk som ønsker en grundig og strukturert tilnærming til læring og anvendelse av SQL.