Utilizzo del tipo di dati booleani MySQL

Per impostazione predefinita, MySQL non offre un tipo di dati booleani nativi. Tuttavia, ci fornisce il tipo di dati TinyInt, permettendoci di archiviare valori booleani simili a valori con il tipo tinyint.

Questa guida si concentrerà su come utilizzare il tipo di dati MySQL TinyInt per archiviare i valori booleani.

Uso di base

MySQL definisce un valore di 0 come valore falso e diverso da zero come vero. Pertanto, per utilizzare i valori letterali booleani, si utilizzano le costanti vere e false che valutano il valore di 0 e 1.

Un esempio:

Seleziona True, False;

Una volta eseguita la query sopra, otterrai un output simile a quello mostrato di seguito:

mysql> seleziona true, false;
+------+-------+
| Vero | Falso |
+------+-------+
| 1 | 0 |
+------+-------+
1 riga in set (0.00 sec)

Da quanto sopra, possiamo dedurre che MySQL considera 1 e 0 come vero e falso, rispettivamente.

È bene notare che come maiuscolo o minuscolo, MySQL assegna vero e falso 0 e 1 come mostrato nella query seguente:

Seleziona vero, falso, vero, falso, vero, falso;

L'output è come mostrato di seguito:

+------+-------+------+-------+------+-------+
| Vero | Falso | vero | Falso | Vero | Falso |
+------+-------+------+-------+------+-------+
| 1 | 0 | 1 | 0 | 1 | 0 |
+------+-------+------+-------+------+-------+
1 riga in set (0.00 sec)

Esempio di casi d'uso

Usiamo un esempio per illustrare come possiamo usare il tipo booleano in mysql.

Inizia creando un database e una tabella chiamata Lingue, che memorizzerà le informazioni su vari linguaggi di programmazione.

All'interno della tabella, abbiamo le seguenti colonne:

1. ID - int non null auto_increment
2. Lingua_name - varchar (100) non null
3. Principiante_friendly - booleano

Considera la query di seguito per implementare il database sopra:

Creare il database campionato;
Utilizzare campionato;
Crea lingue da tavolo (
Id int non null auto_increment,
Lingua_name varchar (100),
Principiante_friendly booleano,
Chiave primaria (ID)
);

Una volta eseguita la query sopra, avrai il database campionato con la tabella delle lingue.

Per ottenere le informazioni sulla tabella sopra, possiamo usare l'istruzione Desc MySQL come mostrato nell'output di seguito:

Mysql> Desc Languages;
+-------------------+--------------+------+-----+---------+----------------+
| Campo | Tipo | Null | Chiave | Predefinito | Extra |
+-------------------+--------------+------+-----+---------+----------------+
| Id | int | No | Pri | Null | Auto_Increment |
| Lingua_name | Varchar (100) | Sì | | Null | |
| Principiante_friendly | tinyint (1) | Sì | | Null | |
+-------------------+--------------+------+-----+---------+----------------+
3 righe in set (0.01 sec)

Se guardi il campo per principianti, che impostiamo come booleano quando creiamo il tavolo, ora mostra il tipo di tinyint.

Nel passaggio successivo, aggiungiamo alcuni dati alla tabella utilizzando le query fornite di seguito:

Inserire nel campionato.Lingue (id, lingua_name, principiante_friendly) valori (1, "python", true);
Inserire nel campionato.Lingue (id, lingua_name, principiante_friendly) valori (2, "c ++", false);

Se ora selezioni i valori nella tabella sopra:

mysql> seleziona * da campionato.le lingue
->;
+----+---------------+-------------------+
| Id | Lingua_name | Principiante_friendly |
+----+---------------+-------------------+
| 1 | Python | 1 |
| 2 | C ++ | 0 |
+----+---------------+-------------------+
2 righe in set (0.00 sec)

Vedrai che i valori sono impostati su 0 e 1, rispettivamente.

NOTA: Puoi archiviare valori numerici nella colonna booleana diversi dai valori True e False. Ad esempio, considera la query di seguito:

Inserire nel campionato.Lingue (id, lingua_name, principiante_friendly) valori (3, "go lang", 10);

Se esegui la query sopra, MySQL non segnalerà un errore. Invece, memorizzerà il valore numerico come 10. Considera l'uscita mostrata di seguito:

mysql> seleziona * da campionato.le lingue;
+----+---------------+-------------------+
| Id | Lingua_name | Principiante_friendly |
+----+---------------+-------------------+
| 1 | Python | 1 |
| 2 | C ++ | 0 |
| 3 | Vai lang | 10 |
+----+---------------+-------------------+
3 righe in set (0.00 sec)

Operatori booleani MySQL

MySQL supporta vari operatori booleani come è vero, è falso, non è vero e non è falso. In base al nome, puoi determinare che alcuni fanno esattamente la stessa cosa.

Ad esempio, è vero e non è falso è simile. Lo stesso caso si applica all'altra coppia.

Tuttavia, possiamo usare questi operatori per ottenere un insieme di valori che sia vero o falso. Ad esempio, la query seguente ottiene tutti i valori in cui principiante è vero.

mysql> seleziona * da campionato.Lingue dove principiante è vero;
+----+---------------+-------------------+
| Id | Lingua_name | Principiante_friendly |
+----+---------------+-------------------+
| 1 | Python | 1 |
| 3 | Vai lang | 10 |
+----+---------------+-------------------+
2 righe in set (0.00 sec)

Come possiamo vedere dall'output, otteniamo solo valori in cui il valore di Beginner_friendly è vero.

Puoi anche ottenere i valori falsi usando entrambi È vero o non è vero.

mysql> seleziona * da campionato.Lingue in cui principiante non è vero;
+----+---------------+-------------------+
| Id | Lingua_name | Principiante_friendly |
+----+---------------+-------------------+
| 2 | C ++ | 0 |
+----+---------------+-------------------+
1 riga in set (0.00 sec)

Conclusione

Questa guida ti ha mostrato come implementare e utilizzare i tipi di dati booleani MySQL per archiviare valori veri o falsi.