Uso del tipo de datos booleanos mySQL

Por defecto, MySQL no ofrece un tipo de datos booleanos nativos. Sin embargo, nos proporciona el tipo de datos Tinyint, lo que nos permite almacenar valores booleanos con el tipo Tinyint.

Esta guía se centrará en cómo usar el tipo de datos MySQL Tinyint para almacenar valores booleanos.

Uso básico

MySQL define un valor de 0 como falso y un valor distinto de cero como verdadero. Por lo tanto, para usar valores literal booleanos, usa las constantes verdaderas y falsas que evalúan el valor de 0 y 1.

Un ejemplo:

Seleccione True, False;

Una vez que ejecute la consulta anterior, obtendrá una salida similar a la que se muestra a continuación:

mysql> seleccione True, False;
+------+-------+
| Verdadero | Falso |
+------+-------+
| 1 | 0 |
+------+-------+
1 fila en el set (0.00 seg)

De lo anterior, podemos deducir que MySQL considera 1 y 0 como verdadero y falso, respectivamente.

Es bueno tener en cuenta que a medida que aumenta o en minúsculas, MySQL asigna verdadero y falso 0 y 1 como se muestra en la consulta a continuación:

seleccione True, False, True, False, True, False;

La salida es como se muestra a continuación:

+------+-------+------+-------+------+-------+
| Verdadero | Falso | Verdadero | falso | Verdadero | Falso |
+------+-------+------+-------+------+-------+
| 1 | 0 | 1 | 0 | 1 | 0 |
+------+-------+------+-------+------+-------+
1 fila en el set (0.00 seg)

Ejemplo de casos de uso

Usemos un ejemplo para ilustrar cómo podemos usar el tipo booleano en mysql.

Comience por crear una base de datos y una tabla llamada lenguaje, que almacenará información sobre varios lenguajes de programación.

Dentro de la tabla, tenemos las siguientes columnas:

1. ID - int no nulo auto_increment
2. Lenguaje_name - varchar (100) no nulo
3. Beginner_friendly - booleano

Considere la consulta a continuación para implementar la base de datos anterior:

Crear una base de datos muestreada;
Usar muestras;
Crear idiomas de tabla (
ID int no nulo auto_increment,
Lenguaje_name varchar (100),
Booleano de principiantes,
Clave principal (ID)
);

Una vez que ejecute la consulta anterior, tendrá la base de datos muestras con la tabla de idiomas.

Para obtener la información sobre la tabla anterior, podemos usar la instrucción MySQL DESC como se muestra en la salida a continuación:

MySQL> Desc idiomas;
+-------------------+--------------+------+-----+---------+----------------+
| Campo | Tipo | NULL | Clave | Predeterminado | Extra |
+-------------------+--------------+------+-----+---------+----------------+
| ID | int | No | PRI | NULL | auto_increment |
| Lenguaje_name | Varchar (100) | SÍ | | NULL | |
| Beginner_friendly | Tinyint (1) | SÍ | | NULL | |
+-------------------+--------------+------+-----+---------+----------------+
3 filas en el set (0.01 seg)

Si miras el campo Beginner_friendly, que establecemos como booleano al crear la tabla, ahora muestra tipo de Tinyint.

En el siguiente paso, agregemos algunos datos a la tabla utilizando las consultas proporcionadas a continuación:

Insertar en muestras.Idiomas (id, idioma_name, principiantes_friendly) valores (1, "python", true);
Insertar en muestras.Lenguages ​​(id, idioma_name, principiante_friendly) valores (2, "c ++", falso);

Si ahora selecciona los valores en la tabla de arriba:

mysql> seleccionar * de Sampled.lenguas
->;
+----+---------------+-------------------+
| ID | Lenguaje_name | Beginner_friendly |
+----+---------------+-------------------+
| 1 | Python | 1 |
| 2 | C ++ | 0 |
+----+---------------+-------------------+
2 filas en el set (0.00 seg)

Verá que los valores se establecen en 0 y 1, respectivamente.

NOTA: Puede almacenar valores numéricos en la columna booleana que no sean valores verdaderos y falsos. Por ejemplo, considere la consulta a continuación:

Insertar en muestras.Idiomas (id, idioma_name, principiantes_friendly) valores (3, "Go lang", 10);

Si ejecuta la consulta anterior, MySQL no informará un error. En cambio, almacenará el valor numérico como 10. Considere la salida que se muestra a continuación:

mysql> seleccionar * de Sampled.idiomas;
+----+---------------+-------------------+
| ID | Lenguaje_name | Beginner_friendly |
+----+---------------+-------------------+
| 1 | Python | 1 |
| 2 | C ++ | 0 |
| 3 | Ir lang | 10 |
+----+---------------+-------------------+
3 filas en el set (0.00 seg)

Operadores booleanos de MySQL

Mysql admite varios operadores booleanos como es verdadero, es falso, no es verdadero y no es falso. Basado en el nombre, puede determinar que algunos hacen exactamente lo mismo.

Por ejemplo, es verdadero y no es falso son similares. El mismo caso se aplica al otro par.

Sin embargo, podemos usar estos operadores para obtener un conjunto de valores que es verdadero o falso. Por ejemplo, la consulta a continuación obtiene todos los valores donde Beginner_friendly es verdadero.

mysql> seleccionar * de Sampled.Idiomas donde Beginner_friendly es verdad;
+----+---------------+-------------------+
| ID | Lenguaje_name | Beginner_friendly |
+----+---------------+-------------------+
| 1 | Python | 1 |
| 3 | Ir lang | 10 |
+----+---------------+-------------------+
2 filas en el set (0.00 seg)

Como podemos ver en la salida, solo obtenemos valores donde el valor de principiantes es verdadero.

También puede obtener los valores falsos usando cualquiera Es verdadero o no es verdad.

mysql> seleccionar * de Sampled.Idiomas donde Beginner_friendly no es verdad;
+----+---------------+-------------------+
| ID | Lenguaje_name | Beginner_friendly |
+----+---------------+-------------------+
| 2 | C ++ | 0 |
+----+---------------+-------------------+
1 fila en el set (0.00 seg)

Conclusión

Esta guía le ha mostrado cómo implementar y usar los tipos de datos booleanos de MySQL para almacenar valores verdaderos o falsos.