20TD02U_ForAlle_Blooms_Side_50_Database_1 - itnett/FTD02H-N GitHub Wiki

For å gi en grundig, programmatiske tilnærming til temaet "Database", vil vi bruke Blooms taksonomi for å strukturere læringsprosessen fra videregående skole til universitetsnivå. Dette dekker de nødvendige nivåene fra grunnleggende kunnskap til avansert syntese og evaluering. Vi vil også inkludere logiske, praktiske og anvendelsesbaserte tilnærminger innen IT-drift og sikkerhet.

Videregående Skole Nivå

1. Kunnskap (Remembering)

Emne: Databasesystem

  • Logisk tilnærming: Start med å lære grunnleggende begreper som database, tabell, rad, kolonne, primærnøkkel, og fremmednøkkel.
  • Programmatisk tilnærming: Lag en enkel SQLite-database med Python for å illustrere hvordan data kan lagres og hentes ut.
  • Praktisk tilnærming: Installer SQLite og bruk den til å opprette en enkel database med en tabell for å lagre elevdata.
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
)
''')

connection.commit()
connection.close()

2. Forståelse (Understanding)

Emne: SQL

  • Logisk tilnærming: Forstå grunnleggende SQL-kommandoer som SELECT, INSERT, UPDATE, DELETE.
  • Programmatisk tilnærming: Bruk Python til å kjøre SQL-kommandoer på SQLite-databasen.
  • Praktisk tilnærming: Skriv SQL-kommandoer for å legge til, oppdatere, hente og slette elevdata i databasen.
connection = sqlite3.connect('skole.db')
cursor = connection.cursor()

# 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())

connection.commit()
connection.close()

3. Anvendelse (Applying)

Emne: ER-diagram

  • Logisk tilnærming: Lær hvordan man visualiserer relasjoner mellom tabeller ved hjelp av ER-diagrammer (Entity-Relationship Diagram).
  • Programmatisk tilnærming: Bruk verktøy som dbdiagram.io eller Lucidchart for å lage et ER-diagram for en enkel skole-database.
  • Praktisk tilnærming: Opprett et ER-diagram som viser relasjonene mellom tabellene elever, klasser, og fag.

Høyskole Nivå

4. Analyse (Analyzing)

Emne: Normalisering

  • Logisk tilnærming: Forstå begreper som normalisering og de forskjellige normalformer (1NF, 2NF, 3NF).
  • Programmatisk tilnærming: Normaliser en gitt database ved å dele opp tabeller for å eliminere redundans.
  • Praktisk tilnærming: Ta en eksisterende database og normaliser den til 3NF.
# Eksempel på normalisering: Deling av tabellen elever for å eliminere redundans
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)
)
''')

5. Syntese (Synthesizing)

Emne: Brukeradministrasjon og Indeksering

  • Logisk tilnærming: Forstå hvordan brukeradministrasjon og indeksering fungerer for å optimalisere ytelsen og sikkerheten i en database.
  • Programmatisk tilnærming: Implementer brukeradministrasjon og indeksering i en MySQL-database.
  • Praktisk tilnærming: Opprett brukere med ulike tilgangsnivåer, og legg til indekser på store tabeller for å forbedre ytelsen.
-- Oppretting av en bruker med begrensede rettigheter
CREATE USER 'student'@'localhost' IDENTIFIED BY 'passord123';
GRANT SELECT, INSERT ON skole.* TO 'student'@'localhost';

-- Oppretting av indekser for å forbedre søkeytelsen
CREATE INDEX idx_navn ON elever (navn);
CREATE INDEX idx_klasse_id ON elever (klasse_id);

Universitets Nivå

6. Evaluering (Evaluating)

Emne: Logging, Backup og Restore

  • Logisk tilnærming: Forstå viktigheten av logging, backup og restore i en databasesikkerhet og dataintegritet.
  • Programmatisk tilnærming: Implementer automatisert backup og restore ved bruk av shell-skript.
  • Praktisk tilnærming: Sett opp et cron-jobb for å automatisere daglig backup av en MySQL-database, og test gjenopprettingsprosessen.
#!/bin/bash

# Automatisk backup av MySQL-database
backup_dir="/backup/mysql"
timestamp=$(date +"%F")
backup_file="$backup_dir/skole_$timestamp.sql"

mkdir -p "$backup_dir"
mysqldump -u root -p'yourpassword' skole > "$backup_file"

# Automatisert restore (for testformål)
mysql -u root -p'yourpassword' skole < "$backup_file"

7. Skapelse (Creating)

Emne: Kryptering og Datavisualisering

  • Logisk tilnærming: Forstå hvordan kryptering beskytter sensitiv data, og hvordan datavisualisering hjelper med å forstå store mengder data.
  • Programmatisk tilnærming: Implementer AES-kryptering for sensitive felt i databasen, og bruk Python og matplotlib for å visualisere data fra databasen.
  • Praktisk tilnærming: Krypter feltene som inneholder sensitive data som personnummer, og visualiser elevprestasjoner ved hjelp av grafer.
from Crypto.Cipher import AES
import base64
import mysql.connector
import matplotlib.pyplot as plt

def encrypt(data, key):
    cipher = AES.new(key.encode('utf-8'), AES.MODE_ECB)
    padded_data = data + (16 - len(data) % 16) * ' '
    encrypted = base64.b64encode(cipher.encrypt(padded_data.encode('utf-8')))
    return encrypted.decode('utf-8')

# Kryptering av sensitiv data og lagring i MySQL
cnx = mysql.connector.connect(user='root', password='yourpassword', host='localhost', database='skole')
cursor = cnx.cursor()
key = "ThisIsASecretKey"

cursor.execute("INSERT INTO elever (navn, alder, personnummer) VALUES (%s, %s, %s)", 
               ("Ola Nordmann", 16, encrypt("12345678910", key)))

cnx.commit()
cursor.close()
cnx.close()

# Datavisualisering av elevdata
def fetch_elev_data():
    cnx = mysql.connector.connect(user='root', password='yourpassword', host='localhost', database='skole')
    cursor = cnx.cursor()
    cursor.execute("SELECT navn, alder FROM elever")
    data = cursor.fetchall()
    cursor.close()
    cnx.close()
    return data

elev_data = fetch_elev_data()
navn, alder = zip(*elev_data)
plt.bar(navn, alder)
plt.xlabel('Navn')
plt.ylabel('Alder')
plt.title('Elev Alder Visualisering')
plt.show()

Konklusjon

Denne omfattende tilnærmingen tar studentene fra videregående til universitetsnivå gjennom en fullstendig programmeringsorientert reise innen databaseteknologi. Ved å følge Blooms taksonomi, har vi strukturert læringsprosessen for å sikre at studentene utvikler en dyp forståelse, anvender kunnskap praktisk, og til slutt er i stand til å skape og evaluere komplekse databaseløsninger i ulike driftsmiljøer. Gjennom denne reisen blir de også i stand til å håndtere databaser med fokus på sikkerhet, ytelse og dataintegritet.

Denne veiledningen er optimalisert for lærere, utviklere, og studenter som ønsker en strukturert, fullstendig og praktisk tilnærming til læring og anvendelse av databasekonsepter fra grunnleggende nivå til avansert bruk i IT-drift og sikkerhet.