Utilisation du type de données booléen MySQL

Par défaut, MySQL n'offre pas de type de données booléen natif. Cependant, il nous fournit le type de données Tinyint, nous permettant de stocker des valeurs booléennes comme le type Tinyint.

Ce guide se concentrera sur la façon d'utiliser le type de données MySQL Tinyint pour stocker les valeurs booléennes.

Utilisation de base

MySQL définit une valeur de 0 comme fausse et une valeur non nulle comme vraie. Par conséquent, pour utiliser des valeurs littérales booléennes, vous utilisez les constantes vraies et fausses qui évaluent la valeur de 0 et 1.

Un exemple:

Sélectionnez True, False;

Une fois que vous avez exécuté la requête ci-dessus, vous obtiendrez une sortie similaire à celle ci-dessous:

mysql> SELECT true, false;
+------+-------+
| Vrai | Faux |
+------+-------+
| 1 | 0 |
+------+-------+
1 ligne en jeu (0.00 sec)

À partir de ce qui précède, nous pouvons déduire que MySQL considère 1 et 0 comme vrai et faux, respectivement.

Il est bon de noter que comme majuscules ou minuscules, MySQL affecte True et False 0 et 1 comme indiqué dans la requête ci-dessous:

Sélectionnez true, false, true, false, true, false;

La sortie est comme indiqué ci-dessous:

+------+-------+------+-------+------+-------+
| Vrai | Faux | Vrai | Faux | Vrai | Faux |
+------+-------+------+-------+------+-------+
| 1 | 0 | 1 | 0 | 1 | 0 |
+------+-------+------+-------+------+-------+
1 ligne en jeu (0.00 sec)

Exemple de cas d'utilisation

Laissez-nous utiliser un exemple pour illustrer comment nous pouvons utiliser le type booléen dans MySQL.

Commencez par créer une base de données et une table appelée Langues, qui stockera des informations sur divers langages de programmation.

À l'intérieur de la table, nous avons les colonnes suivantes:

1. Id - int not null auto_increment
2. Langue_name - Varchar (100) pas null
3. Débutant_friendly - booléen

Considérez la requête ci-dessous pour implémenter la base de données ci-dessus:

Créer la base de données échantillonnée;
Utiliser échantillonné;
Créer des langues de table (
Id int not null auto_increment,
Language_name Varchar (100),
Débutant_friendly booléen,
Clé primaire (ID)
));

Une fois que vous avez exécuté la requête ci-dessus, vous aurez la base de données échantillonnée avec le tableau des langues.

Pour obtenir les informations sur le tableau ci-dessus, nous pouvons utiliser l'instruction MySQL DESC comme indiqué dans la sortie ci-dessous:

MySQL> DESC Langues;
+-------------------+--------------+------+-----+---------+----------------+
| Champ | Type | NULL | Clé | Par défaut | Extra |
+-------------------+--------------+------+-----+---------+----------------+
| ID | int | Non | Pri | NULL | auto_increment |
| Langue_name | varchar (100) | Oui | | NULL | |
| Débutant_friendly | Tinyint (1) | Oui | | NULL | |
+-------------------+--------------+------+-----+---------+----------------+
3 lignes en jeu (0.01 SEC)

Si vous regardez le champ Beginner_friendly, que nous avons défini comme booléen lors de la création de la table, il montre maintenant le type de minuscule.

À l'étape suivante, ajoutons des données au tableau à l'aide des requêtes ci-dessous:

Insérer dans l'échantillon.Langues (ID, Language_name, Beginner_Friendly) VALEURS (1, "Python", true);
Insérer dans l'échantillon.Langues (ID, Language_name, Beginner_Friendly) VALEURS (2, "C ++", FALSE);

Si vous sélectionnez maintenant les valeurs dans le tableau ci-dessus:

mysql> sélectionner * à partir d'échantillonnage.langues
->;
+----+---------------+-------------------+
| ID | Langue_name | Débutant_friendly |
+----+---------------+-------------------+
| 1 | Python | 1 |
| 2 | C ++ | 0 |
+----+---------------+-------------------+
2 lignes en jeu (0.00 sec)

Vous verrez que les valeurs sont définies respectivement sur 0 et 1.

NOTE: Vous pouvez stocker des valeurs numériques dans la colonne booléenne autre que les valeurs vraies et fausses. Par exemple, considérez la requête ci-dessous:

Insérer dans l'échantillon.Langues (id, Language_Name, Beginner_Friendly) VALEURS (3, "Go Lang", 10);

Si vous exécutez la requête ci-dessus, MySQL ne rapportera pas d'erreur. Au lieu de cela, il stockera la valeur numérique comme 10. Considérez la sortie ci-dessous:

mysql> sélectionner * à partir d'échantillonnage.langues;
+----+---------------+-------------------+
| ID | Langue_name | Débutant_friendly |
+----+---------------+-------------------+
| 1 | Python | 1 |
| 2 | C ++ | 0 |
| 3 | Go Lang | 10 |
+----+---------------+-------------------+
3 lignes en jeu (0.00 sec)

Opérateurs booléens mysql

MySQL prend en charge divers opérateurs booléens comme c'est vrai, est faux, n'est pas vrai et n'est pas faux. Sur la base du nom, vous pouvez déterminer que certains font exactement la même chose.

Par exemple, est vrai et n'est pas faux est similaire. Le même cas s'applique à l'autre paire.

Cependant, nous pouvons utiliser ces opérateurs pour obtenir un ensemble de valeurs qui sont vraies ou fausses. Par exemple, la requête ci-dessous obtient toutes les valeurs où débutant_friendly est vraie.

mysql> sélectionner * à partir d'échantillonnage.langues où débutant_friendly est vrai;
+----+---------------+-------------------+
| ID | Langue_name | Débutant_friendly |
+----+---------------+-------------------+
| 1 | Python | 1 |
| 3 | Go Lang | 10 |
+----+---------------+-------------------+
2 lignes en jeu (0.00 sec)

Comme nous pouvons le voir sur la sortie, nous n'obtenons que des valeurs où la valeur de débutant_friendly est vraie.

Vous pouvez également obtenir les fausses valeurs en utilisant soit Est vrai ou n'est pas vrai.

mysql> sélectionner * à partir d'échantillonnage.langues où débutant_friendly n'est pas vrai;
+----+---------------+-------------------+
| ID | Langue_name | Débutant_friendly |
+----+---------------+-------------------+
| 2 | C ++ | 0 |
+----+---------------+-------------------+
1 ligne en jeu (0.00 sec)

Conclusion

Ce guide vous a montré comment implémenter et utiliser les types de données booléens MySQL pour stocker des valeurs vraies ou fausses.