Klausur Fragen

• SHOW DATABASES

  • zeigt alle Datenbanken

• CREATE DATABASE datenbankname

  • CREATE DATABASE zoo

• USE datenbankname

• Hilft um die auf eine andern Datenbank zu wechseln wenn man gerade aktik auf eine Datenbank ist und nun auf eine anderen möchte

• DROP DATABASE datenbankname

• SHOW TABLES;

  • MySQL zeigt dir alle Tabellen an, die in der aktuell aktiven Datenbank liegen

  • Die aktive Datenbank musst du vorher mit USE <datenbankname>; gesetzt haben.

• SHOW TABLES FROM fom;

  • Du gibst explizit an, aus welcher Datenbank MySQL die Tabellen zeigen soll – unabhängig davon, welche aktuell aktiv ist.

  • Du brauchst vorher kein USE gemacht zu haben.

• DESCRIBE tabellenname; oder DESC tabellenname;

• Zeigt dir die Struktur an

• DESCRIBE zoo.kunden;

  • Wenn vorher kein USE datenname ausgeführt wurde

• Gibt das zurück :

• | Field    | Type        | Null | Key | Default | Extra          |

  +----------+-------------+------+-----+---------+----------------+

  | id       | INT         | NO   | PRI | NULL    | auto_increment |

  | name     | VARCHAR(50) | YES  |     | NULL    |                |

  | geburt   | DATE        | YES  |     | NULL    |                |

  +----------+-------------+------+-----+---------+----------------+

• DROP TABLE datenname;

• CREATE TABELE datenbankname (

  feldname_1 datentyp,

    feldname_2 datentyp,

    ...

    feldname_n datentyp

  );

  
  

• INSERT INTO tabellenname

  (feld_1, feld_2, ..., feld_n)

  VALUES

  (wert_1, wert_2, ..., wert_n);

• INSERT INTO kunden (id, name, geburtstag)

  VALUES (1, 'Mia Meier', '2000-05-12');

• INSERT INTO mitglieder (id, name, beitritt)

  VALUES 

  (1, 'Lisa Lange', '2023-01-10'),

  (2, 'Tobi Thiel', '2024-02-20'),

  (3, 'Sami Schmidt', '2025-05-01');

• SELECT * FROM tabellenname;

• Wenn vorher kein USE datenname ausgeführt wurde

  • SELECT * FROM zoo.kunden;

• Beispiel:

• +----+------------+-------------+

  | id | name       | ort         |

  +----+------------+-------------+

  | 1  | Mia Müller | Köln        |

  | 2  | Leo Lange  | Düsseldorf  |

• In großen Datenbanken mit vielen Spalten (z. B. 50 oder 100) ist SELECT * ineffizient.

• Dort schreibt man lieber gezielt:

  • SELECT name, ort FROM kunden;

  
  

• Der Datentyp bestimmt:

  • Welche Art von Wert in einem Feld gespeichert werden darf (Text? Zahl? Ja/Nein?)

  • Wie viel Speicherplatz belegt wird

  • Wie der Wert intern verarbeitet wird (Sortierung, Vergleiche, Rechenoperationen)

• ihij

  • Kategorie Text

    • Beispiele: Namen, Städte, E-Mail

    • Datentyp: CHAR(x), VARCHAR(x), TE

  • Kategorie Numerisch ganzzahlig

    • Beispiele: Alter, ID, Anzahl

    • Datentyp: INT, TINYINT, BIGINT

  • Kategorie Numerisch reell

    • Beispiele: Preis, Gewicht, Temperatur

    • Datentyp: FLOAT, DOUBLE, DECIMAL

  • Kategorie Logisch

    • Beispiele: Wahr/Falsch, Ja/Nein

    • Datentyp: BOOLEAN (bzw. TINYINT(1))

  • Kategorie Sonstige

    • Beispiele: Datum, Uhrzeit, Blob, JSON

    • Datentyp: DATE, TIME, DATETIME, BLOB

•  Für Texte gedacht

•  Reserviert es immer gleich viel Speicher

• Du kannst CHAR(1) bis CHAR(255) schreiben.

• Das bedeutet: Du kannst Texte bis zu 255 Zeichen lang speichern.

• Aber bei CHAR(255) werden immer 255 Zeichen Speicherplatz verwendet, auch wenn du nur ‘Ali’ speicherst.

• Am besten geeignet:

  • Wenn man ganz sicher weißt, dass alle Werte immer exakt gleich lang sind

  • Beispiele:

    • Ländercode (DE, FR, IT)

    • ISO-Codes wie ISO3166, ISO9001

    • Geschlechtskürzel (M, W, D)

    • Postleitzahl (z. B. in DE)

  
  

• Geeignet für Text

• Es speichert nur so viele Zeichen, wie wirklich gebraucht werden (+1–2 Bytes Info).

• Man kann kurze und lange Werte mischen, ohne Platz zu verschwenden.

• Üblich für Namen, E-Mails usw.

  • Weil Textlängen unterschiedlich sind

• perfekt für Benutzereingaben

  • Man weißt nie, wie lang ein Name oder ein Kommentar ist – VARCHAR passt sich an

• 65.535 Byte ist das absolute Limit in MySQL

  • Das gilt pro Zeile insgesamt, also nicht nur für ein Feld!

•  Wenn maximale Länge ≤ 255 Zeichen ➜ +1 Byte für die Längeninfo

  • VARCHAR(100)

    • Man speichert z. B. 'Ali' → 3 Zeichen

      • MySQL braucht:

        • 3 Bytes für 'Ali'

      • 1 Byte für die Längenangabe

        • Insgesamt: 4 Bytes

• Wenn maximale Länge ≥ 256 Zeichen ➜ +2 Bytes für die Längeninfo

  • VARCHAR(500)

    • Man speichert z. B. 'Hallo' → 5 Zeichen

      ➡️ MySQL braucht:

      • 5 Bytes für 'Hallo'

      • 2 Bytes für die Längenangabe

        ✅ Insgesamt: 7 Bytes

• 
  

• Das sind Datentypen für sehr große Inhalte, also:

  • sehr lange Texte (z. B. Artikel, Kommentare, Lebensläufe)

  • Binärdaten (z. B. Bilder, PDFs, Videos, Dateien)

• TEXT:

  • Beachtet nicht Groß- und Kleinschreibung

  • CREATE TABLE artikel (

      id INT,

      titel VARCHAR(255),

      inhalt TEXT

    );

  • INSERT INTO artikel (id, titel, inhalt)

    VALUES (

      1,

      'Wie man SQL lernt',

      'In diesem Artikel lernen Sie die Grundlagen von SQL...'

    );

• BLOB:

  • Beachtet Groß- und Kleinschreibung

  • CREATE TABLE uploads (

      id INT,

      dateiname VARCHAR(255),

      datei BLOB

    );

  • INSERT INTO

    uploads (id, dateiname, datei)

    VALUES

    (1, 'lebenslauf.pdf', LOAD_FILE('/pfad/zur/datei/lebenslauf.pdf'));

• DEFAULT ist bei beiden nicht erlaubt

• TINYINT

  • 1 Byte

  • Wertebereich (normal)

    • -128 bis 127

  • Wertebereich (UNSIGNED)

    • 0 bis 255

• SMALLINT

  • 2 Byte

  • Wertebereich (normal)

    • –32.768 bis +32.767

  • Wertebereich (UNSIGNED)

    • 0 bis 65.535

• MEDIUMINT

  • 3 Bytes

  • Wertebereich (normal)

    • –8.388.608 bis +8.388.607

  • Wertebereich (UNSIGNED)

    • 0 bis 16.777.215

• INT

  • 4 Bytes

  • Wertebereich (normal)

    • –2.147.483.648 bis +2.147.483.647

  • Wertebereich (UNSIGNED)

    • 0 bis 4.294.967.295

• BIGINT

  • 8 Bytes

  • Wertebereich (normal)

    • –9 Trillionen bis +9 Trillionen

  • Wertebereich (UNSIGNED)

    • 0 bis 18 Triliionen

  
  

• n = gesamte Anzahl an Ziffern (inkl. Vorkomma + Nachkomma)

• d = Anzahl Nachkommastellen

• FLOAT(n,d)

  • mittel (max 24 Nachkommastellen)

  • schnell, aber ungenau bei Rechenfehlern

  • FLOAT(6,2) → erlaubt z. B. 1234.56

• DOUBLE(n,d)

  • hoch (max 53 Nachkommastellen)

  • für sehr große oder präzise Werte

• DECIMAL(n,d)

  • exakt

  • perfekt für Geld, wird als Zeichen gespeichert (keine Rundungsfehler)

• YEAR:

  • Nur Jahre von 1901 bis 2155

  • Alles außerhalb → ungültig → wird zu 0000 gesetzt

  • 00–69 → interpretiert MySQL als 2000–2069

  • Am besten immer vierzahlen angeben

  
  

• DATE:

  • Format:

    • YYYY-MM-DD ->

  • Bereich:

    • von 1000-01-01 bis 9999-12-31 

  • Beispiel:

    • '2025-06-16

    
    

• DATETIME:

  • Bereich:

    • 1000-01-01 00:00:00 bis 9999-12-31 23:59:59

  • Format:

    • YYYY-MM-DD HH:MM:SS

  • Beispiel:

    • '2025-06-16 13:45:00'

• TIME:

  • Bereich:

    • -838:59:59 bis 838:59:59

  • Format:

    • HH:MM:SS

  • Beispiel:

    • '13:45:00'

  
  

• TIMESTAMP speichert automatisch das aktuelle Datum + aktuelle Uhrzeit,

  wenn ein Datensatz eingefügt oder geändert wird

• Beispiel:

  • CREATE TABLE login_log (

      benutzer VARCHAR(50),

      login_zeit TIMESTAMP

    );

  • INSERT INTO login_log (benutzer) VALUES ('Ali');

  • login_zeit wird automatisch z. B. 2025-06-16 18:45:32

• SET ist ein Datentyp, mit dem du eine oder mehrere Optionen aus einer festen Liste in einem einzigen Feld speichern kannst

• Beispiel:

  • CREATE TABLE benutzer (

      name VARCHAR(50),

      interessen SET('Sport', 'Musik', 'Kunst', 'Reisen')

    );

  • INSERT INTO benutzer (name, interessen)

    VALUES ('Ali', 'Sport,Musik');

• Wichtige Regeln:

  • Man kann mehrere Werte auswählen

  • Maximal 64 verschiedene Werte in der Liste erlaubt

  • Keine Kommas im Wert selbst

    • Komma ist Trennung

    
    

  
  

• ENUM erlaubt dir, genau einen Wert aus einer festen Liste auszuwählen

• Beispiel:

  • CREATE TABLE benutzer (

      name VARCHAR(50),

      geschlecht ENUM('männlich', 'weiblich', 'divers')

    );

• Mann kann nur eines davon eintragen

• Max Anzahl Werte sind 65535

• Beispiel:

  • CREATE TABLE pizza (

      Bezeichnung VARCHAR(30),

      Preis FLOAT(4,2),

      Zusatz SET("Knoblauch", "extra scharf", "doppelt Käse"),

      Groesse ENUM("groß", "mittel", "klein")

    );

  
  

• Der Primärschlüssel ist eine Spalte (oder Kombination aus Spalten),

  die jeden Datensatz in einer Tabelle eindeutig identifiziert

• Merkmal:

  • Eindeutig

  • NOT NULL

  • Nur 1× pro Tabelle

• Beispiel:

  • CREATE TABLE lieferant (

      lid INT UNSIGNED PRIMARY KEY,

      nachname VARCHAR(30)

    );

    • Jeder Lieferant braucht eine ID

    • UNSIGNED = nur positive Werte (z. B. ID: 1, 2, 3 …)

    
    

•  Ein PRIMARY KEY kann aus mehreren Spalten bestehen.

  Das nennt man dann einen zusammengesetzten (kombinierten) Schlüssel.

• Stell dir das wie einen Türschlüssel mit zwei Zacken vor:

  • Zacken 1 = fk_auftrag

  • Zacken 2 = fk_artikel

• Du hast eine Tabelle bestellposition. Eine Bestellung (fk_auftrag) kann mehrere Artikel enthalten, z. B.:

  • fk_auftrag und fk_artikel

  • 1001 fk_auftrag kann mehrfach vorkommen (weil eine Bestellung mehrere Artikel hat)

  • 200 kann bei fk_artikel mehrfach vorkommen (weil derselbe Artikel in verschiedenen Bestellungen vorkommen kann)

  • Aber: Die Kombination 1001 & 200 darf nur einmal vorkommen

    • (weil du nicht denselben Artikel zwei Mal in derselben Bestellung anlegen darfst)

    
    

• Ein UNIQUE-Feld darf keinen doppelten Wert enthalten,

  aber es darf NULL sein (leerer Wert), außer du verbietest das mit NOT NULL

• Beispiel:

  • CREATE TABLE lieferant (

      lid INT UNSIGNED PRIMARY KEY,

      nachname VARCHAR(30),

      plz CHAR(5) UNIQUE

    );

    • lid ist der eindeutige Primärschlüssel (wie ein Ausweis)

    • plz (Postleitzahl) ist einzigartig, aber kein Primärschlüssel

    • Vorteil: Es darf nur eine Zeile mit derselben plz existieren

    
    

• Kein Wert vorhanden

• NOT NULL:

  • Man muss ein Wert angeben

  • Feld dar nicht leer sein

• DEFAULT legt einen Standardwert fest,

  der automatisch in eine Spalte eingetragen wird,

  wenn du beim INSERT keinen eigenen Wert angibst

• Beispiel:

  • CREATE TABLE artikel (

      art_nr INT UNSIGNED PRIMARY KEY,

      artbez VARCHAR(30),

      einzelpreis FLOAT(6, 2) DEFAULT 0.99

    );

    • INSERT INTO artikel (art_nr, artbez)

      VALUES (101, 'Kugelschreiber');

    • Kugelschreiber wird automatsich mit dem Einzelpreis 0.99 eingetragen

• AUTO_INCREMENT sorgt dafür,

  dass die Werte in einer Spalte automatisch hochgezählt werden

• Beipiel:

  • CREATE TABLE lieferant (

    lid INT PRIMARY KEY AUTO_INCREMENT,

    nachname VARCHAR(30),

    umsatz FLOAT(6, 2) DEFAULT 0.99

    );

    • lid ist Primärschlüssel und wird automatisch gezählt → 1, 2, 3, …

    • nachname muss manuell eingetragen werden

    • umsatz wird automatisch auf 0.99 gesetzt, wenn man keinen Wert angibt

• ZEROFILL füllt Zahlen mit führenden Nullen auf

  damit sie immer eine bestimmte Länge hab

• betrifft nur ganzzahlige Datentypen wie INT, SMALLINT, TINYINT, …

• Es sorgt dafür, dass eine Ganzzahl wie 7 z. B. als 00007 angezeigt wird

  •  INT(5) → 5 Stellen = 00007.

• Vorteile:

  • Optische Einheitlichkeit – alle Nummern haben die gleiche Länge

  • Bessere Sortierbarkeit (z. B. alphabetisch in Excel)

  • Sieht professioneller aus in Berichten, Formularen, Rechnungen

  
  

  
  

  
  

  
  

• Mit diesem Befehl änderst du die Struktur einer bestehenden Tabelle –

  du fügst neue Spalten hinzu, ohne die Tabelle komplett neu zu erstellen

• ALTER TABLE tabellenname

  ADD spaltenname datentyp [weitere Attribute];

• ALTER TABLE kunde

  ADD letzter_Zugriff TIMESTAMP;

  • Das bedeutet:

    • Die bestehende Tabelle kunde bekommt eine neue Spalte letzter_Zugriff

    • Diese Spalte hat den Typ TIMESTAMP, also Datum & Uhrzeit

  • Auch mehrere Spalten gleichzeitig möglich:

    • ALTER TABLE kunde

      ADD email VARCHAR(100),

      ADD telefonnummer VARCHAR(20);

  
  

• Wenn du ALTER TABLE ... ADD ... benutzt, wird die neue Spalte standardmäßig am Ende der Tabelle hinzugefügt.

  • 1. ... ADD feld_1 datentyp_1 FIRST;

    • Fügt die Spalte ganz vorne ein – also als erste Spalte der Tabelle.

    
    

    2. ... ADD feld_1 datentyp_1 AFTER feldname_x;

    • Fügt die neue Spalte nach einer bestimmten vorhandenen Spalte ein (z. B. nach email).

    
    

• Allgemeine Form

  • ALTER TABLE tabellenname

    DROP feld_x;

• Beipiel:

  • ALTER TABLE fahrten

    DROP entfernung;

  •  Die Spalte entfernung wird vollständig aus der Tabelle fahrten gelöscht – inklusive aller Daten, die dort drin standen

• Beispiel:

  • ALTER TABLE kunde

    ADD PRIMARY KEY (kundennr);

    • MachT das Feld kundennr zum Primärschlüssel der Tabelle kunde

    • Das geht nur, wenn alle Werte in kundennr eindeutig sind und nicht NULL.

  • ALTER IGNORE TABLE kunde

    ADD PRIMARY KEY (kundennr);

    • Mit IGNORE wird beim Ausführen versucht, Konflikte zu ignorieren oder aufzulösen

    • Wenn es doppelte Werte in kundennr gibt:

      • Ohne IGNORE: ❌ Es kommt zu einem Fehler.

      • Mit IGNORE: ✅ Die Zeilen mit doppelten Werten werden gelöscht oder ignoriert, sodass der Primärschlüssel trotzdem gesetzt werden kann.

      
      

• ALTER TABLE tabellenname

  DROP PRIMARY KEY;

• Das entfernt den bestehenden Primärschlüssel aus einer Tabelle.

  
  

• Wichtig: Danach hat die Tabelle keinen Primärschlüssel mehr, das heißt:

  
  

  • Es gibt keine eindeutige Identifikation mehr für Datensätze.

  • Du kannst NULL- oder doppelte Werte im ehemaligen Schlüssel-Feld speichern (sofern nicht anders eingeschränkt).

  
  

• Ein Index:

  • Beschleunigt Suchabfragen (SELECT) auf bestimmten Spalten.

  • Macht WHERE, JOIN, ORDER BY, GROUP BY usw. viel schneller.

  • Hat keinen Einfluss auf die Daten selbst.

• Hinzufügen eines INDEX:

  • Ohne Indexnamen:

    • ALTER TABLE kunden

      ADD INDEX (plz);

  • Mit Indexnamen:

    • ALTER TABLE kunden

      ADD INDEX idx_plz (plz);

  • Technisch gleich aber später wenn man den löschen möchte einfacher:

    • ALTER TABLE kunden

      DROP INDEX idx_plz;

• Beispiel:

  • ALTER TABLE vertreter

    ADD UNIQUE (region);

    • In der Tabelle vertreter darf jede Region nur einmal vorkommen.

      Zwei Vertreter dürfen nicht dieselbe Region haben.

• Merkmale:

  • Alle Werte in diesem Feld müssen einzigartig sein.

  • Doppelte Einträge sind nicht erlaubt.

  • Es wird automatisch ein eindeutiger Index auf dieses Feld erstellt.

  • Du kannst mehrere UNIQUE Felder haben

  • Du darfst mehrere NULL Werte haben, außer du verbietest es extra.

  
  

  
  

• Ändern eines Standardwerts (SET DEFAULT)

  • ALTER TABLE tabellenname

      ALTER feld_x SET DEFAULT wert;

    •  Damit legst du fest, welcher Wert automatisch verwendet wird, wenn kein Wert für dieses Feld beim Einfügen angegeben wird.

  • Beispiel:

    • ALTER TABLE fahrten

        ALTER entfernung SET DEFAULT 0;

      • Wenn du später INSERT INTO fahrten ... machst und keine Entfernung angibst, wird automatisch 0 eingesetzt

•  Löschen eines Standardwerts (DROP DEFAULT)

  • ALTER TABLE tabellenname

      ALTER feld_x DROP DEFAULT;

    • Wenn du später INSERT INTO fahrten ... machst und keine Entfernung angibst, wird automatisch 0 eingesetzt.

  • Beispiel:

    • ALTER TABLE fahrten

        ALTER entfernung DROP DEFAULT;

      • Jetzt gibt es keinen automatischen Wert mehr – du musst beim Einfügen entweder einen Wert angeben oder NULL zulassen.

  
  

  
  

   

  
  

• ALTER TABLE fahrten

    CHANGE entfernung entf SMALLINT;

  • Hier passieren zwei Dinge gleichzeitig:

    • Umbenennen der Spalte:

      • Die Spalte entfernung wird umbenannt in entf

    • Ändern des Datentyps:

      • Der Datentyp wird von dem bisherigen (z. B. INT) zu SMALLINT geändert.

• MODIFY ändert nur den Datentyp (z. B. INT zu MEDIUMINT) einer bestehenden Spalte. Der Spaltenname bleibt dabei gleich.

• Beispiel:

  • ALTER TABLE fahrten

      MODIFY entfernung MEDIUMINT;

    • Das bedeutet:

      • In der Tabelle fahrten

        wird der Datentyp der Spalte entfernung

        von z. B. INT auf MEDIUMINT geändert

• Beispiel:

  • ALTER TABLE tabellenname

    AUTO_INCREMENT = 1;

    • Wenn keine Datensätze mehr vorhanden sind:

    • Der Zähler beginnt wieder bei 1.

    • Wenn Datensätze vorhanden sind:

      • Der neue AUTO_INCREMENT-Wert überschreibt den nächsten automatisch vorgeschlagenen Wert (z. B. setzt ihn auf 1000, auch wenn der bisher höchste nur 20 war).

  
  

• INSERT INTO tabellenname

  VALUES (wert_1, wert_2, ..., wert_n);

• Achtung: Hier muss die Anzahl und Reihenfolge der Werte exakt zur Spaltendefinition in der Tabelle passen.

• Sobald z. B. eine Spalte dazukommt, schlägt dieser Befehl fehl, wenn du ihn nicht aktualisierst.

• Funktioniert gut nur bei kleinen, fest strukturierten Tabellen

• Dann musst du exakt so viele Werte angeben, wie es Spalten gibt – egal ob NOT NULL oder NULL erlaubt ist.

• Denn: Die Reihenfolge und Anzahl müssen 1:1 zu deiner Tabelle passen.

• → Wenn eine Spalte fehlt, gibt es einen Fehler.

• Pflichten:

  • Du musst alle Spaltenwerte angeben (auch NULL oder DEFAULT),

  • und die Reihenfolge der Spalten muss exakt der Tabellendefinition entsprechen.

• Mitangaben der Spalten:

  • Vorteile:

    • Du kannst Felder weglassen (z. B. nachname, plz, id).

    • Reihenfolge frei wählbar.

    • Fehlende Felder bekommen:

      • NULL (wenn erlaubt),

      • oder ihren DEFAULT-Wert,

      • oder bei AUTO_INCREMENT den nächsten Zählerwert automatisch.

    
    

  
  

  
  

  • 
    

  
  

  
  

• INSERT INTO kunde

  SET vorname = "Emil", nachname = "Fritze", plz = "40195", ort = "Düsseldorf";

• Vorteil:

  • Du musst nicht alle Spalten angeben.

  • Spalten, die einen DEFAULT-Wert oder AUTO_INCREMENT haben, kannst du einfach weglassen.

  • Sehr leserfreundlich, besonders bei vielen Spalten.

    
    

• Hinweis:

  • Die SET-Variante ist MySQL-spezifisch – nicht alle Datenbanksysteme unterstützen das.

  • In professionellen Umgebungen verwendet man meist die klassische VALUES-Schreibweise, weil sie portabler ist.

  
  

  
  

• Syntax:

  UPDATE tabellenname

  SET feld_1 = wert_1, feld_2 = wert_2, ..., feld_n = wert_n

  WHERE bedingung;

• Beispiel:

  • UPDATE kunden

    SET ort = 'Berlin'

    WHERE kundennr = 5;

• Ohne WHERE wird jede Zeile geändert!

• Mit dem UPDATE-Befehl kannst du nicht nur Werte direkt ändern, sondern auch Berechnungen mit bestehenden Werten durchführen.

• UPDATE artikel

  SET einzelpreis = einzelpreis * 0.95

  WHERE art_nr = 555;

  • Tabelle: artikel

    Feld: einzelpreis

  • Was passiert?

    • Der Einzelpreis des Artikels mit der Artikelnummer 555 wird um 5 % reduziert.

    • Also z. B. von 10.00 → 9.50

    
    

  
  

• REPLACE INTO vertreter (vorname, nachname, plz)

  VALUES ("Hans", "Hutmacher", 6);

• Was passiert genau?

  • MySQL schaut: Gibt es schon einen Eintrag mit plz = 6?

  • Ja! ➝ Es gibt: Trude Meier mit PLZ 6.

  • Weil plz UNIQUE ist, wird dieser Eintrag komplett gelöscht.

  • Danach wird ein neuer Datensatz eingefügt: Hans Hutmacher mit PLZ 6.

• Wichtig zu wissen:

  • REPLACE ist also wie:

  • 1. DELETE des alten Eintrags mit der gleichen UNIQUE-Spalte.

  • 2. INSERT des neuen Eintrags.

  • Es funktioniert nur, wenn eine Spalte als UNIQUE oder PRIMARY KEY definiert ist.

  • REPLACE ist wie eine Kombination aus DELETE + INSERT.

    Alles, was du nicht explizit angibst, wird auf NULL gesetzt!

• Löscht Inhalte:

  • DELETE FROM kunde;

    • Löscht alle Datensätzte

  • DELETE FROM kunden WHERE id = 5;

    • löscht den Datensatz von Kunde mit der id 5

  • DELETE FROM kunde

    WHERE letzter_Zugriff < "2007-01-01";

    •  Löscht alle Kunden, die sich vor dem 01.01.2007 zuletzt eingeloggt haben.

• BEGIN

  • Startet eine Transaktion. Damit sagst du der Datenbank: „Jetzt kommt ein Block von Befehlen, die zusammengehören.“

  • BEGIN;

    UPDATE konto SET kontostand = kontostand - 100 WHERE kunde_id = 1;

    UPDATE konto SET kontostand = kontostand + 100 WHERE kunde_id =2;

    -- Noch kein COMMIT, also ist nichts dauerhaft gespeichert!

• SAVEPOINT

  • Setzt einen Zwischenspeicherpunkt innerhalb einer Transaktion. Falls später ein Fehler passiert, kannst du zu diesem Punkt zurückkehren.

  • BEGIN;

    UPDATE konto SET kontostand = kontostand - 100 WHERE kunde_id = 1;

    SAVEPOINT geld_abgezogen;

    UPDATE konto SET kontostand = kontostand + 100 WHERE kunde_id = 999;  -- Kunde gibt's nicht!

• ROLLBACK

  • Macht alle Änderungen seit BEGIN (oder seit dem letzten SAVEPOINT) rückgängig – wie „alles zurück!“.

• COMMIT

  • Bestätigt die Transaktion. Alle Änderungen werden dauerhaft gespeichert.

  • BEGIN;

    UPDATE konto SET kontostand = kontostand - 100 WHERE kunde_id = 1;

    UPDATE konto SET kontostand = kontostand + 100 WHERE kunde_id = 2;

    COMMIT;  -- jetzt ist alles fest gespeichert

• WHERE

  • Filtert einzelne Zeilen in der Datenbank bevor irgendetwas gruppiert oder gerechnet wird.

  • SELECT * FROM kunden WHERE land = 'DE';

  • Klassischer Filter auf Zeilenbasis.

• HAVING

  • Filtert nach GROUP BY – also wenn du Daten gruppiert hast und danach noch sagst:

    • „Zeig mir nur Gruppen, die bestimmte Bedingungen erfüllen.“

  • Beispiel:

    • SELECT land, COUNT(*) FROM kunden

      GROUP BY land

      HAVING COUNT(*) > 10;

  • Filtert Gruppen, nicht einzelne Zeilen.

• LIMIT

  • Filtert nicht nach Inhalt, sondern sagt:

    • „Zeig mir nur die ersten X Zeilen.“

  • Beispiel:

    • SELECT * FROM kunden LIMIT 10;

      • Zeig mir nur die ersten 10 zeilen

    • SELECT *  

      FROM kunde  

      LIMIT 8, 3;

      • Starte bei Zeile 9 (weil Zählung bei 0 beginnt)

        Gib 3 Zeilen aus → Zeile 9, 10, 11

  • Mengenbegrenzung = auch ein Filter.

• Gibt die Zeichenanzahl eines Textes zurück

• Beispiel:

  • SELECT LENGTH('Hallo');  -- ergibt 5

  
  

• Schlüsselwort

• Beispiel:

  • Entfernt Doppelwerte aus dem Ergebnis

• SELECT DISTINCT land FROM kunden;

  • Gibt jede Land-Bezeichnung nur einmal zurück

• Verbindet Zeichenketten zu einer neuen

• SELECT CONCAT('Ali', ' ', 'Müller');  -- ergibt: 'Ali Müller'

• funktioniert pro Zeile, nicht über viele Zeilen

• Ein PRIMARY KEY ist der eindeutige Fingerabdruck jeder Zeile in einer Tabelle.

• Eigenschaften:

  • Eindeutig: Jede Zeile muss einen anderen Wert haben

  • Nicht NULL: Es muss ein Wert vorhanden sein

  • Oft benutzt man AUTO_INCREMENT, um IDs automatisch zu vergeben

  
  

• Verbindet zwei Tabellen miteinander.

• Eigenschaften:

  • Sorgt dafür, dass der Wert in der anderen Tabelle existieren muss

  • Dient der Referenzierung (z. B. „Dieser Kunde gehört zu dieser Bestellung“)

• Stell dir vor, du machst eine Tabelle für Produkte, und du willst sagen:

• „Der Preis darf nicht kleiner als 0 sein!“

• → Das ist eine Regel, und genau dafür ist CHECK da.

• Beispiel:

  • CREATE TABLE produkte (

      id INT PRIMARY KEY,

      name VARCHAR(100),

      preis DECIMAL(5,2) CHECK (preis > 0)

    );

• CONCAT() :

  • Funktion: Verbindet (konkateniert) zwei oder mehr Texte

  • Beispiel:

    • SELECT CONCAT('Ali', ' ', 'Müller');  -- Ergebnis: 'Ali Müller'

• SUBSTRING() 

  • Funktion: Holt einen Teil aus einem Text heraus

  • Beispiel:

    • SELECT SUBSTRING('Hallo Welt', 1, 5);  -- Ergebnis: 'Hallo'

      • Erklärung:

        • Start bei Position 1

        • Hole 5 Zeichen

• UPPER() 

  • Funktion: Wandelt Text in Großbuchstaben um

  • Beispiel:

    • SELECT UPPER('hallo');  -- Ergebnis: 'HALLO'

• LEFT():

  • Funktion: Holt die linken (ersten) X Zeichen aus einem Text

  • Beispiel:

    • SELECT LEFT('Banane', 3);  -- Ergebnis: 'Ban'

• SELECTION

  • Auswahl bestimmter Zeilen nach Kriterien (also: welche Datensätze?)

  • SELECT *

    FROM kunde

    WHERE ort = "hamburg";

  • Alle Kunden sollen angezeigt werden, aber nur die aus Hamburg.

• JOIN

  • Zusammenführen mehrerer Tabellen (über gemeinsame Spalten)

  • Wenn man Daten aus mehreren Tabellen gemeinsam anzeigen möchte – z. B.:

    • Tabelle kunde: Kundendaten

    • Tabelle bestellung: Bestellungen

• Projection

  • Auswahl von Spalten (also: welche Infos anzeigen?)

  • SELECT kd_nr, nachname, plz

    FROM kunde;

  • Das ist eine Projektion, weil nur ausgewählte Spalten angezeigt werden.

• Es sollen nur die Mitarbeiter angezeigt werden,

  die auch tatsächlich Projektleiter in einem Projekt sind.

• SELECT *

  FROM mitarbeiter

  INNER JOIN projekt

  ON persnr = leiter;

• Alternative Variante

  • SELECT *

    FROM

    mitarbeiter, projekt

    WHERE persnr = leiter;

  • 
    

  
  

• Der LEFT JOIN sagt:

  • „Zeig mir ALLE Zeilen aus der linken Tabelle, egal ob sie zur rechten Tabelle passen oder nicht.“

  • Wenn ein Datensatz keinen passenden Treffer in der rechten Tabelle findet, dann zeigt SQL immer noch den Datensatz aus der linken Tabelle an – und füllt die Werte aus der rechten Tabelle mit NULL (also „nichts drin“) aus.

  • 
    

• Zeigt alle Zeilen aus der rechten Tabelle, auch wenn es links keinen passenden Wert gibt.

• Wenn links kein passender Datensatz existiert, wird die linke Seite mit NULL aufgefüllt.

  
  

• Ein CROSS JOIN macht das kartesische Produkt zweier Tabellen:

• Jeder Datensatz aus Tabelle A wird mit jedem Datensatz aus Tabelle B kombiniert.

• AND

  • SELECT * FROM kunde

    WHERE ort = 'Hamburg'

    AND plz = '20095';

  • Nur Kunden aus Hamburg UND mit der PLZ 20095 werden angezeigt.

• OR

  • SELECT * FROM kunde

    WHERE ort = 'Hamburg'

    OR plz = '20095';

  • Kunden aus Hamburg oder mit PLZ 20095 (auch wenn sie aus einer anderen Stadt kommen).

• NOT

  • SELECT * FROM kunde

    WHERE NOT ort = 'Hamburg';

  •  Zeigt Kunden, die entweder aus Hamburg oder PLZ 20095 haben, aber nicht beides gleichzeitig.

• Aufsteigend ASC

  • SELECT * FROM kunde

    ORDER BY name ASC;

  • Sortiert:

    • Alphabetisch von A → Z

    • Zahlen von klein nach groß

    • Datum von früh nach spät

• Absteigend DESC

  • SELECT * FROM kunde

    ORDER BY name DESC;

• Spaltennummer

  • SELECT name, ort, umsatz

    FROM kunde

    ORDER BY 2;

  •  Es sortiert nach der zweiten Spalte, die du im SELECT geschrieben hast.

• ON

  • wird verwendet, um zwei Tabellen miteinander zu verknüpfen.

  • gehört zu JOIN

  
  

• IN

  • wird verwendet, um zu prüfen, ob ein Wert in einer Liste oder in einem Unterergebnis enthalten ist.

  •   gehört zu Bedingungen in WHERE

• Referentielle Integrität stellt sicher,

  dass Verknüpfungen zwischen Tabellen immer gültig sind.

• Eine Bestellung darf nur einen Kunden referenzieren, der auch wirklich existiert.

• Beispiel:

  • kundennr = 3 ist nicht erlaubt, weil es diesen Kunden nicht gibt → das wäre ein Verstoß gegen referentielle Integrität.

• Wie wird das verhindert

  • Mit einem sogenannten Fremdschlüssel (Foreign Key).

  • ALTER TABLE bestellung

    ADD CONSTRAINT fk_kunde

    FOREIGN KEY (kundennr)

    REFERENCES kunde(kundennr);

  • Diese kundennr in bestellung muss in der Tabelle kunde vorhanden sein.

  • FOREIGN KEY (kundennr)

    REFERENCES kunde(kundennr)

    ON DELETE CASCADE

    ON UPDATE CASCADE

Ein Befehl, der eine Aktion in der Datenbank ausführt.

✅ Beispiele:

• SELECT → Daten abfragen

• INSERT → Neue Daten einfügen

• UPDATE → Daten ändern

• DELETE → Daten löschen

• CREATE TABLE → Neue Tabelle erstellen

📌 Merkmale:

• Steht immer am Anfang einer SQL-Anweisung

• Führt eine komplette Aktion durch

Eine eingebaute Berechnung oder Umwandlung, die du innerhalb eines Befehls nutzt.

✅ Beispiele:

• COUNT(*) → Anzahl der Zeilen zählen

• SUM(preis) → Summe berechnen

• UPPER(name) → Großbuchstaben machen

• NOW() → aktuelles Datum/Zeit

📌 Merkmale:

• Wird im SELECT oder WHERE verwendet

• Gibt einen Wert zurück

Ein reserviertes Wort in SQL – die Bausteine der Sprache.

✅ Beispiele:

• FROM, WHERE, ORDER BY, GROUP BY, AS, JOIN, NULL

• Auch: SELECT, INSERT usw. zählen streng genommen auch als Schlüsselwörter, sind aber gleichzeitig Befehle

📌 Merkmale:

• Kann nicht als Name für Spalten oder Tabellen verwendet werden

• Hat feste Bedeutung in SQL

Eine Regel, die Daten in der Tabelle validiert oder schützt.

✅ Beispiele:

• PRIMARY KEY → eindeutig & nicht NULL

• FOREIGN KEY → verweist auf andere Tabelle

• NOT NULL → darf nicht leer sein

• UNIQUE → jeder Wert nur einmal

• CHECK (alter >= 18) → nur gültige Werte erlaubt

📌 Merkmale:

• Gehört zur Tabellenstruktur

• Sorgt für Datenqualität & Konsistenz