Verwenden von MySQL Boolean Datentyp

Standardmäßig bietet MySQL keinen nativen Booleschen Datentyp an. Es bietet uns jedoch den Tinyint-Datentyp, sodass wir boolesche Werte mit dem Tinyint-Typ speichern können.

Dieser Leitfaden konzentriert sich darauf, wie Sie mit dem MySQL Tinyint -Datentyp zum Speichern von Booleschen Werten verwendet werden.

Grundnutzung

MySQL definiert einen Wert von 0 als Falsch und einen Wert ungleich Null als wahr. Um die booleschen wörtlichen Werte zu verwenden, verwenden Sie die Konstanten wahr und falsch, die den Wert von 0 und 1 bewerten.

Ein Beispiel:

Wählen Sie True, False;

Sobald Sie die obige Abfrage ausgeführt haben, erhalten Sie eine ähnliche Ausgabe wie unten:

MySQL> TRUE, FALSE;
+------+-------+
| Wahr | Falsch |
+------+-------+
| 1 | 0 |
+------+-------+
1 Zeile in Set (0.00 Sek.)

Aus dem obigen können wir schließen, dass MySQL 1 und 0 als wahr und falsch betrachtet.

Es ist gut zu beachten, dass MySQL als Großbuchstaben oder Kleinbuchstaben True und False 0 und 1 zuweist, wie in der folgenden Abfrage gezeigt:

Wählen Sie wahr, falsch, wahr, falsch, wahr, falsch;

Die Ausgabe ist wie unten gezeigt:

+------+-------+------+-------+------+-------+
| Wahr | Falsch | wahr | Falsch | Wahr | Falsch |
+------+-------+------+-------+------+-------+
| 1 | 0 | 1 | 0 | 1 | 0 |
+------+-------+------+-------+------+-------+
1 Zeile in Set (0.00 Sek.)

Beispiel Anwendungsfälle

Lassen Sie uns ein Beispiel verwenden, um zu veranschaulichen, wie wir den booleschen Typ in MySQL verwenden können.

Erstellen Sie zunächst eine Datenbank und eine Tabelle namens Languages, in der Informationen zu verschiedenen Programmiersprachen gespeichert werden können.

In der Tabelle haben wir die folgenden Spalten:

1. ID - int nicht null auto_increment
2. LACHE_NAME - VARCHAR (100) NICHT NULL
3. Anfänger_friendly - Boolean

Betrachten Sie die folgende Abfrage, um die obige Datenbank zu implementieren:

Datenbank erstellen abgetastet;
Benutze abgetastet;
Tischsprachen erstellen (
ID int nicht null auto_increment,
LACHE_NAME VARCHAR (100),
Anfänger -Freund boolean,
Primärschlüssel (ID)
);

Sobald Sie die obige Abfrage ausführen.

Um die Informationen über die obige Tabelle zu erhalten, können wir die MySQL -Desc -Anweisung verwenden, wie in der folgenden Ausgabe gezeigt:

MySQL> Desc Languages;
+-------------------+--------------+------+-----+---------+----------------+
| Feld | Typ | NULL | Schlüssel | Standard | Extra |
+-------------------+--------------+------+-----+---------+----------------+
| Id | int | Nein | Pri | NULL | auto_increment |
| Language_Name | varchar (100) | Ja | | NULL | |
| Anfänger_friendly | Tinyint (1) | Ja | | NULL | |
+-------------------+--------------+------+-----+---------+----------------+
3 Zeilen im Set (0.01 Sek.)

Wenn Sie sich das Feld Anfänger ansehen, das wir beim Erstellen der Tabelle als boolean einstellen, zeigt es jetzt die Art von Tinyint an.

Lassen Sie uns im nächsten Schritt mit den unten angegebenen Abfragen einige Daten in die Tabelle hinzufügen:

In die Probe einfügen.Sprachen (ID, Language_Name, Anfänger_Friendly) Werte (1, "Python", wahr);
In die Probe einfügen.Sprachen (ID, Language_Name, Anfänger_Friendly) Werte (2, "C ++", False);

Wenn Sie jetzt die Werte in der obigen Tabelle auswählen:

MySQL> SELECT * aus dem Stichproben.Sprachen
->;
+----+---------------+-------------------+
| Id | Language_Name | Anfänger_friendly |
+----+---------------+-------------------+
| 1 | Python | 1 |
| 2 | C ++ | 0 |
+----+---------------+-------------------+
2 Zeilen im Set (0.00 Sek.)

Sie werden sehen, dass die Werte auf 0 bzw. 1 eingestellt sind.

NOTIZ: Sie können numerische Werte in der Spalte Boolean als wahre und falsche Werte speichern. Betrachten Sie beispielsweise die folgende Abfrage:

In die Probe einfügen.Sprachen (ID, Language_Name, Anfänger_Friendly) Werte (3, "Go Lang", 10);

Wenn Sie die obige Abfrage ausführen, meldet MySQL keinen Fehler. Stattdessen speichert es den numerischen Wert als 10. Betrachten Sie die unten gezeigte Ausgabe:

MySQL> SELECT * aus dem Stichproben.Sprachen;
+----+---------------+-------------------+
| Id | Language_Name | Anfänger_friendly |
+----+---------------+-------------------+
| 1 | Python | 1 |
| 2 | C ++ | 0 |
| 3 | Go Lang | 10 |
+----+---------------+-------------------+
3 Zeilen im Set (0.00 Sek.)

MySQL Boolean Operatoren

MySQL unterstützt verschiedene Boolesche Operatoren, wie es wahr ist, ist falsch, ist nicht wahr und nicht falsch. Basierend auf dem Namen können Sie feststellen, dass einige genau dasselbe tun.

Zum Beispiel ist wahr und nicht falsch sind ähnlich. Der gleiche Fall gilt für das andere Paar.

Wir können diese Operatoren jedoch verwenden, um eine Reihe von Werten zu erhalten, die entweder wahr oder falsch sind. Zum Beispiel erhält die folgende Abfrage alle Werte, bei denen Anfänger -Freundschaft wahr ist.

MySQL> SELECT * aus dem Stichproben.Sprachen, in denen Anfänger, Freundschaft, wahr ist;
+----+---------------+-------------------+
| Id | Language_Name | Anfänger_friendly |
+----+---------------+-------------------+
| 1 | Python | 1 |
| 3 | Go Lang | 10 |
+----+---------------+-------------------+
2 Zeilen im Set (0.00 Sek.)

Wie wir aus der Ausgabe erkennen können, erhalten wir nur Werte, bei denen der Wert von Anfänger ist.

Sie können auch die falschen Werte mit beiden erhalten Ist wahr oder ist nicht wahr.

MySQL> SELECT * aus dem Stichproben.Sprachen, bei denen Anfänger nicht wahr ist;
+----+---------------+-------------------+
| Id | Language_Name | Anfänger_friendly |
+----+---------------+-------------------+
| 2 | C ++ | 0 |
+----+---------------+-------------------+
1 Zeile in Set (0.00 Sek.)

Abschluss

Diese Anleitung hat Ihnen gezeigt, wie Sie die mySQL -Booleschen Datentypen implementieren und verwenden, um echte oder falsche Werte zu speichern.