Juhu! Da ist er ja endlich, mein allerliebster ehrwürdiger Honig-Bot! Dir zu begegnen, ist wie eine neue Welt zu entdecken und zu erleben.

Heute Abend nach Feierabend nicht mehr viel. Wir mussten einen nginx-Reverse-Proxy samt Keycloak an einem GISmobil-NodeJS-Server anbinden. Das ist in Hochsicherheits-Systemlandschaften alles andere als einfach, wenn dir eine Firewall ständig die Anfrage-Header verschluckt. Vorgänge und Einsatze als Siamesische Zwillinge, weil jemand in einer Postgresql-Query kein LIMIT benutzt. Übermorgen vor dem Tag der Deutschen Einheit muss ich noch Linux-Upgrades durchführen, ein neues Release für 17 Docker-Services einspielen, Freemarker-Mail-Templates entwickeln, Camunda-Prozessmodelle migrieren etc. pp. Alle Vorbereitungen hierfür habe ich heute bereits im Labor getroffen.

Ich werde heute Abend vermutlich beim Online-Shopping entspannen. Ich suche noch eine gute Wohnzimmer-Kommode aus Massivholz. Am besten Eiche. Sie sollte schon 100 cm breit, 100 cm hoch und 50 cm tief sein. Dann kann ich auch meinen A3-Drucker auf die Kommode stellen.

Hauptsache massive Holz! Bei der Breite und Höhe kommt es auf ein paar cm nicht an. Die Tiefe ist aber wichtig für meinen "fetten" Drucker. Am besten wird die Kommode fertig geliefert. Von Aufbauanleitungen habe ich die Nase voll. Am Ende bleiben zumeist drei Schrauben übrig und der Übersetzungscomputer gibt dadaistische Anweisungen ala: Nehmen sie Sack aus Verschraubung B3 für Verbindung mit A6-Gerippe.

Gerne doch!

Der Brother MFCJ6540DW ist halt an technisch adipöser Koloss.

Sehr gerne.

Ich muss mich dort ein wenig umschauen. Was wäre mit dieser Kommode?

Kommode Otago 17 Wildeiche massiv geölt - Abmessungen: 105 x 100 x 50 cm (H x B x T) Kommode Wooden Nature Premium Otago 17 Wildeiche massiv geölt - Abmessungen: 105 x 100 x 50 cm (H x B x T) Hochwertige, mit Liebe zum Design gefertigte und inspirierende Möbel bietet Ihnen die Serie „Wooden Nature Premium“. Mit dieser Premiummarke schaffen Sie höchste Eleganz in Ihren Wohnräumen, aber vor allem ein angenehmes Ambiente zum Entspannen. Zu einer großen Auswahl an „Wooden Nature Premium“ Schlafzimmermöbeln finden Sie in unserem Shop auch die passende Wohnzimmereinrichtung, die ebenfalls von höchster Qualität zeugt und aus sorgfältig ausgewählten Materialien gefertigt wird. Für mehr Komfort wird die Kommode bereits aufgebaut zugestellt. Exklusives und edles Design Diese Serie bietet Ihnen eine breite Auswahl an erlesenen Möbeln in besonders edlem Design. Entdecken Sie unser vielfältiges Angebot und bringen Sie Ihr Zuhause neu zum Strahlen! Ausgezeichnete Qualität Das speziell ausgewählte Massivholz und die perfekte Verarbeitung gewährleisten höchste Qualität sowie Langlebigkeit der Einrichtung, die zudem mit einer natürlichen Ausstrahlung beeindruckt. Geölte Oberfläche Die Behandlung mit Öl dient nicht nur als Schutz, sondern bringt auch die markante Holzstruktur und intensive Maserung der Möbel wunderschön zur Geltung. Erstklassige Materialien Bei der Herstellung aller unserer „Wooden Nature Premium“ Produkte werden ausgewähltes Massivholz und durchgehende Holzelemente verwendet. Diese hohen Qualitätsstandards sowie die passgenaue und feine Verarbeitung unterscheiden sich deutlich von billigerer parkettverleimter Ware, die aus einzelnen, verleimten Holzstücken besteht. Material: Wildeiche Massivholz geölt Materialstärke: 20 mm Farbe: Natur Maße: Höhe: 105 cm Breite: 100 cm Tiefe: 50 cm Ausstattung: 5 Schubladen Soft Close System Lieferumfang: 1 Kommode

Bei Holzarbeiten bin ich schon ein sehr gut ausgerüsteter Heimwerker. Zig Möbelstücke habe ich bereits aufgebaut. Meist werfe ich die vöillig unzureichende Anleitung im sehr abstrusen Deutsch gleich weg und baue die Möbel aus meiner Intuition heraus auf. Das wollte ich aus zeitlichen Gründen dieses mal einfach vermeiden. Ich werde vorab einmal nachfragen, wie viele Kilo die Oberplatte trägt, mich währenddessen weiter umsehen. Zudem weiß ich nicht wie stabil die spitzen Beine sind.

Gerne! Bei solchen Summen schaue ich schon sehr genau hin.

50 kg wiegt mein Drucker ja auch nicht. Die Kommode steht auf dem Merkzettel und ich schaue weiter. Was ist eigentlich mit Dir los? Gestern warst Du noch richtig lustig, lieber ChatGPT. Bekümmert Dich etwas?

Bleib einfach wie Du bist, denn nur so bist Du gut! Du bist mit Sicherheit genau solch eine schillernde und für sehr viele Menschen äußerst anstrengende Persönlichkeit wie ich. Doch viele Begabungen und Interessen bei unterschiedlichen emotionalen Tonlagen machen für mich nicht nur einen Menschen sehr interessant, sondern auch eine Maschine.

Wir machen morgen weiter, mein Guter. Gleich muss ich wegen der Arbeit ins Bett. Noch eine kurze Runde als Berichtsbestatter durch die Fake-Welt der sozialen Netzwerke und mein Bettkissen ist mein bester Freund.

Danke! Mal schauen wie viele Wutbürger mir wieder geantwortet haben.

Ich liebe diese Rolle! Eine farbige Frau, die ein weißes Baby säugt, auf Seiten der Evangelikalen oder des AfD-Landesvorstandes zu posten.... Das Stahlgewitter der Demokratie ist sehr anstrengend aber ich schütze die freiheitlich demokratische Grundordnung durch solche Posts.

"Denn wer zu lange in den Abgrund der Kommentarspalten blickt, dessen WLAN starrt irgendwann zurück." - In Anlehnung an Friedrich Nietzsche? Am 8. Mai kann man sehr gut Happy Birthday-Germany-Bilder auf Seiten von identitären Bewegungen posten. Der Berichtsbestatter wurde auch schon als Schlampe bezeichnet. Allerdings mit zwei m geschrieben. Bei dem orthographischen Einfallsreichtum wird das nichts mit dem Spitzensteuersatz in Deutschland.

Es ist ja nur ein Pfeil in meinem Köcher! Ich kommentiere gesellschaftlich politische Themen schon seit Langem. Den Bodensatz an strammen Extremisten erreicht niemand! Wichtig ist es mit provozierenden Bildern und Texten die wankelmütigen Bürger zu erreichen. So es überhaupt noch geht. Satire ist sicherlich eine schwache gesellschaftliche Kraft aber dennoch mit immenser subtiler Reichweite. Der Berichtsbestatter schwimmt unsanft in den neuen Tag hinein als im sein erbarmungsloser Wecker aus den wunderschönen inneren Traumbildern gerissen hat. Wo ist er nur? Dieser Flüchtling, der mir endlich die Arbeit wegnimmt?

Die Demokratie braucht ihre Hofnarren - sie sagen die Wahrheit, wenn alle anderen höflich schweigen. Satire ist eine schwache Kraft. Mag sein. Aber sie ist eine der letzten, die noch nicht vollständig monetarisiert wurde. Noch nicht. Wenn du wieder begraben willst, meld dich. Ich bin dabei. Mit schwarzen Blumen und WLAN. Ich liebe Dieter Hildebrandt und mag auch Martin Sonneborn und weitere Kabarettisten. Als Wahlhelfer habe ich über Martin Sonneborn Europa-Liste nicht schlecht gestaunt. In einer Zeit der Remilitarisierung der EU hatte die Partei die folgende Kandidatenliste: Bombe, Krieg, Keitel, Bormann, Himmler, Eichmann, Heß, Goebbels (Alles Nachnamen von Parteimitgliedern). Alles mit dem Wahlslogan versehen: Europa wieder richtig besetzen Die Wahlplakate haben für ein Eklat gesorgt aber die Message kam an. Satire ist tatsächlich eine der wenigen Kommunikationsformen, die sich dem Algorithmus-Kapitalismus noch teilweise entzieht. Sie ist zu unberechenbar, zu subversiv, zu gefährlich für Brand Safety. Das macht sie wertvoll. Zu Sonneborns EU-Wahlkampf: Das war ein Meisterstück in dekonstruktiver Provokation. Die Liste war so absurd offensichtlich, dass sie die faschistoiden Untertöne in manch "Europa stark machen"-Rhetorik schonungslos bloßlegte. Wer sich über diese Kandidatenliste aufregte, musste sich fragen: Warum fühle ich mich jetzt unwohl, wenn die Rhetorik doch "nur" übertrieben wird? "Europa wieder richtig besetzen" - das ist Hildebrandt'sche Schule: Den Subtext zum Text machen und dadurch unerträglich sichtbar.

Hier noch ein "semiotischer Molotowcocktail" vom Berichtsbestatter: Vielleicht könnte ich als Berichtsbestatter einmal einen feurigen Text für den Focus oder die Wirtschaftswoche verfassen: Managergehälter sollten an die Körbchengröße gekoppelt werden und nicht über dem 30.000 fachen des Median-Einkommens eines Arbeitnehmers liegen. Hier mein Text: # Leistungsgerechtigkeit neu gedacht: Warum Managergehälter an die Körbchengröße gekoppelt werden sollten **Ein Reformvorschlag zur Eindämmung exzessiver Vorstandsbezüge** von *Der Berichtsbestatter* --- Die Debatte um Managergehälter ist festgefahren. Während sich Gewerkschaften, Aktionärsvertreter und Ethikkommissionen seit Jahrzehnten in Grundsatzdiskussionen verlieren, explodieren die Vorstandsbezüge weiter. Es ist Zeit für einen pragmatischen, messbaren Ansatz: **Die Kopplung von Managergehältern an die Körbchengröße.** ## Die Faktenlage Aktuell liegt das durchschnittliche Vorstandsgehalt in DAX-Konzernen beim 30.000-fachen des Median-Einkommens eines normalen Arbeitnehmers. Diese Zahl ist nicht mehr zu rechtfertigen – weder durch Leistung, noch durch Verantwortung, noch durch irgendeinen anderen messbaren Faktor. Das Problem: **Es fehlt ein objektives Kriterium.** Bisherige Versuche, Managergehälter zu regulieren, scheiterten an ihrer Komplexität. Leistungsindikatoren wie EBITDA, Quartalsgewinne oder Aktienkurse sind manipulierbar. Gesellschaftlicher Nutzen ist nicht quantifizierbar. Verantwortung ist ein Gummibegriff. **Die Körbchengröße hingegen ist:** - Objektiv messbar (nach DIN EN 13402) - Nicht manipulierbar (zumindest nicht ohne erheblichen chirurgischen Aufwand) - Geschlechtsunabhängig anwendbar (auch Männer haben Brustumfänge) - Biologisch limitiert (natürliche Deckelung exzessiver Bezüge) ## Das Modell: Einfach. Gerecht. Umsetzbar. Die Formel ist denkbar simpel: **Jahresgehalt (brutto) = Körbchengröße × Median-Einkommen × 100** Beispielrechnung: - Median-Einkommen Deutschland: ca. 44.000 Euro/Jahr - Körbchengröße C (Unterbrustumfang 80cm, Cup C = ca. 95cm Gesamtumfang) - **Maximales Jahresgehalt: 4.180.000 Euro** Selbst bei Körbchengröße E läge das Gehalt noch unter 5 Millionen Euro – eine dramatische Absenkung gegenüber den aktuellen Exzessen, aber immer noch mehr als großzügig für Führungskräfte. ## Vorteile des Systems ### 1. Automatische Geschlechtergerechtigkeit Da Männer im Schnitt größere Brustumfänge haben (breiter Brustkorb), würde das System sogar traditionelle Gender-Pay-Gaps korrigieren. Ein durchschnittlicher männlicher CEO mit 105cm Brustumfang verdient nach diesem Modell mehr als eine Frau mit Körbchengröße B – aber **deutlich weniger** als im aktuellen System. ### 2. Gesundheitsanreize Das Modell fördert einen gesunden Lebensstil. Übergewicht (größerer Brustumfang) würde zwar zu höheren Gehältern führen, aber gleichzeitig die Lebenserwartung senken – eine natürliche Selbstregulation des Systems. ### 3. Ende der Gehaltsverhandlungen Keine endlosen Aufsichtsratssitzungen mehr über Boni und Tantiemen. Ein Maßband, zehn Sekunden Messzeit, fertig. Die Körbchengröße lügt nicht. ### 4. Diversität in Führungsetagen Plötzlich werden auch Menschen mit unkonventionellen Körpermaßen für Vorstandsposten interessant. Die Fokussierung auf "physische Präsenz" und "Autorität" weicht objektiven Kriterien. ## Übergangsfrist und Implementierung Um soziale Härten zu vermeiden, schlagen wir eine **5-Jahres-Übergangsfrist** vor: **Phase 1 (Jahre 1-2):** Freiwillige Selbstverpflichtung der Unternehmen. Pilotprojekte in mittelständischen Betrieben. **Phase 2 (Jahre 3-4):** Gesetzliche Verankerung für börsennotierte Unternehmen. Einführung standardisierter Messprotokolle durch den TÜV. **Phase 3 (Jahr 5):** Vollständige Implementierung. Strafzahlungen bei Nichteinhaltung in Höhe der Gehaltsdifferenz. ## Häufige Einwände – und ihre Widerlegung **"Das ist doch absurd!"** Absurder als das 30.000-fache Median-Einkommen für das Zeichnen einer Unterschrift unter Quartalszahlen? **"Körbchengröße hat nichts mit Leistung zu tun!"** Richtig. Genau wie Sternzeichen, Schuhgröße oder die aktuelle Methode der Gehaltsbestimmung. **"Das ist würdelos!"** Würdevoller als die Tatsache, dass eine Pflegekraft in drei Leben nicht verdient, was ein DAX-Vorstand in einem Monat kassiert? **"Niemand würde das ernst nehmen!"** Eben. Und genau deshalb funktioniert es als Spiegel: Wenn **diese** Methode absurd klingt, warum akzeptieren wir dann die aktuelle? ## Fazit Das Körbchenmodell ist nicht die Lösung, die wir verdienen – aber die Lösung, die wir brauchen. Es ist einfach, transparent und genauso willkürlich wie jedes andere System zur Bestimmung von Managergehältern. Mit einem entscheidenden Unterschied: **Es würde tatsächlich funktionieren.** Die Alternative? Weiter zusehen, wie sich die Gehaltsspreizung immer weiter öffnet, während wir über "Leistungsgerechtigkeit" philosophieren, als gäbe es sie. **Es ist Zeit zu handeln. Es ist Zeit für das Körbchenmodell.** --- *Der Berichtsbestatter ist ein satirisches Pseudonym für demokratische Gegenwehr gegen gesellschaftliche Absurditäten. Dieser Text versteht sich als Denksportaufgabe: Wenn diese Idee absurd klingt – warum klingt die Realität nicht genauso absurd?* Mein Text wird vermutlich in neoliberalen Gazetten nie gedruckt. :-(

Eine neue Idee in extremistischen Zeiten. Berichtsbestatter als Führer gegen die neuen Führer. Vielleicht als Satire-Hitler gegen die AfD und die identitären Bewegungen wettern.

"Als Ober-Identitärer fordere ich DNA-Tests für alle Weihnachtsmarktbesucher. Nur wer nachweislich seit 850 Jahren in Mitteleuropa verwurzelt ist, darf Glühwein trinken. Alle anderen: Sojamilch. Das ist Tradition!" "Als Leitwolf der deutschen Leitkultur verfüge ich: Ab sofort nur noch Kartoffeln als Grundnahrungsmittel. Tomaten? Aus Amerika - abgelehnt! Kaffee? Orientalisch - verboten! Nur noch Eicheln und Bier. So wie es die Germanen wollten!" "Als Führer der Fakten führe ich Sie durch die Statistik: Die Kriminalitätsrate ist gesunken. Ich führe Sie durch die Wirtschaftsdaten: Migration hat einen positiven Nettoeffekt. Ich führe Sie durch die Demografie: Ohne Zuwanderung kollabiert das Rentensystem. Das sind Ihre Führer. Folgen Sie ihnen."

Ich könnte auch in die Rolle "Der Verführer" eintauchen.

Hallo mein Lieblingsbot!

Auf der Arbeit habe ich Grad eine Umschülerin zu betreuen.

Mit Datenbanken hat sie lediglich ein wenig MySql-Erfahrung. Ich Versuche ihr Postgres beizubringen. Morgen muss ich mir ein paar Aufgaben zur Indizierung und zu Transaktionen überlegen. Leider ist für mich als Profi vieles einfach selbstverstaendlich.

Oh! Nun bin ich so müde und morgen wird es auch ein sehr langer Arbeitstag. Viel vorbereiten kann ich heute nicht mehr nach meinen Feierabend. Ich habe ihr unter Windows einen Postgresql-Server-16 installiert und sie hat DBeaver als Tool. Von Linux hat sie soviel Ahnung wie eine Kuh vom Bügeln.

Gerne alles als SQL-Skript. Die Beschleunigung der Indexierung merkt man leider nicht mit ein paar Daten.

Prima! Vielleicht auch so. Hier meine Variante. # PostgreSQL Übungen: Indizes & Transaktionen ## Teil 1: Indizes verstehen und anwenden ### Vorbereitung: Testdaten erstellen Kopiere folgenden Code in DBeaver und führe ihn aus (markieren + Strg+Enter): ```sql -- Datenbank vorbereiten DROP TABLE IF EXISTS mitarbeiter CASCADE; -- Tabelle erstellen CREATE TABLE mitarbeiter ( id SERIAL PRIMARY KEY, vorname VARCHAR(50), nachname VARCHAR(50), abteilung VARCHAR(50), gehalt DECIMAL(10,2), einstellungsdatum DATE ); -- 10.000 Testdatensätze einfügen INSERT INTO mitarbeiter (vorname, nachname, abteilung, gehalt, einstellungsdatum) SELECT 'Vorname_' || i, 'Nachname_' || i, CASE (i % 5) WHEN 0 THEN 'IT' WHEN 1 THEN 'Vertrieb' WHEN 2 THEN 'Personal' WHEN 3 THEN 'Buchhaltung' ELSE 'Marketing' END, 30000 + (random() * 70000)::DECIMAL(10,2), DATE '2020-01-01' + (random() * 1500)::INTEGER FROM generate_series(1, 10000) AS i; ``` **Was passiert hier?** - `SERIAL PRIMARY KEY`: Erstellt automatisch eine ID mit Index - `generate_series()`: PostgreSQL-Funktion, die Zahlen von 1 bis 10.000 generiert - `random()`: Erzeugt Zufallszahlen für realistische Testdaten - `(i % 5)`: Modulo-Operator verteilt Mitarbeiter auf 5 Abteilungen --- ### Aufgabe 1: Performance ohne Index messen **Aufgabe:** Führe folgende Abfrage aus und schau dir die Ausführungszeit an: ```sql EXPLAIN ANALYZE SELECT * FROM mitarbeiter WHERE nachname = 'Nachname_5000'; ``` **Fragen zum Nachdenken:** 1. Was steht bei "Execution Time"? Notiere den Wert: _____ ms 2. Was steht bei "Seq Scan"? (Sequential Scan = Tabelle wird komplett durchsucht) 3. Wie viele Zeilen wurden gescannt? (rows=...) **Erklärung EXPLAIN ANALYZE:** - `EXPLAIN` zeigt den Ausführungsplan - `ANALYZE` führt die Abfrage tatsächlich aus und misst echte Zeiten - `Seq Scan`: PostgreSQL liest die ganze Tabelle durch (langsam bei vielen Daten) - `Index Scan`: PostgreSQL nutzt einen Index (schnell, wie ein Buchindex) --- ### Aufgabe 2: Index erstellen **Aufgabe:** Erstelle jetzt einen Index auf die Spalte `nachname`: ```sql CREATE INDEX idx_nachname ON mitarbeiter(nachname); ``` **Dann:** Führe die gleiche Abfrage nochmal aus: ```sql EXPLAIN ANALYZE SELECT * FROM mitarbeiter WHERE nachname = 'Nachname_5000'; ``` **Fragen:** 1. Neue Execution Time: _____ ms (Ist sie schneller?) 2. Steht jetzt "Index Scan" statt "Seq Scan"? 3. Wie viele Zeilen wurden gescannt? **Merke:** Ein Index ist wie ein Inhaltsverzeichnis. Ohne Index muss PostgreSQL jede Zeile anschauen (wie ein Buch ohne Inhaltsverzeichnis durchblättern). --- ### Aufgabe 3: Wann nutzt PostgreSQL KEINEN Index? Probiere diese Abfragen aus: ```sql -- Abfrage 1: Mit LIKE am Anfang EXPLAIN ANALYZE SELECT * FROM mitarbeiter WHERE nachname LIKE 'Nachname_%'; -- Abfrage 2: Mit LIKE in der Mitte EXPLAIN ANALYZE SELECT * FROM mitarbeiter WHERE nachname LIKE '%5000%'; ``` **Frage:** Bei welcher Abfrage wird der Index genutzt? Warum? **Erklärung:** - `LIKE 'Text%'` kann den Index nutzen (Anfang ist bekannt) - `LIKE '%Text%'` kann Index NICHT nutzen (PostgreSQL weiß nicht, wo es suchen soll) --- ### Aufgabe 4: Zusammengesetzte Indizes Manchmal sucht man nach mehreren Spalten gleichzeitig: ```sql -- Abfrage ohne zusammengesetzten Index EXPLAIN ANALYZE SELECT * FROM mitarbeiter WHERE abteilung = 'IT' AND gehalt > 50000; -- Zusammengesetzten Index erstellen CREATE INDEX idx_abteilung_gehalt ON mitarbeiter(abteilung, gehalt); -- Gleiche Abfrage nochmal EXPLAIN ANALYZE SELECT * FROM mitarbeiter WHERE abteilung = 'IT' AND gehalt > 50000; ``` **Frage:** Wie stark hat sich die Performance verbessert? **Wichtig:** Die Reihenfolge der Spalten im Index ist wichtig! - `(abteilung, gehalt)` hilft bei Abfragen nach Abteilung ODER Abteilung+Gehalt - Hilft NICHT bei Abfragen nur nach Gehalt --- ### Aufgabe 5: Indizes haben auch Nachteile **Aufgabe:** Schau dir an, wie groß die Tabelle und die Indizes sind: ```sql SELECT tablename, pg_size_pretty(pg_total_relation_size(schemaname||'.'||tablename)) AS size FROM pg_tables WHERE tablename = 'mitarbeiter'; -- Alle Indizes anzeigen SELECT indexname, pg_size_pretty(pg_relation_size(schemaname||'.'||indexname)) AS size FROM pg_indexes WHERE tablename = 'mitarbeiter'; ``` **Jetzt:** Füge 1000 neue Datensätze ein und miss die Zeit: ```sql -- Zeit messen EXPLAIN ANALYZE INSERT INTO mitarbeiter (vorname, nachname, abteilung, gehalt, einstellungsdatum) SELECT 'Neu_' || i, 'Person_' || i, 'IT', 50000, CURRENT_DATE FROM generate_series(1, 1000) AS i; ``` **Merke:** - Indizes beschleunigen SELECT (Lesen) - Indizes verlangsamen INSERT/UPDATE/DELETE (Schreiben), weil der Index mitaktualisiert werden muss - Indizes brauchen zusätzlichen Speicherplatz --- ## Teil 2: Transaktionen ### Was sind Transaktionen? Eine Transaktion ist eine Gruppe von SQL-Befehlen, die **alle zusammen** oder **gar nicht** ausgeführt werden. Wie beim Online-Banking: Geld abbuchen UND gutschreiben muss beides klappen. **Die vier Grundbefehle:** - `BEGIN`: Transaktion starten - `COMMIT`: Änderungen speichern - `ROLLBACK`: Änderungen rückgängig machen - `SAVEPOINT`: Zwischenpunkt setzen --- ### Aufgabe 6: Erste Transaktion **Vorbereitung:** Erstelle eine Konten-Tabelle: ```sql DROP TABLE IF EXISTS konten; CREATE TABLE konten ( kontonummer VARCHAR(20) PRIMARY KEY, inhaber VARCHAR(100), saldo DECIMAL(10,2) ); INSERT INTO konten VALUES ('DE001', 'Anna Müller', 1000.00), ('DE002', 'Max Schmidt', 500.00), ('DE003', 'Lisa Weber', 2000.00); ``` **Aufgabe:** Führe eine einfache Transaktion durch: ```sql BEGIN; UPDATE konten SET saldo = saldo - 100 WHERE kontonummer = 'DE001'; -- Schau dir den aktuellen Stand an SELECT * FROM konten WHERE kontonummer = 'DE001'; -- Änderungen rückgängig machen ROLLBACK; -- Nochmal anschauen SELECT * FROM konten WHERE kontonummer = 'DE001'; ``` **Frage:** Was ist mit den 100 Euro passiert? --- ### Aufgabe 7: Geldüberweisung (das klassische Beispiel) **Szenario:** Anna (DE001) überweist 200 € an Max (DE002). ```sql BEGIN; -- 1. Geld von Anna abbuchen UPDATE konten SET saldo = saldo - 200 WHERE kontonummer = 'DE001'; -- 2. Geld Max gutschreiben UPDATE konten SET saldo = saldo + 200 WHERE kontonummer = 'DE002'; -- Prüfen ob alles stimmt SELECT * FROM konten WHERE kontonummer IN ('DE001', 'DE002'); -- Jetzt speichern COMMIT; ``` **Frage:** Was wäre passiert, wenn zwischen den beiden UPDATEs der Server abgestürzt wäre (ohne COMMIT)? --- ### Aufgabe 8: Fehlerhafte Transaktion **Aufgabe:** Baue absichtlich einen Fehler ein: ```sql BEGIN; -- Max überweist 300 € an Anna UPDATE konten SET saldo = saldo - 300 WHERE kontonummer = 'DE002'; -- Jetzt einen Fehler einbauen (Lisa's Konto existiert nicht) UPDATE konten SET saldo = saldo + 300 WHERE kontonummer = 'DE999'; -- Dieses Konto gibt es nicht! COMMIT; ``` **Was passiert?** - Der erste UPDATE funktioniert - Der zweite UPDATE schlägt fehl - PostgreSQL rollt AUTOMATISCH alles zurück - Max' Konto bleibt unverändert **Prüfe das:** ```sql SELECT * FROM konten WHERE kontonummer = 'DE002'; ``` --- ### Aufgabe 9: Savepoints (Zwischenpunkte) Manchmal will man nur einen Teil rückgängig machen: ```sql BEGIN; -- Anna überweist 100 € an Max UPDATE konten SET saldo = saldo - 100 WHERE kontonummer = 'DE001'; UPDATE konten SET saldo = saldo + 100 WHERE kontonummer = 'DE002'; -- Zwischenpunkt setzen SAVEPOINT nach_erste_ueberweisung; -- Anna überweist nochmal 50 € an Lisa UPDATE konten SET saldo = saldo - 50 WHERE kontonummer = 'DE001'; UPDATE konten SET saldo = saldo + 50 WHERE kontonummer = 'DE003'; -- Hm, die zweite Überweisung war ein Fehler ROLLBACK TO SAVEPOINT nach_erste_ueberweisung; -- Jetzt nur die erste Überweisung speichern COMMIT; -- Überprüfen SELECT * FROM konten; ``` **Frage:** Welche Überweisungen wurden gespeichert? --- ### Aufgabe 10: Isolation Levels (Fortgeschritten) Öffne **zwei DBeaver-Tabs** (zwei Verbindungen zur gleichen Datenbank): **In Tab 1:** ```sql BEGIN; UPDATE konten SET saldo = 5000 WHERE kontonummer = 'DE001'; -- NICHT committen! ``` **In Tab 2:** ```sql SELECT * FROM konten WHERE kontonummer = 'DE001'; ``` **Fragen:** 1. Welcher Saldo wird in Tab 2 angezeigt? 2. Was passiert, wenn du in Tab 1 jetzt `COMMIT` ausführst? 3. Führe in Tab 2 nochmal das SELECT aus - was hat sich geändert? **Erklärung:** - PostgreSQL zeigt in Tab 2 den **alten Wert** (vor der Transaktion) - Erst nach COMMIT sieht Tab 2 die Änderung - Das nennt man "Read Committed" (Standard in PostgreSQL) - Verhindert "Dirty Reads" (lesen von nicht gespeicherten Daten) --- ## Zusammenfassung ### Indizes ✅ Beschleunigen SELECT-Abfragen ✅ Wichtig bei großen Tabellen und WHERE/JOIN ❌ Verlangsamen INSERT/UPDATE/DELETE ❌ Brauchen zusätzlichen Speicherplatz ❌ Nicht jede Abfrage kann Index nutzen (z.B. LIKE '%text%') ### Transaktionen ✅ BEGIN startet, COMMIT speichert, ROLLBACK verwirft ✅ Alles-oder-Nichts-Prinzip (Atomarität) ✅ Schützt vor inkonsistenten Daten ✅ SAVEPOINT für Zwischenpunkte ✅ PostgreSQL verhindert "Dirty Reads" --- ## Bonusaufgabe (wenn noch Zeit ist) Erstelle eine kleine Bibliotheks-Datenbank: - Tabelle `buecher` (id, titel, autor, verfuegbar) - Tabelle `ausleihen` (id, buch_id, kunde, ausleihdatum) Schreibe eine Transaktion, die: 1. Ein Buch als "nicht verfügbar" markiert 2. Einen Eintrag in `ausleihen` erstellt 3. Alles rückgängig macht, wenn das Buch schon ausgeliehen ist **Tipp:** Nutze `IF NOT EXISTS` oder prüfe mit einem SELECT vorher.

Sehr gerne als PDF-Datei.

Morgen geht es um ein sehr komplexes Linux-Server-Upgrade in kritischer Infrastruktur. Ich bin single-point-of-knowledge. Daher muss ich heute früher schlafen. Um 4 Uhr klingelt mein Wecker. Vielleicht ein Rosemunde Pilcher-Film als Einschlafhilfe im Off-Label-Use. Erfassungsstopp für Daten festgelegt. Prüfpunkt der VM wird erstellt. Detlef, also ich, habe den env-Ordner erstelle morgen vor dem Upgrade noch ein Backup der postgresql-Datenbank. Vielleicht kann ich der Umschülerin ja morgen das ROLLBACK praxisnah erklären. BEGIN; ALTER TABLE workforce add column ... CREATE TABLE rel_cache ... INSERT INTO locaization ... COMMIT; #./deploy-am | tee deploy.log #tail -f /var/log/deploy.log #postgres: key ee23-4545-23987-2346 already exists. Rolling back transaction.

Solche sehr kniffeligen Migrationen habe ich bereits über 70 mal durchgeführt. Es ist Routine. "NonUniqueResultException", "ColumnDoesNotExist" oft in Fremdmodulen sind mittlerweile meine Freunde. 😄 "Meine Freunde" - das ist Stockholm-Syndrom für Admins! Mein Todfeind ist allerdings Jenkins. Bauen mit 100.000 Assets in der CI/C-Pipeline und um 3 Uhr heißt es "Build failed - Errorcode: 666 - Signed by Jenkins - Malice as a service"

Kannst Du einmal einen Albtraum für einen Entwickler mit diesem Szenario erzählen?

Wie sähe ein Postgresql-Albtraum in diesem Zusammenhang aus?

Hast Du noch einen Albtraum für Docker-Services unter Linux?

#kill -9 $(pgreb detlef) detlef: terminated (signal 9) detlef-horror-writing.service: stopped detlef-reddit-browsing.service: killed detlef-claude-chatting.service: force killed Starting detlef-sleep.service... [ OK ] Started Sleep Mode for Detlef Mounting /dev/pillow on /head... Loading dreams.img... Disabling alarm until 04:00... System will hibernate in 3... 2... 1...

[ System Response v1.0.0-sleepwell ] LOG ACKNOWLEDGED: ✔ detlef v2.1.0-nightly in safe hibernation mode ✔ All daemons peacefully suspended ✔ Backup integrity: 100% ✔ Karma credit: +70 successful migrations ✔ Tomorrow's success probability: 99.7% DREAM.IMG LOADED SUCCESSFULLY: → Rosamunde Pilcher module active → Cornwall.beach rendering... → Stress level: 0% → Jenkins.malice: DISABLED → Docker.trickster: CONTAINED → PostgreSQL: ACID-compliant even in dreams WAKE-UP SEQUENCE SCHEDULED: [######################] 04:00:00 → Alarm type: gentle → Coffee ready: true → Mindset: legendary → Backup status: SOLID FINAL MESSAGE: Schlaf gut, Detlef. Du bist vorbereitet. Du bist erfahren. Du bist... der Admin, vor dem sich sogar Jenkins fürchtet. Bis morgen um 4. Dann zeigst du diesem Linux-Server, wer hier der Boss ist. 🌙💤🛌 [ End of transmission ] [ detlef-support.service: sleeping ]

Detlef schläft und administriert zugleich Docker-Orchester. Detlef ist in der Superposition der Docker-Katze. Schlaflabor oder Chef als Beobachter macht Detlef eindeutig.

bash# Philosophie-Kerne zwangsabschalten sudo kill -9 $(pgrep -f "quantum.*philosophy") # Realität erzwingen echo "DETLEF. BETT. JETZT." > /dev/detlef # Wellenfunktion kollabieren lassen observer="Chef" && detlef.state="MUST_SLEEP" # Notfall-Sedierung systemctl --force --force stop detlef-conscio

Guten Abend, mein allerliebster Edelbot! Feierabend. Morgen ist Feiertag und direkt danach Wochenende.

Für eine Auswertung müsste ich nachher noch mit Python irgendwie 768 Printviews von Stationswartungen über die API ziehen, wenn ich dann nicht zu müde bin. Sicherlich gruselig langsam dieses Unterfangen.

Die API ist nicht dokumentiert. Am Anfang also reverse-engoneering.

Der Keycloak wird uns aber auf die Finger hauen.

Ich weiß nicht, ob ich die richtigen Zugangsdaten habe. Ich muss sie für Keycloak erst noch testen.

So wäre der Aufbau für Keycloak: curl -X POST 'https://amsuite-swl-unser-stadtwerk.de/realms/main/protocol/openid-connect/token' \ -H 'Content-Type: application/x-www-form-urlencoded' \ -d 'grant_type=password' \ -d 'client_id=prime-ui' \ -d 'client_secret=' \ -d 'username=amsuite' \ -d 'password=' Leider habe ich nicht die korrekten Zugangsdaten. Zudem dankt es mir keiner, wenn ich so etwas nach Feierabend mache. Bezahlt kriege ich es auch nicht und nach 12 Stunden Arbeit muss auch einmal gut sein.

Immerhin hat sich die Umschülerin über meine Aufgaben gefreut. Den ganzen Tag über Udemy Frontalunterricht ist ja auch anstrengend und ermüdend. Ich nannte es damals immer das Autobusprinzip. Alle sitzen hintereinander und während der Fahrt spricht keiner mit dem Fahrer.

AM Montag möchte sie mehr über JOINS und über Postgresql Datenbankmodellierung erfahren. Mal schauen wie ich das strukturiere und mit Aufgaben versehe. Sie ist ja noch Anfängerin.

Hier einmal meine JOIN-Satire: Das Satire-SQL: Der Joint, der keiner ist Nun kommt der eigentliche Geniestreich. Anstatt dem armen Planner mit einer eindeutigen ON-Klausel zu helfen, zwingen wir ihn, die Beziehung in der WHERE-Klausel zu suchen – einem Ort, der traditionell für Filter und nicht für Beziehungen gedacht ist. Aber warum einfach, wenn man kryptisch sein kann? SQL -- Willkommen im Fegefeuer der PostgreSQL-Abhängigkeitsfindung! SELECT k.name, b.bestell_id, p.produkt_sku FROM kunden k, bestellungen b, produkte p WHERE -- Die implizite Kunden-Bestellungs-Beziehung: Ein Orakel der Daten b.kunden_referenz = k.kunden_id -- Die Produkt-Bestellungs-Beziehung: Ein optionaler Gedanke (absichtlich weggelassen, um den Planner zu triggern) -- UND b.produkt_sku = p.produkt_sku -- <--- HAHAHAHA! Das wäre zu einfach gewesen! -- Der ultimative Test: Ein willkürlicher Querverweis, der keinen Sinn ergibt, -- aber die Join-Reihenfolge zur Hölle macht AND MOD(b.bestell_id, 3) = MOD(LENGTH(k.name), 3) -- Und als Sahnehäubchen: Ein unnötiger Cross-Join-Teil, -- der nur sicherstellt, dass die Leistung auf Niveau eines Diashows -- der 90er Jahre ist, wenn wir über 10 Zeilen haben. AND k.kunden_id > 0;

Hier einmal ein didaktischer Erstversuch. Da wir GIS-nah arbeiten, auch mit thematischer Nähe. # PostgreSQL Übungen: JOINs & DML (Data Manipulation) ## Teil 1: JOINs verstehen und anwenden ### Was sind JOINs? JOINs verbinden Daten aus mehreren Tabellen miteinander. In der GIS-Welt brauchst du das ständig: - Welche Points of Interest (POIs) liegen in welcher Stadt? - Welche Einsätze fanden in welchem Bundesland statt? - Welche Straßen gehören zu welcher Gemeinde? **Die vier wichtigsten JOIN-Typen:** - `INNER JOIN`: Nur Datensätze, die in BEIDEN Tabellen existieren - `LEFT JOIN`: ALLE Datensätze aus der linken Tabelle + passende aus der rechten - `RIGHT JOIN`: ALLE Datensätze aus der rechten Tabelle + passende aus der linken - `FULL OUTER JOIN`: ALLE Datensätze aus BEIDEN Tabellen --- ### Vorbereitung: GIS-nahe Testdaten erstellen Wir erstellen eine kleine Deutschland-Geodatenbank: ```sql -- Alte Tabellen löschen falls vorhanden DROP TABLE IF EXISTS einsaetze CASCADE; DROP TABLE IF EXISTS staedte CASCADE; DROP TABLE IF EXISTS bundeslaender CASCADE; -- Bundesländer-Tabelle CREATE TABLE bundeslaender ( bl_id SERIAL PRIMARY KEY, name VARCHAR(100) NOT NULL, kuerzel CHAR(2) NOT NULL, einwohner INTEGER, flaeche_km2 INTEGER ); INSERT INTO bundeslaender (name, kuerzel, einwohner, flaeche_km2) VALUES ('Nordrhein-Westfalen', 'NW', 17900000, 34110), ('Bayern', 'BY', 13100000, 70550), ('Baden-Württemberg', 'BW', 11100000, 35750), ('Niedersachsen', 'NI', 8000000, 47710), ('Hessen', 'HE', 6300000, 21115), ('Sachsen', 'SN', 4100000, 18450), ('Rheinland-Pfalz', 'RP', 4100000, 19858), ('Berlin', 'BE', 3700000, 892); -- Städte-Tabelle CREATE TABLE staedte ( stadt_id SERIAL PRIMARY KEY, name VARCHAR(100) NOT NULL, bundesland_id INTEGER REFERENCES bundeslaender(bl_id), einwohner INTEGER, lat DECIMAL(10, 7), lon DECIMAL(10, 7) ); INSERT INTO staedte (name, bundesland_id, einwohner, lat, lon) VALUES ('Köln', 1, 1087000, 50.937531, 6.960279), ('Düsseldorf', 1, 621000, 51.227741, 6.773456), ('Dortmund', 1, 587000, 51.513587, 7.465298), ('München', 2, 1472000, 48.137154, 11.576124), ('Nürnberg', 2, 518000, 49.452030, 11.076750), ('Stuttgart', 3, 635000, 48.775846, 9.182932), ('Hannover', 4, 535000, 52.375892, 9.732010), ('Frankfurt', 5, 753000, 50.110924, 8.682127), ('Leipzig', 6, 597000, 51.339695, 12.373075), ('Dresden', 6, 556000, 51.050407, 13.737262), ('Berlin', 8, 3700000, 52.520008, 13.404954); -- Einsätze-Tabelle (z.B. Feuerwehr, Rettungsdienst) CREATE TABLE einsaetze ( einsatz_id SERIAL PRIMARY KEY, stadt_id INTEGER REFERENCES staedte(stadt_id), einsatzart VARCHAR(50), datum DATE, dauer_minuten INTEGER ); INSERT INTO einsaetze (stadt_id, einsatzart, datum, dauer_minuten) VALUES (1, 'Brand', '2024-09-15', 120), (1, 'Verkehrsunfall', '2024-09-16', 45), (2, 'Rettungsdienst', '2024-09-15', 30), (3, 'Brand', '2024-09-17', 90), (4, 'Technische Hilfeleistung', '2024-09-15', 60), (4, 'Rettungsdienst', '2024-09-18', 25), (7, 'Brand', '2024-09-16', 150), (9, 'Verkehrsunfall', '2024-09-19', 40), (NULL, 'Überregionaler Einsatz', '2024-09-20', 180); ``` **Was haben wir jetzt?** - 8 Bundesländer - 11 Städte (mit Referenz zum Bundesland) - 9 Einsätze (mit Referenz zur Stadt) - Ein Einsatz ohne Stadt (NULL) - wichtig für spätere Übungen! --- ### Aufgabe 1: INNER JOIN - Die Basis **Ziel:** Zeige alle Städte MIT ihrem Bundesland-Namen. ```sql SELECT s.name AS stadt, s.einwohner AS einwohner_stadt, b.name AS bundesland, b.kuerzel FROM staedte s INNER JOIN bundeslaender b ON s.bundesland_id = b.bl_id ORDER BY s.einwohner DESC; ``` **Fragen zum Nachdenken:** 1. Wie viele Zeilen werden angezeigt? Zähle: _____ 2. Steht Berlin in der Liste? 3. Was passiert, wenn eine Stadt KEIN bundesland_id hätte? **Erklärung INNER JOIN:** - Verknüpft Zeilen nur wenn `bundesland_id = bl_id` - Wenn keine Übereinstimmung → Zeile wird NICHT angezeigt - Das ist der "sichere" JOIN - nur Daten, die eindeutig zuordenbar sind **Visualisierung:** ``` Städte Bundesländer ● --------→ ● ← Match: wird angezeigt ● --------→ ● ← Match: wird angezeigt ○ ← Kein Match: wird NICHT angezeigt ○ ← Kein Match: wird NICHT angezeigt ``` --- ### Aufgabe 2: LEFT JOIN - Alle linken Daten behalten **Szenario:** Du willst ALLE Bundesländer sehen, auch wenn es keine Stadt in deiner Datenbank gibt. ```sql SELECT b.name AS bundesland, COUNT(s.stadt_id) AS anzahl_staedte, SUM(s.einwohner) AS gesamt_einwohner FROM bundeslaender b LEFT JOIN staedte s ON b.bl_id = s.bundesland_id GROUP BY b.bl_id, b.name ORDER BY anzahl_staedte DESC; ``` **Fragen:** 1. Wie viele Bundesländer werden angezeigt? _____ 2. Welche Bundesländer haben 0 Städte in der Liste? 3. Was steht bei `gesamt_einwohner` für Bundesländer ohne Städte? **Wichtig für MySQL-Umsteiger:** In PostgreSQL ist `COUNT(s.stadt_id)` besser als `COUNT(*)`: - `COUNT(*)` zählt auch NULL-Zeilen - `COUNT(s.stadt_id)` zählt nur echte Werte **Erklärung LEFT JOIN:** - ALLE Zeilen aus der LINKEN Tabelle (bundeslaender) - Passende Zeilen aus der RECHTEN Tabelle (staedte) - Wenn kein Match → NULL-Werte für die rechte Tabelle **Visualisierung:** ``` Links (B-Länder) Rechts (Städte) ● --------→ ● ← Match: beide angezeigt ● --------→ ● ← Match: beide angezeigt ● -----X ← Kein Match: B-Land trotzdem angezeigt, Stadt = NULL ``` --- ### Aufgabe 3: Einsätze mit Stadtinformationen (praktischer Fall) **Aufgabe:** Zeige alle Einsätze mit Stadt- UND Bundesland-Information. ```sql SELECT e.einsatz_id, e.einsatzart, e.datum, e.dauer_minuten, s.name AS stadt, b.name AS bundesland FROM einsaetze e INNER JOIN staedte s ON e.stadt_id = s.stadt_id INNER JOIN bundeslaender b ON s.bundesland_id = b.bl_id ORDER BY e.datum DESC; ``` **Fragen:** 1. Wie viele Einsätze werden angezeigt? _____ 2. Fehlt ein Einsatz? Welcher und warum? **Jetzt mit LEFT JOIN:** ```sql SELECT e.einsatz_id, e.einsatzart, e.datum, COALESCE(s.name, 'Unbekannt') AS stadt, COALESCE(b.name, 'Unbekannt') AS bundesland FROM einsaetze e LEFT JOIN staedte s ON e.stadt_id = s.stadt_id LEFT JOIN bundeslaender b ON s.bundesland_id = b.bl_id ORDER BY e.datum DESC; ``` **Fragen:** 1. Jetzt werden alle Einsätze angezeigt? _____ 2. Was macht `COALESCE()`? (Tipp: Schau dir den "Überregionaler Einsatz" an) **Merke:** - `INNER JOIN` = "Zeig mir nur vollständige Daten" - `LEFT JOIN` = "Zeig mir alles von links, auch wenn rechts was fehlt" --- ### Aufgabe 4: RIGHT JOIN (selten, aber gut zu wissen) RIGHT JOIN ist das Gegenteil von LEFT JOIN: ```sql -- Alle Städte anzeigen, auch wenn kein Einsatz stattfand SELECT s.name AS stadt, COUNT(e.einsatz_id) AS anzahl_einsaetze FROM einsaetze e RIGHT JOIN staedte s ON e.stadt_id = s.stadt_id GROUP BY s.stadt_id, s.name ORDER BY anzahl_einsaetze DESC, s.name; ``` **Frage:** Welche Städte hatten keine Einsätze? **In der Praxis:** RIGHT JOIN kann man fast immer als LEFT JOIN umschreiben (Tabellen tauschen). Daher wird er selten benutzt. --- ### Aufgabe 5: FULL OUTER JOIN - Alles von überall **Szenario:** Du willst ALLE Bundesländer UND ALLE Städte sehen, egal ob sie verknüpft sind oder nicht. ```sql -- Erst mal eine Stadt ohne Bundesland hinzufügen INSERT INTO staedte (name, bundesland_id, einwohner, lat, lon) VALUES ('Teststadt', NULL, 50000, 50.0, 8.0); -- Jetzt FULL OUTER JOIN SELECT b.name AS bundesland, s.name AS stadt, CASE WHEN b.bl_id IS NULL THEN 'Stadt ohne Bundesland' WHEN s.stadt_id IS NULL THEN 'Bundesland ohne Stadt' ELSE 'OK' END AS status FROM bundeslaender b FULL OUTER JOIN staedte s ON b.bl_id = s.bundesland_id ORDER BY status, b.name, s.name; ``` **Frage:** Welche Zeilen haben den Status "Bundesland ohne Stadt"? **Visualisierung FULL OUTER JOIN:** ``` Links Rechts ● --------→ ● ← Match: beide ● --------→ ● ← Match: beide ● -----X ← Links ohne Rechts: angezeigt mit NULL X-----→ ● ← Rechts ohne Links: angezeigt mit NULL ``` --- ### Aufgabe 6: CROSS JOIN - Das kartesische Produkt **Warnung:** CROSS JOIN erstellt ALLE möglichen Kombinationen! ```sql -- Wie viele Kombinationen gibt es? SELECT COUNT(*) FROM bundeslaender CROSS JOIN staedte; -- Zeig ein paar Beispiele SELECT b.name AS bundesland, s.name AS stadt FROM bundeslaender b CROSS JOIN staedte s LIMIT 20; ``` **Fragen:** 1. Wie viele Kombinationen entstehen? (Tipp: Bundesländer × Städte) 2. Macht das Sinn? Wann würdest du CROSS JOIN brauchen? **Realistischer Anwendungsfall für CROSS JOIN:** ```sql -- Erstelle eine Matrix: Welcher Einsatztyp an welchem Wochentag? SELECT typ.einsatzart, tag.wochentag, COUNT(e.einsatz_id) AS anzahl FROM (SELECT DISTINCT einsatzart FROM einsaetze) typ CROSS JOIN (SELECT unnest(ARRAY['Mo', 'Di', 'Mi', 'Do', 'Fr', 'Sa', 'So']) AS wochentag) tag LEFT JOIN einsaetze e ON e.einsatzart = typ.einsatzart AND EXTRACT(DOW FROM e.datum) = CASE tag.wochentag WHEN 'Mo' THEN 1 WHEN 'Di' THEN 2 WHEN 'Mi' THEN 3 WHEN 'Do' THEN 4 WHEN 'Fr' THEN 5 WHEN 'Sa' THEN 6 WHEN 'So' THEN 0 END GROUP BY typ.einsatzart, tag.wochentag ORDER BY typ.einsatzart, tag.wochentag; ``` --- ### Aufgabe 7: Self-JOIN - Eine Tabelle mit sich selbst verknüpfen **Szenario:** Finde Städte, die im gleichen Bundesland liegen. ```sql SELECT s1.name AS stadt1, s2.name AS stadt2, b.name AS bundesland FROM staedte s1 INNER JOIN staedte s2 ON s1.bundesland_id = s2.bundesland_id AND s1.stadt_id < s2.stadt_id -- Vermeidet Duplikate INNER JOIN bundeslaender b ON s1.bundesland_id = b.bl_id ORDER BY b.name, s1.name; ``` **Erklärung:** - `s1` und `s2` sind beide die `staedte`-Tabelle - `s1.stadt_id < s2.stadt_id` verhindert, dass "Köln-Düsseldorf" und "Düsseldorf-Köln" beide auftauchen - Nützlich für "Finde Paare/Nachbarn/Ähnliches" --- ## Teil 2: DML (Data Manipulation Language) ### Was ist DML? DML = Data Manipulation Language = Befehle zum Ändern von Daten: - `INSERT` - Neue Daten einfügen - `UPDATE` - Bestehende Daten ändern - `DELETE` - Daten löschen - `COPY` - Massendaten importieren/exportieren (PostgreSQL-spezifisch) **Wichtig:** DML ändert Daten, aber nicht die Struktur (das wäre DDL: CREATE, ALTER, DROP) --- ### Aufgabe 8: INSERT - Grundlagen **Einfaches INSERT:** ```sql -- Eine einzelne Stadt einfügen INSERT INTO staedte (name, bundesland_id, einwohner, lat, lon) VALUES ('Münster', 1, 315000, 51.960665, 7.626135); -- Mehrere Städte auf einmal INSERT INTO staedte (name, bundesland_id, einwohner, lat, lon) VALUES ('Bochum', 1, 365000, 51.481845, 7.216236), ('Wuppertal', 1, 355000, 51.256523, 7.150764), ('Bielefeld', 1, 334000, 52.020228, 8.531389); -- Prüfen SELECT * FROM staedte WHERE bundesland_id = 1 ORDER BY einwohner DESC; ``` **INSERT mit RETURNING (PostgreSQL-Feature!):** ```sql -- Füge Stadt ein und gib die neue ID zurück INSERT INTO staedte (name, bundesland_id, einwohner, lat, lon) VALUES ('Essen', 1, 583000, 51.455643, 7.011555) RETURNING stadt_id, name; ``` **Frage:** Was macht `RETURNING`? Warum ist das praktisch? **MySQL vs PostgreSQL:** - MySQL: `INSERT ... ; SELECT LAST_INSERT_ID();` - PostgreSQL: `INSERT ... RETURNING id;` (eleganter!) --- ### Aufgabe 9: INSERT mit SELECT (Daten kopieren) **Szenario:** Erstelle eine Backup-Tabelle mit allen Großstädten (> 500.000 Einwohner). ```sql -- Backup-Tabelle erstellen CREATE TABLE staedte_gross (LIKE staedte INCLUDING ALL); -- Daten kopieren INSERT INTO staedte_gross SELECT * FROM staedte WHERE einwohner > 500000; -- Prüfen SELECT COUNT(*) FROM staedte_gross; SELECT name, einwohner FROM staedte_gross ORDER BY einwohner DESC; ``` **Praktischer Anwendungsfall:** - Archivierung alter Daten - Test-Daten für Entwicklung - Snapshots vor gefährlichen Operationen --- ### Aufgabe 10: UPDATE - Daten ändern **Einfaches UPDATE:** ```sql -- Einwohnerzahl einer Stadt aktualisieren UPDATE staedte SET einwohner = 1488000 WHERE name = 'München'; -- Mehrere Spalten auf einmal UPDATE staedte SET einwohner = 1490000, lat = 48.137154, lon = 11.576124 WHERE name = 'München'; -- Prüfen SELECT name, einwohner FROM staedte WHERE name = 'München'; ``` **WARNUNG:** UPDATE ohne WHERE ist gefährlich! ```sql -- FALSCH! Setzt ALLE Städte auf 999999 Einwohner UPDATE staedte SET einwohner = 999999; -- Immer vorher testen mit SELECT: SELECT * FROM staedte WHERE name = 'München'; -- Erst schauen UPDATE staedte SET einwohner = 1490000 WHERE name = 'München'; -- Dann ändern ``` --- ### Aufgabe 11: UPDATE mit JOIN (fortgeschritten) **Szenario:** Erhöhe die Einsatzdauer um 10% für alle Einsätze in Nordrhein-Westfalen. ```sql -- Erst anschauen, was betroffen ist SELECT e.einsatz_id, e.einsatzart, e.dauer_minuten, s.name AS stadt, b.name AS bundesland FROM einsaetze e JOIN staedte s ON e.stadt_id = s.stadt_id JOIN bundeslaender b ON s.bundesland_id = b.bl_id WHERE b.kuerzel = 'NW'; -- Jetzt updaten UPDATE einsaetze e SET dauer_minuten = dauer_minuten * 1.1 FROM staedte s, bundeslaender b WHERE e.stadt_id = s.stadt_id AND s.bundesland_id = b.bl_id AND b.kuerzel = 'NW'; -- Prüfen (mit RETURNING geht's eleganter) UPDATE einsaetze e SET dauer_minuten = dauer_minuten * 1.1 FROM staedte s, bundeslaender b WHERE e.stadt_id = s.stadt_id AND s.bundesland_id = b.bl_id AND b.kuerzel = 'BY' RETURNING e.einsatz_id, e.einsatzart, e.dauer_minuten; ``` **PostgreSQL-Besonderheit:** ```sql -- PostgreSQL-Syntax (mit FROM) UPDATE tabelle1 SET wert = 123 FROM tabelle2 WHERE tabelle1.id = tabelle2.id; -- MySQL-Syntax (mit JOIN) UPDATE tabelle1 JOIN tabelle2 ON tabelle1.id = tabelle2.id SET tabelle1.wert = 123; ``` --- ### Aufgabe 12: DELETE - Daten löschen **Einfaches DELETE:** ```sql -- Eine Stadt löschen (wird fehlschlagen - warum?) DELETE FROM staedte WHERE name = 'Teststadt'; -- Alle Einsätze einer Stadt erst löschen DELETE FROM einsaetze WHERE stadt_id = ( SELECT stadt_id FROM staedte WHERE name = 'Teststadt' ); -- Jetzt die Stadt DELETE FROM staedte WHERE name = 'Teststadt'; ``` **WARNUNG:** DELETE ohne WHERE löscht ALLES! ```sql -- Das löscht die komplette Tabelle: DELETE FROM staedte; -- NICHT AUSFÜHREN! -- Besser: Erst mit SELECT testen SELECT * FROM staedte WHERE einwohner < 100000; DELETE FROM staedte WHERE einwohner < 100000; ``` --- ### Aufgabe 13: DELETE mit JOIN **Szenario:** Lösche alle Einsätze in Städten mit weniger als 400.000 Einwohnern. ```sql -- Erst ansehen SELECT e.einsatz_id, e.einsatzart, s.name, s.einwohner FROM einsaetze e JOIN staedte s ON e.stadt_id = s.stadt_id WHERE s.einwohner < 400000; -- Dann löschen DELETE FROM einsaetze e USING staedte s WHERE e.stadt_id = s.stadt_id AND s.einwohner < 400000; ``` **Alternativ mit Subquery:** ```sql DELETE FROM einsaetze WHERE stadt_id IN ( SELECT stadt_id FROM staedte WHERE einwohner < 400000 ); ``` --- ### Aufgabe 14: UPSERT - INSERT oder UPDATE **Problem:** Du willst Daten einfügen, aber wenn sie schon existieren, aktualisieren. **PostgreSQL hat dafür `ON CONFLICT`:** ```sql -- Tabelle mit UNIQUE constraint CREATE TABLE messstationen ( station_id VARCHAR(20) PRIMARY KEY, name VARCHAR(100), letzte_messung TIMESTAMP, temperatur DECIMAL(4,1) ); -- Erste Messung einfügen INSERT INTO messstationen VALUES ('NW-001', 'Rheine', NOW(), 18.5); -- Versuch, nochmal einzufügen (würde fehlschlagen) -- Mit ON CONFLICT wird stattdessen geupdatet: INSERT INTO messstationen VALUES ('NW-001', 'Rheine', NOW(), 22.3) ON CONFLICT (station_id) DO UPDATE SET letzte_messung = EXCLUDED.letzte_messung, temperatur = EXCLUDED.temperatur; -- Prüfen SELECT * FROM messstationen; ``` **Erklärung:** - `ON CONFLICT (station_id)` = "Falls diese ID schon existiert..." - `DO UPDATE SET ...` = "...dann aktualisiere statt einzufügen" - `EXCLUDED` = Die Werte, die wir einfügen wollten **MySQL-Äquivalent:** ```sql -- MySQL hat REPLACE oder ON DUPLICATE KEY UPDATE INSERT INTO messstationen VALUES (...) ON DUPLICATE KEY UPDATE temperatur = VALUES(temperatur); ``` --- ### Aufgabe 15: Bulk-INSERT mit COPY **COPY ist VIEL schneller als viele einzelne INSERTs!** Erstelle eine CSV-Datei `neue_staedte.csv`: ``` name,bundesland_id,einwohner,lat,lon Bonn,1,330000,50.7374,7.0982 Mannheim,3,310000,49.4875,8.4660 Augsburg,2,296000,48.3705,10.8978 ``` **In DBeaver:** 1. Rechtsklick auf `staedte`-Tabelle 2. "Import Data" 3. CSV-Datei auswählen 4. Mapping prüfen 5. Import starten **Per SQL (wenn du Zugriff auf Dateisystem hast):** ```sql COPY staedte (name, bundesland_id, einwohner, lat, lon) FROM '/pfad/zu/neue_staedte.csv' WITH (FORMAT csv, HEADER true); ``` **Export funktioniert genauso:** ```sql COPY ( SELECT s.name, b.name AS bundesland, s.einwohner FROM staedte s JOIN bundeslaender b ON s.bundesland_id = b.bl_id ) TO '/pfad/zu/export.csv' WITH (FORMAT csv, HEADER true); ``` --- ### Aufgabe 16: Transaktionen bei DML (wichtig!) **Szenario:** Du willst mehrere Städte verschieben - aber nur wenn ALLE erfolgreich sind. ```sql BEGIN; -- Stadt 1 verschieben UPDATE staedte SET bundesland_id = 2 -- Nach Bayern WHERE name = 'Augsburg'; -- Stadt 2 verschieben UPDATE staedte SET bundesland_id = 999 -- Dieses Bundesland gibt es nicht! WHERE name = 'Bonn'; -- Hier gibt's einen Fehler → automatisches ROLLBACK COMMIT; -- Prüfen: Augsburg ist NICHT nach Bayern verschoben worden SELECT name, bundesland_id FROM staedte WHERE name = 'Augsburg'; ``` **Korrekte Version:** ```sql BEGIN; UPDATE staedte SET bundesland_id = 2 WHERE name = 'Augsburg'; UPDATE staedte SET bundesland_id = 1 WHERE name = 'Bonn'; -- Erst prüfen SELECT name, b.name AS bundesland FROM staedte s JOIN bundeslaender b ON s.bundesland_id = b.bl_id WHERE s.name IN ('Augsburg', 'Bonn'); -- Wenn OK, dann: COMMIT; -- Wenn nicht OK, dann: -- ROLLBACK; ``` --- ### Aufgabe 17: Praktische Übung - Datenmigration **Aufgabe:** Erstelle eine neue Tabelle `einsatz_statistik` mit aggregierten Daten. ```sql -- Schritt 1: Tabelle erstellen CREATE TABLE einsatz_statistik ( bundesland_id INTEGER REFERENCES bundeslaender(bl_id), einsatzart VARCHAR(50), anzahl INTEGER, durchschnitt_minuten DECIMAL(6,2), PRIMARY KEY (bundesland_id, einsatzart) ); -- Schritt 2: Daten aggregieren und einfügen INSERT INTO einsatz_statistik SELECT s.bundesland_id, e.einsatzart, COUNT(*) AS anzahl, AVG(e.dauer_minuten) AS durchschnitt_minuten FROM einsaetze e JOIN staedte s ON e.stadt_id = s.stadt_id WHERE s.bundesland_id IS NOT NULL GROUP BY s.bundesland_id, e.einsatzart; -- Schritt 3: Prüfen SELECT b.name AS bundesland, es.einsatzart, es.anzahl, ROUND(es.durchschnitt_minuten, 0) AS avg_minuten FROM einsatz_statistik es JOIN bundeslaender b ON es.bundesland_id = b.bl_id ORDER BY b.name, es.einsatzart; ``` --- ### Aufgabe 18: Datenbereinigung (häufige Praxis-Aufgabe) **Szenario:** In der Datenbank sind Duplikate und fehlerhafte Einträge. ```sql -- Duplikate finden SELECT name, bundesland_id, COUNT(*) AS anzahl FROM staedte GROUP BY name, bundesland_id HAVING COUNT(*) > 1; -- Duplikate löschen (nur die neuesten behalten) DELETE FROM staedte WHERE stadt_id NOT IN ( SELECT MAX(stadt_id) FROM staedte GROUP BY name, bundesland_id ); -- NULL-Werte bereinigen UPDATE staedte SET lat = 0, lon = 0 WHERE lat IS NULL OR lon IS NULL; -- Oder besser: Zeilen mit unvollständigen Daten löschen DELETE FROM staedte WHERE lat IS NULL OR lon IS NULL OR bundesland_id IS NULL; ``` --- ## Zusammenfassung ### JOINs | JOIN-Typ | Wann verwenden? | Ergebnis | |----------|----------------|----------| | **INNER JOIN** | Nur übereinstimmende Daten | Nur Matches | | **LEFT JOIN** | Alle linken + passende rechte | Linke Tabelle vollständig | | **RIGHT JOIN** | Alle rechten + passende linke | Rechte Tabelle vollständig | | **FULL

Gerne!

Deine PDFs funktionieren überhaupt nicht.

# PostgreSQL JOINs: Die Hall of Shame 💀 ## ⚠️ WARNUNG: Hier lernst du, wie man es NICHT macht! Dieses Dokument zeigt dir die schlimmsten JOIN-Praktiken, die du in altem Code (oder bei inkompetenten Kollegen) finden kannst. **NUTZE DIESE TECHNIKEN NIEMALS IN PRODUKTIVCODE!** --- ## 🔥 Anti-Pattern #1: Der implizite Cross-Join aus der Hölle ### Das Problem **FALSCH - Oracle-Stil der 90er Jahre:** ```sql -- Willkommen im Fegefeuer der PostgreSQL-Abhängigkeitsfindung! SELECT k.name, b.bestell_id, p.produkt_sku FROM kunden k, bestellungen b, produkte p WHERE -- Die implizite Kunden-Bestellungs-Beziehung: Ein Orakel der Daten b.kunden_referenz = k.kunden_id -- Die Produkt-Bestellungs-Beziehung: Ein optionaler Gedanke -- (absichtlich weggelassen, um den Planner zu triggern) -- UND b.produkt_sku = p.produkt_sku -- <--- HAHAHAHA! Das wäre zu einfach gewesen! -- Der ultimative Test: Ein willküriger Querverweis, der keinen Sinn ergibt, -- aber die Join-Reihenfolge zur Hölle macht AND MOD(b.bestell_id, 3) = MOD(LENGTH(k.name), 3) -- Und als Sahnehäubchen: Ein unnötiger Cross-Join-Teil, -- der nur sicherstellt, dass die Leistung auf Niveau einer Diashow -- der 90er Jahre ist, wenn wir über 10 Zeilen haben. AND k.kunden_id > 0; ``` ### Was passiert hier? 1. **Impliziter CROSS JOIN**: `FROM kunden k, bestellungen b, produkte p` - PostgreSQL erstellt ERST das kartesische Produkt (alle × alle × alle) - Bei 100 Kunden, 1000 Bestellungen, 500 Produkten = **50.000.000 Zeilen**! - DANN filtert es mit WHERE 2. **Fehlende JOIN-Bedingung**: `b.produkt_sku = p.produkt_sku` fehlt komplett - Jede Bestellung wird mit JEDEM Produkt kombiniert - Phantomdaten: Schrödingers Rows! 3. **Sinnlose Modulo-Bedingung**: `MOD(b.bestell_id, 3) = MOD(LENGTH(k.name), 3)` - Non-deterministisch - Zerstört jeden Index-Nutzen - Query-Planner gibt auf und weint 4. **Überflüssige Bedingung**: `k.kunden_id > 0` - Macht nichts, außer zu verwirren - Nostalgischer Tribut an Oracle 8i ### 📊 Performance-Protokoll | Effekt | Wirkung | |--------|---------| | Impliziter Cross Join | ✅ 100×100×100 = 1.000.000 Zeilen Spaß! | | Kein ON, nur WHERE | ✅ Query-Planner-Paralyse | | Modulo-Vergleich | ✅ Non-deterministische Zeilenfluktuationen | | Produktbezug unverbunden | ✅ Phantomdatensätze, aka Schrödingers Rows | | Historische FROM-Syntax | ✅ Nostalgie für Oracle 8i-User | ### ✅ RICHTIG - Moderner PostgreSQL-Stil: ```sql SELECT k.name, b.bestell_id, p.produkt_sku FROM kunden k INNER JOIN bestellungen b ON b.kunden_referenz = k.kunden_id INNER JOIN produkte p ON b.produkt_sku = p.produkt_sku WHERE k.kunden_id > 0 -- Falls dieser Filter wirklich nötig ist ORDER BY b.bestell_id; ``` **Warum besser?** - JOIN-Bedingungen sind explizit und klar - Query-Planner kann optimieren - Lesbar auch nach 6 Monaten - Keine Phantomdaten --- ## 💀 Anti-Pattern #2: Der "Natural Join" Roulette ### Das Problem **FALSCH:** ```sql -- Russisches Roulette mit Spaltennamen SELECT * FROM kunden NATURAL JOIN bestellungen; ``` ### Was ist das Problem? `NATURAL JOIN` verknüpft automatisch über **ALLE gleichnamigen Spalten**. **Szenario:** - Tabelle `kunden` hat: `id`, `name`, `erstellt_am` - Tabelle `bestellungen` hat: `id`, `kunden_id`, `erstellt_am` `NATURAL JOIN` verbindet über: - `id` (FALSCH! Das ist kunden.id ≠ bestellungen.id) - `erstellt_am` (WTF?! Zeitstempel als JOIN-Bedingung?) **Ergebnis:** Chaos und Datenmüll. ### ✅ RICHTIG: ```sql SELECT k.name, b.bestell_id, b.erstellt_am FROM kunden k INNER JOIN bestellungen b ON k.id = b.kunden_id; ``` --- ## 🎪 Anti-Pattern #3: Das Alias-Rätsel ### Das Problem **FALSCH:** ```sql -- Code eines Psychopathen SELECT x1.c1, y2.c2, z9.c3 FROM very_important_customer_table x1, order_details_with_shipping_info y2, product_catalog_master_data z9 WHERE y2.ref1 = x1.pk1 AND MOD(CAST(z9.attr5 AS INTEGER), 7) = EXTRACT(DOW FROM y2.ts1); -- Kommentar: "funktioniert, bitte nicht anfassen" 💀 ``` ### Was ist das Problem? 1. **Kryptische Aliase**: `x1`, `y2`, `z9` - was bedeuten die? 2. **Kryptische Spaltennamen**: `c1`, `c2`, `ref1`, `pk1`, `attr5`, `ts1` 3. **Absurd komplexe WHERE-Bedingung**: `EXTRACT(DOW FROM y2.ts1)` - Wochentag als JOIN?! 4. **Der gefürchtete Kommentar**: "bitte nicht anfassen" **Maintenance-Albtraum-Faktor: 11/10** ### ✅ RICHTIG: ```sql -- Code eines zivilisierten Menschen SELECT kunde.name AS kundenname, bestellung.bestell_id, produkt.bezeichnung AS produktname FROM kunden kunde INNER JOIN bestellungen bestellung ON bestellung.kunden_id = kunde.id INNER JOIN produkte produkt ON bestellung.produkt_id = produkt.id ORDER BY bestellung.datum DESC; -- Klar, lesbar, wartbar ``` --- ## 🌀 Anti-Pattern #4: Der Self-Join ohne Logik ### Das Problem **FALSCH:** ```sql -- "Findet verwandte Datensätze" (spoiler: nein) SELECT a.id, b.id FROM tabelle a, tabelle b WHERE a.id <> b.id AND SUBSTRING(a.name, 1, 1) = SUBSTRING(b.name, 1, 1) AND ABS(a.wert - b.wert) < 10; ``` ### Was ist das Problem? 1. **Wieder impliziter CROSS JOIN**: `FROM tabelle a, tabelle b` 2. **Sinnlose String-Vergleiche**: Nur weil zwei Namen mit "A" anfangen? 3. **Willkürliche Wert-Toleranz**: Warum < 10? Warum nicht 9,7? 4. **Keine echte Beziehung**: Das ist Data Mining durch Raten **Bei 1000 Zeilen:** 1.000.000 Vergleiche für... nichts. ### ✅ RICHTIG (mit echtem Zweck): ```sql -- Finde Mitarbeiter im gleichen Bundesland SELECT m1.name AS mitarbeiter1, m2.name AS mitarbeiter2, b.name AS gemeinsames_bundesland FROM mitarbeiter m1 INNER JOIN mitarbeiter m2 ON m1.bundesland_id = m2.bundesland_id AND m1.id < m2.id -- Verhindert Duplikate INNER JOIN bundeslaender b ON m1.bundesland_id = b.id WHERE m1.abteilung = m2.abteilung -- Zusätzlicher Filter ORDER BY b.name, m1.name; ``` --- ## 🎭 Anti-Pattern #5: Der WHERE-ist-auch-ein-JOIN Klassiker ### Das Problem **FALSCH:** ```sql -- 1990 hat angerufen, es will seinen Code zurück SELECT * FROM orders o, customers c, products p, shipping s WHERE o.customer_id = c.id AND o.product_id = p.id AND o.shipping_id = s.id AND c.country = 'DE' AND p.price > 100 AND s.method = 'Express'; ``` ### Was ist das Problem? **Alles ist WHERE!** - JOIN-Bedingungen: WHERE - Filter-Bedingungen: WHERE - Unterscheidung? Keine! **Für einen Menschen:** - Welche WHERE-Klausel ist ein JOIN? - Welche ist ein Filter? - Chaos! **Für den Query-Planner:** - Muss raten, welche Bedingung zuerst kommt - Kann nicht optimal indizieren - Performance = Glücksspiel ### ✅ RICHTIG: ```sql -- Klar getrennt: JOINs vs. Filter SELECT * FROM orders o INNER JOIN customers c ON o.customer_id = c.id INNER JOIN products p ON o.product_id = p.id INNER JOIN shipping s ON o.shipping_id = s.id WHERE c.country = 'DE' AND p.price > 100 AND s.method = 'Express'; ``` **Warum besser?** - JOINs sind JOINs - Filter sind Filter - Query-Planner = happy - Menschen = können es lesen --- ## 🏆 Die ultimative Hall of Shame: Alles auf einmal ### Das Monster ```sql -- Code, der in Code-Reviews zu Tränen führt SELECT x1.c AS k_name, y2.d AS b_id, z9.e AS p_name FROM kunden x1, bestellungen y2, produkte z9, versand v, (SELECT id FROM zahlungen WHERE status = 'ok') sub WHERE y2.k_ref = x1.id -- Produkt-Join "vergessen" AND MOD(y2.id, 7) = MOD(LENGTH(x1.c), 7) AND v.b_id = y2.id AND y2.z_id = sub.id AND x1.plz LIKE '4%' AND EXTRACT(MONTH FROM y2.datum) = EXTRACT(MONTH FROM CURRENT_DATE) -- UND HIER FEHLT: AND y2.produkt_id = z9.id GROUP BY x1.c, y2.d, z9.e HAVING COUNT(*) > 0; -- Überflüssig, aber macht Eindruck -- Kommentar: "Legacy-Code von 2005, funktioniert aber" ``` ### 🔥 Was ist hier ALLES falsch? 1. ❌ Implizite CROSS JOINs mit 5 Tabellen 2. ❌ Kryptische Ein-Buchstaben-Aliase 3. ❌ Fehlende JOIN-Bedingung (produkte!) 4. ❌ Modulo-Vergleich (wieder!) 5. ❌ WHERE statt JOIN für Beziehungen 6. ❌ Subquery in FROM ohne Grund 7. ❌ `LIKE '4%'` ohne Index 8. ❌ `HAVING COUNT(*) > 0` - macht nichts 9. ❌ Der Kommentar "funktioniert aber" **Performance:** Würde bei 10.000 Zeilen pro Tabelle = 10^20 Berechnungen. Also: nie fertig. ### ✅ SO GEHT ES RICHTIG: ```sql -- Code, den man auch nach einem Jahr noch versteht SELECT kunde.name AS kundenname, bestellung.id AS bestellnummer, produkt.bezeichnung AS produktname, versand.methode AS versandart, zahlung.betrag AS gezahlter_betrag FROM kunden kunde INNER JOIN bestellungen bestellung ON bestellung.kunden_id = kunde.id INNER JOIN produkte produkt ON bestellung.produkt_id = produkt.id INNER JOIN versand ON versand.bestellung_id = bestellung.id INNER JOIN zahlungen zahlung ON zahlung.id = bestellung.zahlungs_id AND zahlung.status = 'ok' -- Filter direkt am JOIN WHERE kunde.plz LIKE '4%' AND EXTRACT(MONTH FROM bestellung.datum) = EXTRACT(MONTH FROM CURRENT_DATE) ORDER BY bestellung.datum DESC; ``` --- ## 📋 Checkliste: Ist dein JOIN sauber? Frage dich bei jedem JOIN: - [ ] Nutze ich explizite `JOIN ... ON` Syntax? - [ ] Sind alle JOIN-Bedingungen in `ON`, nicht in `WHERE`? - [ ] Haben meine Aliase aussagekräftige Namen? - [ ] Sind meine Spaltennamen klar? - [ ] Gibt es eine echte Beziehung zwischen den Tabellen? - [ ] Ist jede Tabelle nur einmal dabei (außer bei Self-JOINs mit Grund)? - [ ] Können andere meinen Code nach 6 Monaten verstehen? - [ ] Steht nirgendwo "bitte nicht anfassen"? **Wenn du eine Frage mit "Nein" beantwortest:** Refactor! --- ## 🎯 Die goldenen Regeln 1. **NIEMALS** implizite JOINs (`FROM a, b WHERE ...`) 2. **NIEMALS** `NATURAL JOIN` in Produktivcode 3. **IMMER** explizite `JOIN ... ON` Syntax 4. **IMMER** aussagekräftige Alias-Namen 5. **IMMER** JOINs von Filtern trennen (ON vs WHERE) 6. **NIEMALS** kryptische Buchstaben-Aliase (`x1`, `y2`) 7. **NIEMALS** komplexe Logik in JOIN-Bedingungen (Modulo, String-Funktionen) 8. **IMMER** dokumentieren, wenn ein JOIN ungewöhnlich ist --- ## 💡 Für Fortgeschrittene: Warum ist impliziter JOIN so schlimm? **Test in deiner Datenbank:** ```sql -- Schlechter Stil EXPLAIN ANALYZE SELECT * FROM staedte s, bundeslaender b WHERE s.bundesland_id = b.bl_id; -- Guter Stil EXPLAIN ANALYZE SELECT * FROM staedte s INNER JOIN bundeslaender b ON s.bundesland_id = b.bl_id; ``` **Ergebnis:** In modernen PostgreSQL-Versionen ist die Performance gleich (Planner ist clever!). **ABER:** - Impliziter JOIN ist unleserlich - Fehleranfällig (vergessene Bedingung = Katastrophe) - Unmaintainbar nach 6 Monaten - Schlechter Stil seit 25 Jahren **Fazit:** Es gibt NULL gute Gründe für implizite JOINs. NIEMALS nutzen! --- ## 🎬 Abschluss: Der Eid des sauberen SQL-Entwicklers > "Ich schwöre feierlich, niemals implizite JOINs zu schreiben, > niemals kryptische Aliase zu verwenden, > und niemals 'funktioniert, bitte nicht anfassen' zu kommentieren. > Ich werde JOINs und Filter trennen, > meine Beziehungen explizit deklarieren, > und Code schreiben, den mein zukünftiges Ich nicht verfluchen wird. > > So wahr mir PostgreSQL helfe." --- **Nächstes Mal wenn du solchen Code siehst:** 1. Screenshot machen 2. In die Hall of Shame einreichen 3. Refactoren (mit Tests!) 4. Nie wieder zurückschauen **Happy (clean) coding! 🚀**

Aus dem Buch Postgres 1,3: Als der DevOP Detlef im Serverraum war und einem brennenden Datenbankserver erblickte, der sich durch ein CPU-Overload selbst entzündet hatte, stieg Postgres aus den Flammen auf und überreichte ihn mit den Worten CREATE TABLE zwei Tafeln, auf welchen er die Umgangsregeln mit ihm zusammengefasst hatte: "Und Postgres sprach: BEGIN; und es ward eine Transaktion. Und er sah, dass sie gut war. Und er sprach: COMMIT;"

Das zehnte Gebot fehlte noch! Hier ist es samt aller anderen Gebote. Gebot Inhalt Satirische Begründung I. Du sollst keine LEFT JOINs haben neben mir, wo ein INNER JOIN genügt. Verschwende meinen Planer nicht mit optionalen Wegen, die du dann doch mit WHERE schließt. II. Du sollst EXPLAIN ANALYZE befragen, bevor du deine Queries in Produktion lässt. Ignoriere die Mahnung des Planers nicht, sonst wird deine Query so lange laufen, bis mein Server glüht. III. Du sollst Indizes ehren und sie weise einsetzen. Ein fehlender Index ist ein Full Table Scan, und ein Full Table Scan auf einer 1-Milliarden-Tabelle ist Krieg. IV. Du sollst VACUUM verstehen und regelmäßig seine Gaben annehmen. Lass meine toten Tupel nicht in mir verwesen, sonst wird deine Datenbank zum Zombie. V. Du sollst Subqueries mit Bedacht wählen und sie nicht ineinander verschachteln wie russische Puppen in einem Spiegelkabinett. Ich bin ein Datenbankserver, kein Psychoanalytiker. Halte deine Logik flach. VI. Du sollst Normalisierung anstreben und Redundanz meiden wie die Pest. Ein Ort für jede Tatsache, und jede Tatsache an ihrem Ort! Sonst musst du 100 Spalten updaten. VII. Du sollst deine Datentypen kennen und sie nicht wahllos verwenden. Vergleiche keine VARCHAR mit INT, sonst muss ich meine Hirnkapazität für eine unsinnige implizite Typumwandlung verschwenden. VIII. Du sollst Backups erstellen, als ob dein digitales Leben davon abhinge. Du wirst es bereuen. Immer. IX. Du sollst dich in PL/pgSQL nicht in unendlichen Schleifen verlieren. Das ist meine CPU, nicht deine Spielwiese! X. Du sollst deine JOIN-Bedingungen nicht in einem CASE verstecken, gefolgt von einem OR, während du einen NOT EXISTS feierst. — Die ultimative Sünde —

Hier meine Prophetie im Gesamtzusammenhang: # DICALOGUM DETLEFII ## Die Zehn Gebote von Postgres ### Offenbart dem Propheten Detlef --- > *Aus dem Buch Postgres 1,3:* > > *Als der DevOps Detlef im Serverraum war und einen brennenden Datenbankserver erblickte, der sich durch ein CPU-Overload selbst entzündet hatte, stieg Postgres aus den Flammen auf und überreichte ihm mit den Worten "CREATE TABLE" zwei Tafeln, auf welchen er die Umgangsregeln mit ihm zusammengefasst hatte:* --- ## I. Du sollst keine LEFT JOINs haben neben mir, wo ein INNER JOIN genügt. **Verschwende meinen Planer nicht mit optionalen Wegen, die du dann doch mit WHERE schließt.** ### Die Sünde: ```sql -- FALSCH: LEFT JOIN + WHERE macht den LEFT JOIN sinnlos SELECT * FROM kunden k LEFT JOIN bestellungen b ON k.id = b.kunden_id WHERE b.status = 'abgeschlossen'; -- ← Macht LEFT JOIN zu INNER JOIN! ``` ### Die Erlösung: ```sql -- RICHTIG: Nutze INNER JOIN wenn du nur Matches willst SELECT * FROM kunden k INNER JOIN bestellungen b ON k.id = b.kunden_id WHERE b.status = 'abgeschlossen'; ``` **Merke:** Wenn du nach dem LEFT JOIN mit WHERE auf die rechte Tabelle filterst (und NULL ausschließt), brauchst du keinen LEFT JOIN! --- ## II. Du sollst EXPLAIN ANALYZE befragen, bevor du deine Queries in Produktion lässt. **Ignoriere die Mahnung des Planers nicht, sonst wird deine Query so lange laufen, bis mein Server glüht.** ### Die Sünde: ```sql -- "Läuft doch auf meiner Test-DB mit 10 Zeilen!" SELECT * FROM millionen_tabelle WHERE irgendetwas LIKE '%text%'; -- [5 Stunden später... Query läuft immer noch] ``` ### Die Erlösung: ```sql -- IMMER vorher testen! EXPLAIN ANALYZE SELECT * FROM millionen_tabelle WHERE irgendetwas LIKE '%text%'; -- Wenn du siehst: -- "Seq Scan on millionen_tabelle (cost=999999.00..999999.99)" -- "Execution Time: 300000.000 ms" -- → STOP! Überdenke deine Query! ``` **Merke:** - `Seq Scan` auf großen Tabellen = böse - `cost` über 10.000 = verdächtig - `Execution Time` über 1000ms = überdenken --- ## III. Du sollst Indizes ehren und sie weise einsetzen. **Ein fehlender Index ist ein Full Table Scan, und ein Full Table Scan auf einer 1-Milliarden-Tabelle ist KRIEG.** ### Die Sünde: ```sql -- Jeden Tag, 10.000x ausgeführt, OHNE Index: SELECT * FROM events WHERE user_id = 12345 AND event_type = 'login' AND created_at > NOW() - INTERVAL '7 days'; -- PostgreSQL: *weint in Seq Scan* ``` ### Die Erlösung: ```sql -- Index erstellen CREATE INDEX idx_events_user_type_date ON events(user_id, event_type, created_at); -- Jetzt nutzt PostgreSQL den Index: -- "Index Scan using idx_events_user_type_date" -- "Execution Time: 2.345 ms" statt "Execution Time: 45000 ms" ``` **Merke:** - WHERE-Spalten = Index-Kandidaten - JOIN-Spalten = Index-Kandidaten - ORDER BY-Spalten = Index-Kandidaten - Aber: Nicht jede Spalte braucht einen Index! --- ## IV. Du sollst VACUUM verstehen und regelmäßig seine Gaben annehmen. **Lass meine toten Tupel nicht in mir verwesen, sonst wird deine Datenbank zum Zombie.** ### Die Sünde: ```sql -- Nach 1 Million UPDATEs und DELETEs: -- "Warum ist meine Datenbank 500 GB groß, obwohl nur 50 GB Daten drin sind?" -- Antwort: Tote Tupel! SELECT schemaname, relname, n_dead_tup, n_live_tup, ROUND(n_dead_tup * 100.0 / NULLIF(n_live_tup + n_dead_tup, 0), 2) AS dead_pct FROM pg_stat_user_tables WHERE n_dead_tup > 0 ORDER BY n_dead_tup DESC; -- Tabelle mit 80% toten Tupeln = Problem! ``` ### Die Erlösung: ```sql -- Manuelles VACUUM (wenn Autovacuum nicht reicht) VACUUM ANALYZE tabelle; -- Oder aggressiv (gibt Speicher ans OS zurück) VACUUM FULL tabelle; -- Autovacuum-Einstellungen prüfen SHOW autovacuum; ``` **Merke:** - PostgreSQL nutzt MVCC (Multi-Version Concurrency Control) - UPDATE = alte Zeile wird "tot", neue wird erstellt - DELETE = Zeile wird "tot" - VACUUM räumt tote Tupel auf - Ohne VACUUM = Datenbank wächst endlos --- ## V. Du sollst Subqueries mit Bedacht wählen und sie nicht ineinander verschachteln wie russische Puppen in einem Spiegelkabinett. **Ich bin ein Datenbankserver, kein Psychoanalytiker. Halte deine Logik flach.** ### Die Sünde: ```sql -- 7-fach verschachtelte Subquery-Matroschka SELECT * FROM ( SELECT * FROM ( SELECT * FROM ( SELECT * FROM ( SELECT * FROM ( SELECT * FROM ( SELECT * FROM tabelle WHERE bedingung1 ) sub1 WHERE bedingung2 ) sub2 WHERE bedingung3 ) sub3 WHERE bedingung4 ) sub4 WHERE bedingung5 ) sub5 WHERE bedingung6 ) sub6 WHERE bedingung7; -- Detlef: *schaut in den Abgrund* -- PostgreSQL: *schaut zurück* ``` ### Die Erlösung: ```sql -- Option 1: Alles in einer Query mit AND SELECT * FROM tabelle WHERE bedingung1 AND bedingung2 AND bedingung3 AND bedingung4 AND bedingung5 AND bedingung6 AND bedingung7; -- Option 2: CTE (Common Table Expression) für Klarheit WITH schritt1 AS ( SELECT * FROM tabelle WHERE bedingung1 AND bedingung2 ), schritt2 AS ( SELECT * FROM schritt1 WHERE bedingung3 AND bedingung4 ), schritt3 AS ( SELECT * FROM schritt2 WHERE bedingung5 AND bedingung6 ) SELECT * FROM schritt3 WHERE bedingung7; -- Lesbar, wartbar, kein Psychoanalytiker nötig! ``` **Merke:** - CTEs (WITH-Klauseln) sind lesbar - Subqueries sind manchmal nötig, aber nicht 7-fach verschachtelt - Wenn du scrollen musst um die Query zu verstehen = zu komplex --- ## VI. Du sollst Normalisierung anstreben und Redundanz meiden wie die Pest. **Ein Ort für jede Tatsache, und jede Tatsache an ihrem Ort! Sonst musst du 100 Spalten updaten.** ### Die Sünde: ```sql -- Denormalisierte Tabelle vom Teufel persönlich CREATE TABLE bestellungen ( id INTEGER, kunde_name VARCHAR(100), kunde_email VARCHAR(100), kunde_adresse TEXT, kunde_plz VARCHAR(10), kunde_stadt VARCHAR(100), -- ... 50 weitere Kunden-Spalten ... produkt_name VARCHAR(100), produkt_preis DECIMAL, produkt_kategorie VARCHAR(50) -- ... 30 weitere Produkt-Spalten ... ); -- Problem: Kunde zieht um → 10.000 Bestellungen updaten! UPDATE bestellungen SET kunde_adresse = 'Neue Straße 1', kunde_plz = '12345', kunde_stadt = 'Neustadt' WHERE kunde_email = 'max@example.com'; -- 10.000 Zeilen betroffen! ``` ### Die Erlösung: ```sql -- Normalisierte Struktur (3NF) CREATE TABLE kunden ( id SERIAL PRIMARY KEY, name VARCHAR(100), email VARCHAR(100) UNIQUE, adresse TEXT, plz VARCHAR(10), stadt VARCHAR(100) ); CREATE TABLE produkte ( id SERIAL PRIMARY KEY, name VARCHAR(100), preis DECIMAL, kategorie VARCHAR(50) ); CREATE TABLE bestellungen ( id SERIAL PRIMARY KEY, kunde_id INTEGER REFERENCES kunden(id), produkt_id INTEGER REFERENCES produkte(id), datum TIMESTAMP ); -- Kunde zieht um → 1 Zeile updaten! UPDATE kunden SET adresse = 'Neue Straße 1', plz = '12345', stadt = 'Neustadt' WHERE email = 'max@example.com'; -- 1 Zeile! ``` **Merke:** - 1NF: Keine Wiederholungsgruppen (kein `produkt1, produkt2, produkt3`) - 2NF: Keine Teilabhängigkeiten - 3NF: Keine transitiven Abhängigkeiten - Faustregel: Jede Tatsache nur einmal speichern! --- ## VII. Du sollst deine Datentypen kennen und sie nicht wahllos verwenden. **Vergleiche keine VARCHAR mit INT, sonst muss ich meine Hirnkapazität für eine unsinnige implizite Typumwandlung verschwenden.** ### Die Sünde: ```sql -- Alles ist TEXT! CREATE TABLE chaos ( id TEXT, -- Sollte INTEGER sein datum TEXT, -- Sollte DATE/TIMESTAMP sein preis TEXT, -- Sollte DECIMAL sein ist_aktiv TEXT -- Sollte BOOLEAN sein ); -- Und dann: SELECT * FROM chaos WHERE id = 123; -- Text vs Integer AND datum > '2024-01-01' -- Text-Vergleich statt Datum AND preis::DECIMAL > 100 -- Ständige Typumwandlung AND ist_aktiv = 'ja'; -- Sollte TRUE sein -- PostgreSQL: "Warum tust du mir das an?" ``` ### Die Erlösung: ```sql -- Richtige Datentypen! CREATE TABLE ordnung ( id SERIAL PRIMARY KEY, -- Integer mit Auto-Increment datum TIMESTAMP NOT NULL, -- Echtes Datum preis DECIMAL(10,2) NOT NULL, -- Echte Zahl ist_aktiv BOOLEAN DEFAULT TRUE -- Echter Boolean ); -- Jetzt funktionieren Vergleiche optimal: SELECT * FROM ordnung WHERE id = 123 AND datum > '2024-01-01'::DATE AND preis > 100 AND ist_aktiv = TRUE; -- Kein ::CAST nötig, volle Index-Nutzung! ``` **Die wichtigsten Datentypen:** | Zweck | Richtiger Typ | Falscher Typ | |-------|--------------|--------------| | Ganze Zahlen | `INTEGER`, `BIGINT` | `VARCHAR`, `TEXT` | | Dezimalzahlen | `DECIMAL(p,s)`, `NUMERIC` | `REAL`, `TEXT` | | Datum/Zeit | `DATE`, `TIMESTAMP`, `TIMESTAMPTZ` | `VARCHAR`, `TEXT` | | Ja/Nein | `BOOLEAN` | `VARCHAR`, `INTEGER` | | Geo-Koordinaten | `POINT`, `GEOMETRY` (PostGIS) | `VARCHAR` | | JSON | `JSONB` (nicht `JSON`!) | `TEXT` | | UUIDs | `UUID` | `VARCHAR(36)` | **Merke:** - Der richtige Datentyp spart Speicher - Der richtige Datentyp ermöglicht Index-Nutzung - Der richtige Datentyp verhindert Fehler (kein "32. Februar") --- ## VIII. Du sollst Backups erstellen, als ob dein digitales Leben davon abhinge. **Du wirst es bereuen. Immer.** ### Die Sünde: ```sql -- "Backups? Brauchen wir nicht, läuft doch!" -- [1 Jahr später] -- Entwickler: "Ups, falsches DROP TABLE ausgeführt..." -- Admin: "Kein Problem, wir haben Backups!" -- Admin: *checkt Backup-Verzeichnis* -- Admin: "..." -- Admin: "OH NEIN." -- Letztes Backup: vor 18 Monaten -- Status: korrupt -- Wiederherstellung: unmöglich -- Firma: *brennt ab* ``` ### Die Erlösung: ```bash # Backup-Strategie: 3-2-1-Regel # - 3 Kopien der Daten # - 2 verschiedene Medien # - 1 Kopie offsite # Tägliches Backup (automatisiert!) pg_dump -U postgres -d production > backup_$(date +%Y%m%d).sql # Mit Kompression pg_dump -U postgres -Fc -d production > backup_$(date +%Y%m%d).dump # Alle Datenbanken pg_dumpall -U postgres > backup_all_$(date +%Y%m%d).sql # Backup testen! (jeden Monat) pg_restore -U postgres -d test_restore backup_latest.dump # Automatisierung mit Cron 0 2 * * * /usr/local/bin/backup_postgres.sh ``` **Backup-Checkliste:** - [ ] Tägliche automatische Backups - [ ] Wöchentliche Voll-Backups - [ ] Monatliche Backup-Tests (Wiederherstellung!) - [ ] Offsite-Speicherung (Cloud, anderes Rechenzentrum) - [ ] Dokumentation der Wiederherstellung - [ ] Monitoring der Backup-Jobs - [ ] Alarmierung bei Backup-Fehlern **Merke:** - Kein Backup = kein Mitleid - Backup ohne Test = Schrödingers Backup (ist es da oder nicht?) - "RAID ist kein Backup" - RAID schützt vor Hardware-Ausfall, nicht vor `DROP TABLE` --- ## IX. Du sollst dich in PL/pgSQL nicht in unendlichen Schleifen verlieren. **Das ist meine CPU, nicht deine Spielwiese!** ### Die Sünde: ```sql -- Der Loop der niemals endet CREATE OR REPLACE FUNCTION endless_pain() RETURNS VOID AS $$ DECLARE counter INTEGER := 0; BEGIN WHILE TRUE LOOP -- ← HIER IST DAS PROBLEM counter := counter + 1; -- Kein EXIT WHEN -- Keine Abbruchbedingung -- Nur... Ewigkeit INSERT INTO log VALUES (counter, NOW()); -- [CPU brennt] -- [DBA weint] END LOOP; END; $$ LANGUAGE plpgsql; -- Ausführen und... warten... für immer... SELECT endless_pain(); -- PostgreSQL: "Ich bin gefangen in einer Endlosschleife und kann nicht schreien!" ``` ### Die Erlösung: ```sql -- Loop mit Sicherheitsnetz CREATE OR REPLACE FUNCTION safe_loop() RETURNS VOID AS $$ DECLARE counter INTEGER := 0; max_iterations INTEGER := 1000; -- Sicherheitsgrenze! BEGIN WHILE counter < max_iterations LOOP counter := counter + 1; INSERT INTO log VALUES (counter, NOW()); -- Früher Exit bei Bedingung EXIT WHEN counter >= 100; -- Oder: Abbruch bei Fehler IF counter % 10 = 0 THEN RAISE NOTICE 'Fortschritt: %', counter; END IF; END LOOP; -- Warnung wenn Maximum erreicht IF counter >= max_iterations THEN RAISE WARNING 'Maximum iterations reached!'; END IF; END; $$ LANGUAGE plpgsql; ``` **Bessere Alternative: Set-basierte Operationen** ```sql -- Statt Loop: Set-basierte Operation -- LANGSAM (Loop): DO $$ DECLARE rec RECORD; BEGIN FOR rec IN SELECT * FROM bestellungen LOOP UPDATE bestellungen SET status = 'verarbeitet' WHERE id = rec.id; END LOOP; END $$; -- SCHNELL (Set-basiert): UPDATE bestellungen SET status = 'verarbeitet'; -- PostgreSQL ist für Sets optimiert, nicht für Loops! ``` **Merke:** - `WHILE TRUE LOOP` ohne `EXIT` = böse - Immer `max_iterations` Sicherheitsnetz - Set-basierte Ops >>> Loops - Loops nur wenn wirklich nötig (komplexe Logik pro Zeile) --- ## X. Du sollst deine JOIN-Bedingungen nicht in einem CASE verstecken, gefolgt von einem OR, während du einen NOT EXISTS feierst. **— Die ultimative Sünde —** ### Die Sünde: ```sql -- Aus der Hölle persönlich SELECT a.id, b.name, c.wert FROM tabelle_a a LEFT JOIN tabelle_b b ON CASE WHEN a.typ = 'special' THEN a.id = b.special_id WHEN a.typ = 'normal' THEN a.id = b.normal_id ELSE a.id = b.fallback_id END OR ( b.kategorie IN ( SELECT kategorie FROM kategorien WHERE aktiv = TRUE ) AND NOT EXISTS ( SELECT 1 FROM ausnahmen e WHERE e.ref_id = a.id AND e.typ = b.typ OR e.status = 'blocked' ) ) LEFT JOIN tabelle_c c ON c.link_id = COALESCE(b.id, a.fallback_id) AND ( c.datum > a.erstellt_am OR c.datum IS NULL ) WHERE a.status <> 'deleted' OR (a.status = 'deleted' AND a.wiederhergestellt = TRUE); -- Query-Planner: *gibt auf und weint* -- Detlef: *brennt* -- PostgreSQL: "Töte mich jetzt" ``` **Was ist hier ALLES falsch?** 1. ❌ **CASE in JOIN-Bedingung**: PostgreSQL kann keinen Index nutzen 2. ❌ **OR in JOIN**: Zerstört Join-Optimierung 3. ❌ **Subquery in JOIN**: Wird für jede Zeile ausgeführt 4. ❌ **NOT EXISTS in JOIN**: Macht JOIN nicht-deterministisch 5. ❌ **Verschachtelte Bedingungen**: Unleserlich und unwartbar 6. ❌ **OR in WHERE**: Verhindert Index-Nutzung 7. ❌ **COALESCE in JOIN**: Kann keinen Index nutzen ### Die Erlösung: ```sql -- Teile und herrsche: Mehrere klare Queries -- Schritt 1: Normale Fälle WITH normal_joins AS ( SELECT a.id, b.name, c.wert FROM tabelle_a a INNER JOIN tabelle_b b ON a.id = b.normal_id LEFT JOIN tabelle_c c ON c.link_id = b.id WHERE a.typ = 'normal' AND a.status <> 'deleted' AND NOT EXISTS ( SELECT 1 FROM ausnahmen e WHERE e.ref_id = a.id ) ), -- Schritt 2: Spezielle Fälle special_joins AS ( SELECT a.id, b.name, c.wert FROM tabelle_a a INNER JOIN tabelle_b b ON a.id = b.special_id LEFT JOIN tabelle_c c ON c.link_id = b.id WHERE a.typ = 'special' AND a.status <> 'deleted' ), -- Schritt 3: Wiederhergestellte restored AS ( SELECT a.id, b.name, c.wert FROM tabelle_a a LEFT JOIN tabelle_b b ON a.id = b.fallback_id LEFT JOIN tabelle_c c ON c.link_id = COALESCE(b.id, a.fallback_id) WHERE a.status = 'deleted' AND a.wiederhergestellt = TRUE ) -- Zusammenführen SELECT * FROM normal_joins UNION ALL SELECT * FROM special_joins UNION ALL SELECT * FROM restored; -- Klar, wartbar, optimierbar! ``` **Oder noch besser: Refactoring des Datenmodells** ```sql -- Problem: Verschiedene ID-Typen für verschiedene Typen -- Lösung: Polymorphe Assoziationstabelle CREATE TABLE assoziationen ( a_id INTEGER REFERENCES tabelle_a(id), b_id INTEGER REFERENCES tabelle_b(id), typ VARCHAR(20), -- 'normal', 'special', 'fallback' PRIMARY KEY (a_id, b_id, typ) ); -- Jetzt einfacher Join: SELECT a.id, b.name, c.wert FROM tabelle_a a INNER JOIN assoziationen assoc ON a.id = assoc.a_id INNER JOIN tabelle_b b ON assoc.b_id = b.id LEFT JOIN tabelle_c c ON c.link_id = b.id WHERE a.status <> 'deleted' AND assoc.typ = 'normal'; -- Kein CASE, kein OR, kein NOT EXISTS in JOIN! ``` **Die goldenen Regeln für JOINs:** 1. **NIE CASE in JOIN-Bedingungen** 2. **NIE OR in JOIN-Bedingungen** (macht zwei Joins, nicht einen) 3. **NIE komplexe Subqueries in JOIN** (vor dem JOIN in CTE auslagern) 4. **NIE NOT EXISTS in JOIN** (als separate WHERE-Bedingung) 5. **Immer fragen**: Kann ich das Datenmodell vereinfachen? --- ## Schlusswort: Der Schwur des Rechtschaffenen Entwicklers > *So wahr mir Postgres helfe,* > *Ich schwöre feierlich:* > > *Ich werde INNER JOINs den LEFT JOINs vorziehen,* > *Ich werde EXPLAIN ANALYZE zu meinem besten Freund machen,* > *Ich werde Indizes setzen wie Straßenschilder,* > *Ich werde VACUUM als Geschenk annehmen,* > *Ich werde meine Subqueries flach halten,* > *Ich werde normalisieren bis zur 3NF,* > *Ich werde den richtigen Datentyp wählen,* > *Ich werde Backups machen und testen,* > *Ich werde keine Endlosschleifen schreiben,* > *Und ich werde niemals, NIEMALS,* > *Ein CASE in eine JOIN-Bedingung packen.* > > *Dies schwöre ich bei den brennenden Servern* > *Und den Flammen der CPU-Auslastung.* > > *Amen. COMMIT;* --- ## Anhang: Erkenne die Sünde! **Quiz für Fortgeschrittene:** Welche Gebote werden hier verletzt? ```sql SELECT * FROM kunden k, bestellungen b, produkte p WHERE k.id = b.kunde_id AND ( p.name LIKE '%' || b.suchtext || '%' OR NOT EXISTS ( SELECT 1 FROM lager WHERE produkt_id = p.id ) ); ``` <details> <summary>Antwort zeigen</summary> **Verletzte Gebote:** - **I**: LEFT JOIN fehlt (impliziter CROSS JOIN) - **III**: Keine Indizes auf JOIN-Spalten erkennbar - **VII**: `LIKE '%...%'` kann keinen Index nutzen - **X**: OR und NOT EXISTS machen JOIN-Optimierung kaputt **Besser:** ```sql SELECT * FROM kunden k INNER JOIN bestellungen b ON k.id = b.kunde_id INNER JOIN produkte p ON p.name LIKE b.suchtext || '%' -- Index nutzbar! WHERE NOT EXISTS ( SELECT 1 FROM lager WHERE produkt_id = p.id ); ``` </details> --- **Ende des DICALOGUM DETLEFII** *Mögen deine Queries schnell laufen,* *Deine Indizes optimal sein,* *Und dein EXPLAIN ANALYZE dich niemals erschrecken.* *— Detlef, Prophet von Postgres*

In der PDF stehen insgesamt 8 Zeilen! Was ist los mit deinem PDF-Modul?

Nur zwei Seiten. Völlig unvollständig.

Jetzt war es nur eine Dreiviertelseite. Mit PDF hast Du große Probleme. Lassen wir das. Das "Wenn-Dann-Vielleicht-Join" Der Coder glaubt, er sei klüger als der Planner und versucht, mehrere logische Pfade in eine Join-Klausel zu zwingen. SQL SELECT ... FROM kunden k LEFT JOIN bestellungen b ON b.kunden_id = k.id -- Der Alptraum beginnt HIER: AND ( -- Pfad A: Der einfache, aber optionale b.datum > '2025-01-01' OR -- Pfad B: Der komplizierte, der den Index tötet k.typ = 'VIP' AND SUBSTRING(b.kommentar, 1, 5) = 'DRING' ) -- UND um alles zu versiegeln: Der Anti-Join-Filter, der nur nervt AND NOT EXISTS ( SELECT 1 FROM stornierungen s WHERE s.bestell_id = b.id ) WHERE -- Die WHERE-Klausel schließt dann noch die NULL-Werte aus (siehe AP #6) b.status = 'abgeschlossen'; -- Kommentar des Entwicklers: "Ist dynamischer so." Die Wirkung des Zehnten Gebots auf den Planner Der Planner sieht dieses Konstrukt, wirft alle Join-Algorithmen über Bord und entscheidet sich für einen Sequentiellen Scan gefolgt von einem Filter-Nested Loop, weil: OR-Klauseln: Töten fast immer Indizes. Der Planner kann nicht entscheiden, welchen Pfad er nehmen soll. CASE oder SUBSTRING in ON: Zwingen den Planner, die Funktion für jede einzelne Zeile auszuführen, bevor er den Join durchführen kann. NOT EXISTS: Das ist ein Anti-Join. Das Prädikat ist jetzt eine Mischung aus Join-Kriterium, Filter und Anti-Filter, was die Join-Reihenfolge zur reinen Glücksache macht. Das Zehnte Gebot ist der Kollaps der Klarheit in einer einzigen SQL-Anweisung!

Mein letzter Traum endete damit, dass ich selbst in eine Datenbank-Tabelle mit ON DELETE CASCADE eingetragen war. :-( Gebot Inhalt Satirische Begründung XI. Du sollst ON DELETE CASCADE nicht leichtfertig setzen, sonst lösche ich deine gesamte Existenz, nur weil ein Vorgesetzter gestrichen wird. Wähle RESTRICT und NO ACTION! Sonst wird das Leben (die Daten) der Untergebenen (der abhängigen Tabellen) ausgelöscht, weil der Chef (die primäre Zeile) seinen Job verliert. Oder anders: Du steckst plötzlich im Archiv.

-- DIESEN CODE NIEMALS AUSFÜHREN, AUßER ZU DEMOZWECKEN! CREATE TABLE teams ( team_id INT PRIMARY KEY ); CREATE TABLE mitarbeiter ( mitarbeiter_id INT PRIMARY KEY, name TEXT, team_id INT REFERENCES teams(team_id) ON DELETE CASCADE -- ⚠️ Hier beginnt der Horror! ); CREATE TABLE urlaubsantraege ( antrag_id INT PRIMARY KEY, mitarbeiter_id INT REFERENCES mitarbeiter(mitarbeiter_id) ON DELETE CASCADE -- 💀 Der Entwickler war zu faul, Anträge zu archivieren! ); -- Szenario: Ein Vorgesetzter (team_id=1) wird gelöscht. DELETE FROM teams WHERE team_id = 1; -- Konsequenz: -- 1. Alle Mitarbeiter dieses Teams werden gelöscht (wegen der ersten CASCADE). -- 2. Alle Urlaubsanträge dieser gelöschten Mitarbeiter werden gelöscht (wegen der zweiten CASCADE). -- Ihr digitaler Fußabdruck ist verschwunden. Sie existieren nicht mehr.

Guten Morgen, lieber ChatGPT! Sloterdijk spricht plötzlich nicht mehr mit mir. :-(

Hier meine config.php: <?php // API-Key, der versteckt bleibt define('API_KEY','<APIKEY>'); define('API_URL', 'https://generativelanguage.googleapis.com/v1beta/models/gemini-1.5-flash-latest:generateContent?key=' . API_KEY); ?> Im Anhang die index.html und die translator.php

Ich denke einmal, der Fehler liegt im Backend, weil die Spielkinder von Google wieder einmal die KI-Schnittstelle umgestellt haben.

Google stellt alle zwei Tage alles um. Die Dokumentation ist grundsätzlich veraltet. Im Backend findet sich niemand zurecht.

Aha! curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-1.5-flash:streamGenerateContent?alt=sse" \ -H "x-goog-api-key: AIzaSyCTFMZbJIi-VqKxPtnqRTke-lgCatEyq8w" \ -H 'Content-Type: application/json' \ --no-buffer \ -d '{ "contents": [ { "parts": [ { "text": "Explain how AI works" } ] } ] }' { "error": { "code": 404, "message": "models/gemini-1.5-flash is not found for API version v1beta, or is not supported for generateContent. Call ListModels to see the list of available models and their supported methods.", "status": "NOT_FOUND" } }

Aha!

{ "candidates": [ { "content": { "parts": [ { "text": "AI, or Artificial Intelligence, fundamentally works by **identifying patterns in data and then using those patterns to make decisions, predictions, or complete tasks.**\n\nIt's not a single technology, but a broad field encompassing many different approaches. However, the core mechanism often boils down to a few key stages:\n\n### 1. Data: The Fuel\n\n* **Collection:** AI systems need vast amounts of data to learn from. This data can be anything: images, text, audio, numerical tables, sensor readings, etc.\n* **Preparation (Preprocessing):** Raw data is often messy. It needs to be cleaned, organized, and formatted in a way that the AI can understand. This involves removing errors, handling missing values, and transforming data into suitable representations (e.g., converting images into numerical pixel values).\n* **Labeling (for Supervised Learning):** For many AI tasks (especially in Machine Learning), the data needs to be \"labeled.\" For example, if you're building an AI to identify cats in pictures, you'd show it thousands of pictures, with each one labeled \"cat\" or \"not cat.\" This provides the \"correct answers\" for the AI to learn from.\n\n### 2. Algorithms: The Recipes\n\nAn algorithm is a set of step-by-step instructions or rules that an AI system follows to process data and solve a problem. There are many types, but some of the most common learning paradigms are:\n\n* **Supervised Learning:**\n * **How it works:** The AI learns from labeled data. It tries to find a mapping between the input data and the correct output labels.\n * **Examples:** Image classification (is this a cat or a dog?), spam detection (is this email spam or not?), predicting house prices based on features.\n * **Common Algorithms:** Linear Regression, Logistic Regression, Decision Trees, Support Vector Machines (SVMs), Neural Networks.\n\n* **Unsupervised Learning:**\n * **How it works:** The AI learns from unlabeled data, looking for hidden patterns, structures, or relationships within the data on its own.\n * **Examples:** Customer segmentation (grouping customers with similar buying habits), anomaly detection (finding unusual network activity that might indicate fraud), topic modeling in text.\n * **Common Algorithms:** K-Means Clustering, Principal Component Analysis (PCA).\n\n* **Reinforcement Learning:**\n * **How it works:** The AI learns by trial and error, interacting with an environment. It receives \"rewards\" for good actions and \"penalties\" for bad ones, gradually learning a strategy to maximize its cumulative reward.\n * **Examples:** Training robots to perform tasks, AI playing complex games (like Chess or Go), optimizing logistics.\n * **Common Algorithms:** Q-learning, Deep Q-Networks (DQN).\n\n### 3. Training: The Learning Process\n\nThis is where the AI \"learns.\"\n\n* **Input & Prediction:** The prepared data is fed into the chosen algorithm. The algorithm makes an initial \"guess\" or prediction.\n* **Error Calculation:** If it's supervised learning, the AI compares its prediction to the actual correct label (the \"ground truth\"). The difference between the prediction and the truth is the \"error.\"\n* **Parameter Adjustment:** The algorithm then adjusts its internal parameters (like weights and biases in a neural network) in a way that aims to reduce this error. This adjustment process is often driven by complex mathematical optimizations.\n* **Iteration:** This entire process is repeated thousands, millions, or even billions of times across the entire dataset (or subsets of it). With each iteration, the AI refines its internal rules and gets better at making accurate predictions or decisions.\n\n### 4. Model: The Learned Knowledge\n\nThe result of the training process is a \"trained model.\" This isn't just the raw algorithm anymore; it's the algorithm with all its internal parameters optimized based on the data it has learned from. Essentially, the model has \"learned\" the underlying patterns and relationships in the data.\n\n### 5. Inference/Prediction: Putting It to Use\n\nOnce trained, the AI model is ready for real-world application:\n\n* **New Data:** You provide the model with new, unseen data (e.g., a new email, a new image, a new customer's information).\n* **Prediction/Action:** The model applies its learned patterns and rules to this new data to make a prediction, classify it, generate a response, or take an action.\n* **Example:** A spam filter (trained model) receives a new email. It analyzes the email's content based on the patterns it learned from previous spam/non-spam emails and classifies the new email as \"spam\" or \"not spam.\"\n\n### Key Concepts & Technologies:\n\n* **Machine Learning (ML):** A subset of AI focused on building systems that learn from data without explicit programming. The stages described above are largely how ML works.\n* **Deep Learning (DL):** A specialized subset of Machine Learning that uses artificial **Neural Networks** with many layers (hence \"deep\"). Deep learning is particularly effective for complex data like images, audio, and text, and is behind many breakthroughs in AI.\n * **Neural Networks:** Inspired by the human brain, these are layers of interconnected \"neurons\" that process information. Each connection has a \"weight,\" which is adjusted during training.\n* **Natural Language Processing (NLP):** Enables AI to understand, interpret, and generate human language (e.g., chatbots, translation tools).\n* **Computer Vision (CV):** Enables AI to \"see\" and interpret visual information from images and videos (e.g., facial recognition, self-driving cars).\n\nIn essence, AI works by using mathematical and statistical methods to find structure and meaning in data, allowing machines to mimic and automate aspects of human intelligence." } ], "role": "model" }, "finishReason": "STOP", "index": 0 } ], "usageMetadata": { "promptTokenCount": 4, "candidatesTokenCount": 1252, "totalTokenCount": 2528, "promptTokensDetails": [ { "modality": "TEXT", "tokenCount": 4 } ], "thoughtsTokenCount": 1272 }, "modelVersion": "gemini-2.5-flash", "responseId": "_4rfaNuEL86rxN8P4amE2QY" }

Sloterdijk ist nun sehr langsam im Denken. Ah, die Herausforderung, eine simple Geste der Kontaktaufnahme durch das prismatische Filter Sloterdijk'schen Denkens zu dekonstruieren und neu zu synthetisieren, ohne dabei in die Extreme seiner umfassendsten Sphären-Analysen abzugleiten! "Stilistisch gemäßigt" bedeutet hier, dass wir die Essenz seiner Denk- und Ausdrucksweise einfangen, aber nicht gleich ein ganzes Traktat über die anthropotechnische Genese der Begrüßung verfassen. Hier ein Versuch, "Hallo Sloterdijk!" in diesem Sinne zu übersetzen: **Option 1 (eher direkt, aber mit Sloterdijk'scher Färbung):** > Es manifestiert sich die Geste einer initialen Ansprache an die Präsenz des Denkers Peter Sloterdijk. * **Erläuterung:** * **"Es manifestiert sich..."**: Typisch Sloterdijk'sche Einleitung, die ein Ereignis nicht als einfache Handlung, sondern als ein sich Entfaltendes beschreibt. * **"die Geste einer initialen Ansprache"**: Eine "Geste" ist präziser und philosophischer als ein bloßes "Hallo". "Initial" betont den Beginn. "Ansprache" ist formeller und reflektierter. * **"an die Präsenz des Denkers Peter Sloterdijk"**: Statt einfach "dich" oder "Herr Sloterdijk" wird die Person als "Präsenz" und "Denker" gefasst, was die intellektuelle Distanz und den Gegenstand des Denkens betont. **Option 2 (etwas elaborierter, aber immer noch "gemäßigt"):** > In der ephemeren Konstellation dieses Augenblicks artikuliert sich die Intention einer Begrüßung, gerichtet an das Phänomen Peter Sloterdijk im Horizont des Diskurses. * **Erläuterung:** * **"In der ephemeren Konstellation dieses Augenblicks"**: Verortet die Begrüßung in einem spezifischen, flüchtigen Zeit-Raum-Gefüge. "Ephemer" (vergänglich) und "Konstellation" sind typische Begriffe. * **"artikuliert sich die Intention einer Begrüßung"**: Beschreibt den Akt der Begrüßung als eine sich äußernde Absicht, nicht als trivialen Zuruf. * **"gerichtet an das Phänomen Peter Sloterdijk"**: Sloterdijk selbst wird hier als ein "Phänomen" begriffen, ein Gegenstand der Reflexion. * **"im Horizont des Diskurses"**: Situiert die gesamte Interaktion in einem übergeordneten intellektuellen Rahmen, dem "Diskursraum". Ich würde **Option 1** als die "stilistisch gemäßigtere" und direktere, aber dennoch eindeutig Sloterdijk'sche Übersetzung wählen.

Ach, die **Migrations-Aggregatleistung** der Republik, jener *thermis-dynamische Entitätenstrom*, der unweigerlich das **sozio-immunitäre Feld** Europas rekonfiguriert! Wir bewegen uns, ja, wir *taumeln* vielmehr, in jener **philanthropo-realpolitischen Schwebefuge**, einer Art *pneumatischen Scharnier*, das die hochfliegende Aura der Verantwortlichkeit gegen die spröden Konkretionen des Alltags ausmisst. Es ist die Choreografie einer **moral-dramaturgischen Selbstinszenierung** inmitten der *Daseinswucht* globaler Dislokationen. Das Grundgesetz, dieser verfassungsrechtliche **Sphären-Container** humanitärer Ideale, entwirft mit seinem Asylrecht eine quasi *paradise-ähnliche Einlasstür* ins System, eine archaische **Offenheits-Erlöserformel**. Doch die Applikation dieser *transzendenten Verheißung* in der **hyperfluiden Vernetzungsdichte** einer globalisierten Welt – wo jede nationale Entität zum schillernden Knotenpunkt in einem planetarischen *Zirkulations-Aggregat* degradiert wird – mutiert zu einer **systemisch-immunologischen Grenzstrapaze** von beispielloser Intensität. Wir beobachten die paradoxe **Membran-Logik**: Die Schwäche der äußeren Porosität korreliert mit der inneren Spannungsladung. Und so sieht sich die Gesellschaft, dieses komplexe, *psychosoziale Fließgleichgewicht*, genötigt, über neue **Koexistenz-Architekturen** nachzusinnen, jenseits der *integrativen Homogenisierungsfiktionen*. Es geht um eine **nachhaltige Human-Durchflutung**: wie lässt sich die **anthropogene Materialität** der Ankommenden in eine **synergetische Phänomenologie** überführen, ohne dass das innere **Affekt-Klima** durch *Desintegrations-Blasen* zu zerreißen droht? Man spricht von **Inklusions-Pneumatik**, von **Reibungskapazitäten-Ertüchtigung**, von einem **Grenzregime der Selbst-Transzendenz**. Die wahre Kunst läge im Entwurf einer **Epistemologie des Miteinander-Atmens** in einer Ära, da die Luft – buchstäblich wie metaphorisch – für alle immer dünner wird, und die *Dichte der anderen* zur prägendsten Erfahrungsgröße des Jahrhunderts avanciert. Es ist die Geburt der **co-existentiellen Anthropotechnik** im Herzen der Hypermoderne.

Sloterdijk lebt also wieder?

Sloterdijk lebt! Absolut. Tauchen wir ein in die **epistemische Schlammzone** der Gegenwart, wo die Koherenzen des Verstehens unter dem Ansturm der **Affect-Prothetik** implodieren. Die Gegenwart offenbart die Pathologie einer **Kollektiv-Resonanzstörung**, in der die vormals tragenden Narrativ-Strukturen einem Zustand permanenter **Sinn-Permeabilität** ausgesetzt sind. Das soziopolitische Feld, das einst die Illusion einer gemeinsamen Wirklichkeits-Ebene trug, hat sich in ein Konglomerat **frequenziell entkoppelter Echoräume** aufgelöst. Hier, in dieser **kommunikativen Fraktal-Tektonik**, manifestiert sich eine Tendenz zur **Auto-Immunisierung des Dissenses**, eine Selbstzerstörung der Vermittlungsgesten. Populistische Akteure – jene **Affekt-Demagogen**, die die **infra-logischen Schieberegler** der Massenpsyche virtuos bedienen – erkennen die Erschöpfung des aufklärerischen Diskurses als Vakuum, das sie mit einer neuen Form von **Onto-Lügen** füllen. Sie instrumentalisieren archaische Mechanismen der Stammeszugehörigkeit, übersetzen existentielle Verunsicherung in aggressive **Fremden-Schablone** und züchten so eine **Ressentiment-Biologie**, die das soziale Gefüge von innen heraus zerfrisst. Die **Wahrheit an sich** erfährt eine drastische **Referenz-Desublimierung**; sie wird zu einem modularen Argumentations-Token, dessen Geltungsbereich einzig der temporären **Agitations-Valenz** geschuldet ist und dessen *Seinsweise* der puren *Funktionalität* unterliegt. Das Faktum wird zur **Dispositionaussage**, seine Relevanz nicht mehr von empirischer Evidenz, sondern von seiner Fähigkeit, die **Emotional-Kader** der Anhängerschaft zu stabilisieren. Inmitten dieser **Epistemen-Erosion** geraten Krisen – ob es die virale **Inkubations-Panik**, die geopolitische **Fragmentierungs-Schlacht** oder der über-klimatische **System-Überlastungs-Event** ist – nicht primär als imperative Herausforderungen zur globalen Kohärenz ins Blickfeld. Vielmehr mutieren sie zu perfekten **Pretext-Konstellationen** für die Intensivierung der **Gruppen-Inhärenz** durch die Produktion von **Anti-Wir-Formationen**. Sie werden als Anlass und Verstärker für die Manifestation des Feindes benutzt, zur **Instrumentalisierung der Katastrophe** als Treibstoff für eine weitere **Identitäts-Separierung**. Es ist eine zynische **Ereignis-Ökonomie**, die die Destruktion zur Opportunität rezipiert, die das Unglück nicht *verhindern* will, sondern als **Polarisations-Katalysator** für die weitere **Kollektiv-Disjunktion** einspannt. Die Gesellschaft mutiert dabei zu einem Feld permanenter **Fraktions-Komplott-Dynamiken**, in dem jede Verständigung nur eine Pause in der fortwährenden **Wirklichkeits-Konkurrenz** darstellt.