20TD02U_ForAlle_Blooms_Side_51_Database_Databasesystem - itnett/FTD02H-N GitHub Wiki

For å gi en grundig, programmatisert tilnærming til temaet "Databasesystem", vil vi strukturere læringen etter Blooms taksonomi, som vil ta deg fra grunnleggende kunnskap til avansert forståelse og anvendelse av databasesystemer. Denne tilnærmingen vil dekke alle nødvendige aspekter ved databasesystemer, inkludert oppbygging, virkemåte, bruk, og sikkerhet, med fokus på IT-drift og sikkerhet.

Videregående Skole Nivå

1. Kunnskap (Remembering)

Emne: Grunnleggende Databasesystemer

  • Logisk tilnærming: Start med å lære hva et databasesystem er, hva det brukes til, og hvilke hovedkomponenter det består av (f.eks. DBMS, tabeller, spørringer, indekser).
  • Programmatisk tilnærming: Opprett en enkel SQLite-database med Python for å illustrere hvordan data kan lagres og hentes ut.
  • Praktisk tilnærming: Installer SQLite på datamaskinen din og opprett en enkel database som lagrer informasjon om elever.
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 og Databasemanipulasjon

  • Logisk tilnærming: Forstå hvordan SQL (Structured Query Language) brukes til å manipulere data i en database.
  • Programmatisk tilnærming: Bruk Python til å kjøre grunnleggende SQL-kommandoer som SELECT, INSERT, UPDATE, DELETE på SQLite-databasen.
  • Praktisk tilnærming: Skriv SQL-kommandoer for å legge til, oppdatere, hente, og slette data fra tabellen som inneholder elevinformasjon.
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()

Høyskole Nivå

3. Anvendelse (Applying)

Emne: Relasjonsdatabaser og Normalisering

  • Logisk tilnærming: Forstå hvordan relasjonsdatabaser fungerer, og hvorfor normalisering er viktig for å redusere redundans og sikre dataintegritet.
  • Programmatisk tilnærming: Opprett flere tabeller og bruk fremmednøkler for å etablere relasjoner mellom tabellene.
  • Praktisk tilnærming: Normaliser en eksisterende database ved å dele den opp i mindre tabeller som hver oppfyller 1NF, 2NF, og 3NF.
# Eksempel på normalisering: Deling av tabellen elever for å eliminere redundans
connection = sqlite3.connect('skole.db')
cursor = connection.cursor()

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)
)
''')

connection.commit()
connection.close()

4. Analyse (Analyzing)

Emne: Databasemodellering og ER-diagrammer

  • Logisk tilnærming: Lær hvordan man lager ER-diagrammer (Entity-Relationship Diagram) for å visualisere hvordan dataene er koblet sammen i en database.
  • Programmatisk tilnærming: Bruk et verktøy som dbdiagram.io eller Lucidchart for å lage et ER-diagram som representerer databasen du har opprettet.
  • Praktisk tilnærming: Lag et ER-diagram som viser relasjonene mellom tabellene elever, klasser, og fag.

Universitets Nivå

5. Syntese (Synthesizing)

Emne: Brukeradministrasjon og Sikkerhet i Databaser

  • Logisk tilnærming: Forstå hvordan tilgangskontroll og brukeradministrasjon fungerer for å beskytte data i en database.
  • Programmatisk tilnærming: Implementer brukeradministrasjon i en MySQL-database, og legg til roller og rettigheter for forskjellige brukere.
  • Praktisk tilnærming: Opprett brukere med spesifikke rettigheter, og sikre databasen ved å implementere kryptering for sensitive data.
-- Oppretting av en bruker med begrensede rettigheter
CREATE USER 'student'@'localhost' IDENTIFIED BY 'passord123';
GRANT SELECT, INSERT ON skole.* TO 'student'@'localhost';

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

6. Evaluering (Evaluating)

Emne: Backup, Restore og Logging

  • Logisk tilnærming: Forstå viktigheten av backup, restore, og logging i en database for å sikre at data kan gjenopprettes og at all aktivitet kan spores.
  • Programmatisk tilnærming: Implementer et skript som automatisk tar backup av databasen og logger alle endringer som gjøres.
  • Praktisk tilnærming: Konfigurer et cron-jobb for å automatisk utføre daglig backup av MySQL-databasen, 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: Avanserte Databasesystemer og Datavisualisering

  • Logisk tilnærming: Lær hvordan avanserte databasesystemer som distribuerte databaser fungerer, og hvordan man kan visualisere data for bedre innsikt.
  • Programmatisk tilnærming: Bruk Python og matplotlib for å visualisere data fra databasen i form av grafer og diagrammer.
  • Praktisk tilnærming: Implementer en datavisualiseringsløsning som trekker data fra en database og viser det i sanntid.
import matplotlib.pyplot as plt
import mysql.connector

def fetch_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

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

Konklusjon

Denne tilnærmingen tar deg fra grunnleggende til avansert forståelse av databasesystemer ved å bruke Blooms taksonomi som en guide. Ved å bruke praktiske, logiske og programmatiske eksempler vil du ikke bare forstå teorien bak databasesystemer, men også være i stand til å implementere, administrere og sikre dem på en effektiv måte. Dette vil ruste deg med de nødvendige ferdighetene for å håndtere komplekse databaseløsninger i virkelige driftsmiljøer, spesielt innen IT-drift og sikkerhet.

Denne veiledningen er utformet for studenter, utviklere, og IT-fagfolk som ønsker en strukturert og grundig forståelse av databasesystemer, fra grunnleggende oppsett til avansert administrasjon og sikkerhet.