Reglas para las comparaciones de valores

MySQL Sigue las siguientes reglas a la hora de comparar valores:

  • Si uno o los dos valores a comparar son NULL, el resultado es NULL, excepto con el operador <=>, de comparación con NULL segura.
  • Si los dos valores de la comparación son cadenas, se comparan como cadenas.
  • Si ambos valores son enteros, se comparan como enteros.
  • Los valores hexadecimales se tratan como cadenas binarias, si no se comparan con un número.
  • Si uno de los valores es del tipo TIMESTAMP o DATETIME y el otro es una constante, la constantes se convierte a timestamp antes de que se lleve a cabo la comparación. Hay que tener en cuenta que esto no se hace para los argumentos de una expresión IN(). Para estar seguro, es mejor usar siempre cadenas completas datetime/date/time strings cuando se hacen comparaciones.
  • En el resto de los casos, los valores se comparan como números en coma flotante.

Operadores de comparación

Para crear expresiones lógicas, a las que podremos aplicar el álgebra de Boole, disponemos de varios operadores de comparación. Estos operadores se aplican a cualquier tipo de columna: fechas, cadenas, números, etc, y devuelven valores lógicos: verdadero o falso (1/0).

Los operadores de comparación son los habituales en cualquier lenguaje de programación, pero además, MySQL añade varios más que resultan de mucha utilidad, ya que son de uso muy frecuente.

Operador de igualdad

El operador = compara dos expresiones, y da como resultado 1 si son iguales, o 0 si son diferentes. Ya lo hemos usado en ejemplos anteriormente:

mysql> SELECT * FROM gente WHERE fecha="2001-12-02";
+--------+------------+
| nombre | fecha      |
+--------+------------+
| Tulano | 2001-12-02 |
+--------+------------+
1 row in set (0.00 sec)

mysql>

Hay que mencionar que, al contrario que otros lenguajes, como C o C++, donde el control de tipos es muy estricto, en MySQL se pueden comparar valores de tipos diferentes, y el resultado será el esperado.

Por ejemplo:

mysql> SELECT "0" = 0, "0.1"=.1;
+---------+----------+
| "0" = 0 | "0.1"=.1 |
+---------+----------+
|       1 |        1 |
+---------+----------+
1 row in set (0.00 sec)

mysql>

Esto es así porque MySQL hace conversión de tipos de forma implícita, incluso cuando se trate de valores de tipo cadena.

Operador de igualdad con NULL seguro

El operador <=> funciona igual que el operador =, salvo que si en la comparación una o ambas de las expresiones es nula el resultado no es NULL. Si se comparan dos expresiones nulas, el resultado es verdadero:

mysql> SELECT NULL = 1, NULL = NULL;
+----------+-------------+
| NULL = 1 | NULL = NULL |
+----------+-------------+
|     NULL |        NULL |
+----------+-------------+
1 row in set (0.00 sec)

mysql> SELECT NULL <=> 1, NULL <=> NULL;
+------------+---------------+
| NULL <=> 1 | NULL <=> NULL |
+------------+---------------+
|          0 |             1 |
+------------+---------------+
1 row in set (0.00 sec)

mysql>

Operador de desigualdad

MySQL dispone de dos operadores equivalente para comprobar desigualdades, <> y !=. Si las expresiones comparadas son diferentes, el resultado es verdadero, y si son iguales, el resultado es falso:

mysql> SELECT 100 <> 32, 43 != 43;
+-----------+----------+
| 100 <> 32 | 43 != 43 |
+-----------+----------+
|         1 |        0 |
+-----------+----------+
1 row in set (0.02 sec)

mysql>

Operadores de comparación de magnitud

Disponemos de los cuatro operadores corrientes.

Operador Descripción
<= Menor o igual
< Menor
> Mayor
>= Mayor o igual

Estos operadores también permiten comparar cadenas, fechas, y por supuesto, números:

mysql> SELECT "hola" < "adios", "2004-12-31" > "2004-12-01";
+------------------+-----------------------------+
| "hola" < "adios" | "2004-12-31" > "2004-12-01" |
+------------------+-----------------------------+
|                0 |                           1 |
+------------------+-----------------------------+
1 row in set (0.00 sec)

mysql> SELECT ".01" >= "0.01", .01 >= 0.01;
+-----------------+-------------+
| ".01" >= "0.01" | .01 >= 0.01 |
+-----------------+-------------+
|               0 |           1 |
+-----------------+-------------+
1 row in set (0.00 sec)

mysql>

Cuando se comparan cadenas, se considerá menor la cadena que aparezca antes por orden alfabético.

Si son fechas, se considera que es menor cuanto más antigua sea.

Pero cuidado, como vemos en el segundo ejemplo, si comparamos cadenas que contienen números, no hay conversión, y se comparan las cadenas tal como aparecen.

Verificación de NULL

Los operadores IS NULL e IS NOT NULL sirven para verificar si una expresión determinada es o no nula. La sintaxis es:

<expresión> IS NULL
<expresión> IS NOT NULL

Por ejemplo:

mysql> SELECT NULL IS NULL;
+--------------+
| NULL IS NULL |
+--------------+
|            1 |
+--------------+
1 row in set (0.00 sec)

mysql> SELECT "NULL" IS NOT NULL;
+--------------------+
| "NULL" IS NOT NULL |
+--------------------+
|                  1 |
+--------------------+
1 row in set (0.00 sec)

mysql>

Verificar pertenencia a un rango

Entre los operadores de MySQL, hay uno para comprobar si una expresión está comprendida en un determinado rango de valores. La sintaxis es:

<expresión> BETWEEN mínimo AND máximo
<expresión> NOT BETWEEN mínimo AND máximo

En realidad es un operador prescindible, ya que se puede usar en su lugar dos expresiones de comparación y el operador AND. Estos dos ejemplos son equivalentes:

mysql> SELECT 23 BETWEEN 1 AND 100;
+----------------------+
| 23 BETWEEN 1 AND 100 |
+----------------------+
|                    1 |
+----------------------+
1 row in set (0.00 sec)

mysql> SELECT 23 >= 1 AND 23 <= 100;
+-----------------------+
| 23 >= 1 AND 23 <= 100 |
+-----------------------+
|                     1 |
+-----------------------+
1 row in set (0.00 sec)

mysql>

Del mismo modo, estas dos expresiones también lo son:

mysql> SELECT 23 NOT BETWEEN 1 AND 100;
+--------------------------+
| 23 NOT BETWEEN 1 AND 100 |
+--------------------------+
|                        0 |
+--------------------------+
1 row in set (0.00 sec)

mysql> SELECT NOT (23 BETWEEN 1 AND 100);
+----------------------------+
| NOT (23 BETWEEN 1 AND 100) |
+----------------------------+
|                          0 |
+----------------------------+
1 row in set (0.00 sec)

mysql>