Elección de no nulos

El operador COALESCE sirve para seleccionar el primer valor no nulo de una lista o conjunto de expresiones. La sintaxis es:

COALESCE(<expr1>, <expr2>, <expr3>...)

El resultado es el valor de la primera expresión distinta de NULL que aparezca en la lista. Por ejemplo:

mysql> SET @a=23, @b="abc", @d="1998-11-12";
Query OK, 0 rows affected (0.03 sec)

mysql> SELECT COALESCE(@c, @a, @b, @d);
+--------------------------+
| COALESCE(@c, @a, @b, @d) |
+--------------------------+
| 23                       |
+--------------------------+
1 row in set (0.05 sec)

mysql>

En este ejemplo no hemos definido la variable @c, por lo tanto, tal como dijimos antes, su valor se considera NULL. El operador COALESCE devuelve el valor de la primera variable no nula, es decir, el valor de @a.

Valores máximo y mínimo de una lista

Los operadores GREATEST y LEAST devuelven el valor máximo y mínimo, respectivamente, de la lista de expresiones dada. La sintaxis es:

GREATEST(<expr1>, <expr2>, <expr3>...)
LEAST(<expr1>, <expr2>, <expr3>...)

La lista de expresiones debe contener al menos dos valores.

Los argumentos se comparan según estas reglas:

• Si el valor de retorno se usa en un contexto entero, o si todos los elementos de la lista son enteros, estos se comparan entre si como enteros.
• Si el valor de retorno se usa en un contexto real, o si todos los elementos son valores reales, serán comparados como reales.
• Si cualquiera de los argumentos es una cadena sensible al tipo (mayúsculas y minúsculas son caracteres diferentes), los argumentos se comparan como cadenas sensibles al tipo.
• En cualquier otro caso, los argumentos se comparan como cadenas no sensibles al tipo.

mysql> SELECT LEAST(2,5,7,1,23,12);
+----------------------+
| LEAST(2,5,7,1,23,12) |
+----------------------+
|                    1 |
+----------------------+
1 row in set (0.69 sec)

mysql> SELECT GREATEST(2,5,7,1,23,12);
+-------------------------+
| GREATEST(2,5,7,1,23,12) |
+-------------------------+
|                      23 |
+-------------------------+
1 row in set (0.03 sec)

mysql> SELECT GREATEST(2,5,"7",1,"a",12);
+----------------------------+
| GREATEST(2,5,"7",1,"a",12) |
+----------------------------+
|                         12 |
+----------------------------+
1 row in set (0.09 sec)

mysql>

Verificar conjuntos

Los operadores IN y NOT IN sirven para averiguar si el valor de una expresión determinada está dentro de un conjunto indicado. La sintaxis es:

 IN (<expr1>, <expr2>, <expr3>...)
 NOT IN (<expr1>, <expr2>, <expr3>...)

El operador IN devuelve un valor verdadero, 1, si el valor de la expresión es igual a alguno de los valores especificados en la lista. El operador NOT IN devuelve un valor falso en el mismo caso. Por ejemplo:

mysql> SELECT 10 IN(2, 4, 6, 8, 10);
+-----------------------+
| 10 IN(2, 4, 6, 8, 10) |
+-----------------------+
|                     1 |
+-----------------------+
1 row in set (0.00 sec)

mysql>

Verificar nulos

El operador ISNULL es equivalente a IS NULL.

La sintaxis es:

ISNULL(<expresión>)

Por ejemplo:

mysql> SELECT 1/0 IS NULL, ISNULL(1/0);
+-------------+-------------+
| 1/0 IS NULL | ISNULL(1/0) |
+-------------+-------------+
|           1 |           1 |
+-------------+-------------+
1 row in set (0.02 sec)

mysql>

Encontrar intervalo

Se puede usar el operador INTERVAL para calcular el intervalo al que pertenece un valor determinado. La sintaxis es:

INTERVAL(<expresión>, <límite1>, <limite1>, ... <limiten>)

Si el valor de la expresión es menor que límite1, el operador regresa con el valor 0, si es mayor o igual que límite1 y menor que limite2, regresa con el valor 1, etc.

Todos los valores de los límites deben estar ordenados, ya que MySQL usa el algoritmo de búsqueda binaria.

Nota: Según la documentación, los valores de los índices se trata siempre como enteros, aunque he podido verificar que el operador funciona también con valores en coma flotante, cadenas y fechas.

mysql> SET @x = 19;
Query OK, 0 rows affected (0.02 sec)

mysql> SELECT INTERVAL(@x, 0, 10, 20, 30, 40);
+---------------------------------+
| INTERVAL(@x, 0, 10, 20, 30, 40) |
+---------------------------------+
|                               2 |
+---------------------------------+
1 row in set (0.01 sec)

mysql> SELECT INTERVAL("Gerardo", "Antonio", 
    -> "Fernando", "Ramón", "Xavier");
+---------------------------------------------------------------+
| INTERVAL("Gerardo", "Antonio", "Fernando", "Ramón", "Xavier") |
+---------------------------------------------------------------+
|                                                             4 |
+---------------------------------------------------------------+
1 row in set (0.01 sec)

mysql>

Operadores aritméticos  

Los operadores aritméticos se aplican a valores numéricos, ya sean enteros o en coma flotante. El resultado siempre es un valor numérico, entero o en coma flotante.

MySQL dispone de los operadores aritméticos habituales: suma, resta, multiplicación y división.

En el caso de los operadores de suma, resta, cambio de signo y multiplicación, si los operandos son enteros, el resultado se calcula usando el tipo BIGINT, es decir, enteros de 64 bits. Hay que tener esto en cuenta, sobre todo en el caso de números grandes.

Operador de adición o suma

El operador para la suma es, como cabría esperar, +. No hay mucho que comentar al respecto. Por ejemplo:

mysql> SELECT 192+342, 23.54+23;
+---------+----------+
| 192+342 | 23.54+23 |
+---------+----------+
|     534 |    46.54 |
+---------+----------+
1 row in set (0.00 sec)

mysql>

Este operador, al igual que el de resta, multiplicación y división, es binario. Como comentamos al hablar de los operadores lógicos, esto no significa que no se puedan asociar, sino que la operaciones se realizan tomando los operandos dos a dos.

Operador de sustracción o resta

También con la misma lógica, el operador para restar es el -. Otro ejemplo:

mysql> SELECT 192-342, 23.54-23;
+---------+----------+
| 192-342 | 23.54-23 |
+---------+----------+
|    -150 |     0.54 |
+---------+----------+
1 row in set (0.02 sec)

mysql>

Operador unitario menos

Este operador, que también usa el símbolo -, se aplica a un único operando, y como resultado se obtiene un valor de signo contrario. Por ejemplo:

mysql> SET @x=100;
Query OK, 0 rows affected (0.00 sec)

mysql> SELECT -@x;
+------+
| -@x  |
+------+
| -100 |
+------+
1 row in set (0.01 sec)

mysql>

Operador de producto o multiplicación

También es un operador binario, el símbolo usado es el asterisco, *. Por ejemplo:

mysql> SELECT 12343432*3123243, 312*32*12;
+------------------+-----------+
| 12343432*3123243 | 312*32*12 |
+------------------+-----------+
|   38551537589976 |    119808 |
+------------------+-----------+
1 row in set (0.00 sec)

mysql>

Operador de cociente o división

El resultado de las divisiones, por regla general, es un número en coma flotante. Por supuesto, también es un operador binario, y el símbolo usado es /.

Dividir por cero produce como resultado el valor NULL. Por ejemplo:

mysql> SELECT 2132143/3123, 4324/25434, 43/0;
+--------------+------------+------+
| 2132143/3123 | 4324/25434 | 43/0 |
+--------------+------------+------+
|       682.72 |       0.17 | NULL |
+--------------+------------+------+
1 row in set (0.00 sec)

mysql>

Operador de división entera

Existe otro operador para realizar divisiones, pero que sólo calcula la parte entera del cociente. El operador usado es DIV. Por ejemplo:

mysql> SELECT 2132143 DIV 3123, 4324 DIV 25434, 43 DIV 0;
+------------------+----------------+----------+
| 2132143 DIV 3123 | 4324 DIV 25434 | 43 DIV 0 |
+------------------+----------------+----------+
|              682 |              0 |     NULL |
+------------------+----------------+----------+
1 row in set (0.00 sec)

mysql>