MySQL - Boolean-Datentyp: Ein Anfängerleitfaden

Hallo da draußen, zukünftige Datenbank-Zauberer! Heute tauchen wir ein in die faszinierende Welt des MySQL-Boolean-Datentyps. Keine Sorge, wenn du noch nie eine Zeile Code geschrieben hast – ich werde dein freundlicher Guide auf dieser Reise sein, genau wie ich es für unzählige Schüler in meinen Jahren des Unterrichtens getan habe. Also, hol dir eine Tasse deines Lieblingsgetränks und lassen uns loslegen!

Was ist ein Boolean-Datentyp?

Bevor wir uns den spezifischen Details von MySQL zuwenden, lassen uns verstehen, was ein Boolean ist. Stell dir vor, du spielst ein einfaches Spiel von "ja" oder "nein" mit einem Freund. Das ist im Grunde genommen, was ein Boolean in der Programmierung ist – er kann nur zwei mögliche Werte haben: wahr oder falsch.

In realen Anwendungen sind Booleans unglaublich nützlich. Sie können darstellen:

• Ob ein Benutzer angemeldet ist oder nicht
• Ob ein Produkt auf Lager ist
• Ob ein Schüler eine Prüfung bestanden hat

Nun sehen wir, wie MySQL mit diesem Konzept umgeht.

Boolean in MySQL

Hier wird es ein bisschen eigenartig – MySQL hat keinen nativen BOOLEAN-Datentyp! Ich weiß, ich weiß, das klingt verwirrend. Aber keine Sorge, MySQL hat eine clevere Umgehungslösung.

In MySQL wird BOOLEAN actually als Synonym für TINYINT(1) behandelt. Das bedeutet, wenn du eine BOOLEAN-Spalte erstellst, erstellt MySQL heimlich eine TINYINT(1)-Spalte stattdessen.

Lassen wir das in die Tat umsetzen:

CREATE TABLE game_status (
id INT AUTO_INCREMENT PRIMARY KEY,
game_name VARCHAR(50),
is_completed BOOLEAN
);

INSERT INTO game_status (game_name, is_completed) VALUES
('Schach', TRUE),
('Monopoly', FALSE),
('Scrabble', TRUE);

SELECT * FROM game_status;

Wenn du diesen SELECT-Befehl ausführst, könntest du überrascht sein, zu sehen:

+----+-----------+--------------+
| id | game_name | is_completed |
+----+-----------+--------------+
|  1 | Schach    |            1 |
|  2 | Monopoly  |            0 |
|  3 | Scrabble  |            1 |
+----+-----------+--------------+

Warte einen Moment! Wo sind unsere TRUE und FALSE Werte? Na, erinnerst du dich daran, dass ich gesagt habe, BOOLEAN sei ein TINYINT(1)? Hier ist, was passiert:

• TRUE wird als 1 gespeichert
• FALSE wird als 0 gespeichert

Es ist, als ob MySQL im Hintergrund ein geheimes Spiel von "1 bedeutet ja, 0 bedeutet nein" spielt!

Ersetzen von BOOLEAN 0,1 mit TRUE und FALSE

Nun könntest du denken: "Aber ich möchte TRUE und FALSE in meinen Ergebnissen sehen!" Keine Sorge, MySQL hat dich abgedeckt. Wir können eine CASE-Anweisung verwenden, um diese heimlichen 0s und 1s zurück in TRUE und FALSE zu konvertieren:

SELECT
id,
game_name,
CASE
WHEN is_completed = 1 THEN 'TRUE'
ELSE 'FALSE'
END AS is_completed
FROM game_status;

Das gibt dir ein lesbarereres Ergebnis:

+----+-----------+--------------+
| id | game_name | is_completed |
+----+-----------+--------------+
|  1 | Schach    | TRUE         |
|  2 | Monopoly  | FALSE        |
|  3 | Scrabble  | TRUE         |
+----+-----------+--------------+

viel besser, oder? Es ist, als hätten wir MySQL einen kleinen Übersetzer gegeben, um unsere Sprache zu sprechen!

Boolean-Operatoren mit einem Client-Programm

Nun, da wir verstehen, wie MySQL Booleans behandelt, schauen wir uns einige Boolean-Operatoren an. Diese sind wie die Regeln unseres "ja/nein"-Spiels, die MySQL anweisen, wie Boolean-Werte kombiniert oder manipuliert werden sollen.

Hier sind die wichtigsten Boolean-Operatoren in MySQL:

Operator	Beschreibung
AND	Wahr, wenn beide wahr sind
OR	Wahr, wenn einer wahr ist
NOT	Kehrt den Boolean-Wert um
XOR	Wahr, wenn genau einer wahr ist

Lassen wir diese in Aktion sehen:

-- AND Operator
SELECT * FROM game_status WHERE is_completed = TRUE AND game_name = 'Schach';

-- OR Operator
SELECT * FROM game_status WHERE is_completed = TRUE OR game_name = 'Monopoly';

-- NOT Operator
SELECT * FROM game_status WHERE NOT is_completed;

-- XOR Operator
SELECT * FROM game_status WHERE is_completed XOR game_name = 'Monopoly';

Lassen wir das auseinandernehmen:

1. Die AND-Abfrage wird nur Zeilen zurückgeben, bei denen das Spiel abgeschlossen ist UND der Name des Spiels 'Schach' ist.
2. Die OR-Abfrage wird Zeilen zurückgeben, bei denen entweder das Spiel abgeschlossen ist ODER der Name des Spiels 'Monopoly' ist.
3. Die NOT-Abfrage wird Zeilen zurückgeben, bei denen das Spiel nicht abgeschlossen ist (das bedeutet, is_completed = 0).
4. Die XOR-Abfrage wird Zeilen zurückgeben, bei denen entweder das Spiel abgeschlossen ist ODER der Name des Spiels 'Monopoly' ist, aber nicht beide.

Diese Operatoren sind wie die Bausteine für komplexere Abfragen. Sie ermöglichen es uns, sehr spezifische Fragen an unsere Daten zu stellen, genau wie ein Detektiv, der Hinweise zusammenfügt!

Fazit

Und da hast du es, meine Freunde! Wir sind durch das Land der MySQL-Booleans gereist, von ihrer eigenartigen Implementierung als TINYINT(1) bis hin zu den mächtigen Operatoren, die uns helfen, unsere Daten abzufragen.

Denke daran, in der Welt der Datenbanken ist alles entweder eine 1 oder eine 0, ein WAHR oder ein FALSCH. Es ist, als ob die Datenbank ständig ein großes Spiel von "ja/nein" mit unseren Daten spielt. Und jetzt hast du die Werkzeuge, um an diesem Spiel teilzunehmen!

Wenn du deine MySQL-Abenteuer fortsetzt, wirst du feststellen, dass diese Boolean-Konzepte überall auftauchen. Sie sind das Geheimrezept, das uns hilft, Daten zu filtern, Entscheidungen in unserem Code zu treffen und letztendlich mächtige und dynamische Anwendungen zu erstellen.

Also, auf in die Zukunft, meine Schüler, und mögen deine Abfragen stets WAHR zurückkehren (wenn du nicht willst, dass sie FALSCH zurückkehren, natürlich)!

Credits: Image by storyset