Usando o tipo de dados booleano do MySQL

Por padrão, o MySQL não oferece um tipo de dados booleano nativo. No entanto, ele nos fornece o tipo de dados TinyInt, permitindo-nos armazenar valores booleanos com valores com o tipo Tinyint.

Este guia se concentrará em como usar o tipo de dados do MySQL Tinyint para armazenar valores booleanos.

Uso básico

MySQL define um valor de 0 como falso e um valor diferente de zero como verdadeiro. Portanto, para usar valores literais booleanos, você usa as constantes verdadeiras e falsas que avaliam o valor de 0 e 1.

Um exemplo:

selecione True, falso;

Depois de executar a consulta acima, você obterá uma saída semelhante à mostrada abaixo:

mysql> selecione True, falso;
+------+-------+
| Verdadeiro | Falso |
+------+-------+
| 1 | 0 |
+------+-------+
1 linha no conjunto (0.00 seg)

Do exposto, podemos deduzir que o MySQL considera 1 e 0 como verdadeiro e falso, respectivamente.

É bom observar que, como maiúsculas ou minúsculas, o MySQL atribui verdadeiro e falso 0 e 1, como mostrado na consulta abaixo:

Selecione verdadeiro, falso, verdadeiro, falso, verdadeiro, falso;

A saída é como mostrado abaixo:

+------+-------+------+-------+------+-------+
| Verdadeiro | Falso | verdadeiro | falso | Verdadeiro | Falso |
+------+-------+------+-------+------+-------+
| 1 | 0 | 1 | 0 | 1 | 0 |
+------+-------+------+-------+------+-------+
1 linha no conjunto (0.00 seg)

Exemplo de uso de casos

Vamos usar um exemplo para ilustrar como podemos usar o tipo booleano em mysql.

Comece criando um banco de dados e uma tabela chamada idiomas, que armazenará informações sobre várias linguagens de programação.

Dentro da mesa, temos as seguintes colunas:

1. Id - não não nulo auto_increment
2. Idioma_name - varchar (100) não nulo
3. Beginner_friendly - Booleano

Considere a consulta abaixo para implementar o banco de dados acima:

Criar banco de dados amostrado;
Use amostrado;
Crie idiomas de tabela (
Id int não nulo auto_incrent,
Idioma_name varchar (100),
Beginner_friendly boolean,
Chave primária (id)
);

Depois de executar a consulta acima, você terá o banco de dados amostrado com a tabela de idiomas.

Para obter as informações sobre a tabela acima, podemos usar a instrução MySQL DEC, como mostrado na saída abaixo:

MySql> Desc Languages;
+-------------------+--------------+------+-----+---------+----------------+
| Campo | Tipo | Nulo | Chave | Padrão | Extra |
+-------------------+--------------+------+-----+---------+----------------+
| Id | int | Não | PRI | Nulo | Auto_increment |
| Idioma_name | Varchar (100) | Sim | | Nulo | |
| Beginner_friendly | Tinyint (1) | Sim | | Nulo | |
+-------------------+--------------+------+-----+---------+----------------+
3 linhas no set (0.01 seg)

Se você olhar para o campo iniciante_friendly, que definimos como booleano ao criar a mesa, agora mostra o tipo de tinyint.

Na próxima etapa, vamos adicionar alguns dados à tabela usando as consultas fornecidas abaixo:

Inserir em amostragem.idiomas (id, idioma_name, iniciante_friendly) valores (1, "python", true);
Inserir em amostragem.idiomas (id, idioma_name, iniciante_friendly) valores (2, "c ++", false);

Se agora você selecionar os valores na tabela acima:

mysql> selecione * de amostragem.línguas
->;
+----+---------------+-------------------+
| Id | Idioma_name | Beginner_friendly |
+----+---------------+-------------------+
| 1 | Python | 1 |
| 2 | C ++ | 0 |
+----+---------------+-------------------+
2 linhas no set (0.00 seg)

Você verá que os valores estão definidos como 0 e 1, respectivamente.

OBSERVAÇÃO: Você pode armazenar valores numéricos na coluna booleana, exceto valores verdadeiros e falsos. Por exemplo, considere a consulta abaixo:

Inserir em amostragem.idiomas (id, idioma_name, iniciante_friendly) valores (3, "go lang", 10);

Se você executar a consulta acima, o MySQL não relatará um erro. Em vez disso, ele armazenará o valor numérico como 10. Considere a saída mostrada abaixo:

mysql> selecione * de amostragem.línguas;
+----+---------------+-------------------+
| Id | Idioma_name | Beginner_friendly |
+----+---------------+-------------------+
| 1 | Python | 1 |
| 2 | C ++ | 0 |
| 3 | Vá lang | 10 |
+----+---------------+-------------------+
3 linhas no set (0.00 seg)

Operadores booleanos do MySQL

O MySQL suporta vários operadores booleanos, como é verdadeiro, é falso, não é verdadeiro e não é falso. Com base no nome, você pode determinar que alguns fazem exatamente a mesma coisa.

Por exemplo, é verdadeiro e não é falso são semelhantes. O mesmo caso se aplica ao outro par.

No entanto, podemos usar esses operadores para obter um conjunto de valores que são verdadeiros ou falsos. Por exemplo, a consulta abaixo recebe todos os valores em que iniciante_friendly é verdadeiro.

mysql> selecione * de amostragem.idiomas onde iniciantes_friendly é verdadeiro;
+----+---------------+-------------------+
| Id | Idioma_name | Beginner_friendly |
+----+---------------+-------------------+
| 1 | Python | 1 |
| 3 | Vá lang | 10 |
+----+---------------+-------------------+
2 linhas no set (0.00 seg)

Como podemos ver na saída, só obtemos valores onde o valor de iniciante_friendly é verdadeiro.

Você também pode obter os valores falsos usando qualquer É verdadeiro ou não é verdadeiro.

mysql> selecione * de amostragem.idiomas onde iniciantes_friendly não é verdadeiro;
+----+---------------+-------------------+
| Id | Idioma_name | Beginner_friendly |
+----+---------------+-------------------+
| 2 | C ++ | 0 |
+----+---------------+-------------------+
1 linha no conjunto (0.00 seg)

Conclusão

Este guia mostrou como implementar e usar os tipos de dados booleanos do MySQL para armazenar valores verdadeiros ou falsos.