5 - Operadores Lógicos

Operador

Un operador, como su propio nombre indica, es quien opera, normalmente entre dos operandos, estableciendo una operación que al ejecutarla se obtiene un resultado.

Por ejemplo en matemáticas: 3 + 4.
"+" es el operador y, "3" y "4" son los operandos. El resultado de esta operación es 7.

A modo de apunte diremos, aunque poco tenga que ver con esta lección, que el SQL nos permite calcular ciertas operaciones matemáticas tanto en la cláusula SELECT, para obtener resultados, como en la cláusula WHERE, para establecer condiciones:

select 3 + 4
                

A la pregunta: ¿Qué empleados tienen un salario mayor de 1350?, podríamos construir la consulta SQL así, sustituyendo 1350 por: 1300 + 50

select NOMBRE, APELLIDOS
  from EMPLEADOS
 where SALARIO > 1300 + 50
                

Lógica Booleana

Lo que se pretende abordar en esta lección principalmente es la lógica booleana, que es la que nos permite establecer condiciones. Advierto que esta lección puede resultar un poco dura, si tiene dificultades para entender lo que trataremos, no se preocupe e intente quedarse con la idea de fondo.

Cuando usted jugaba al ya clásico juego de ¿Quién es Quién?

usted estaba aplicando lógica booleana para descubrir el personaje que su contrincante escondía. Usted lanzaba preguntas con el propósito de saber si una característica del personaje misterioso era cierta o falsa, y si era cierta, descartaba los personajes que no presentaban esa característica.

El SGBD hace algo muy parecido, usted establece una característica en la cláusula WHERE de la consulta SQL, y el SGBD descarta los registros en qué la característica es falsa, mientras que mantiene los que es cierta.

Expresiones Booleanas

Si usted jugando a ¿Quién es quién? preguntaba a su contrincante: ¿tiene barba?, lo que en realidad estaba preguntando era: ¿EL PERSONAJE MISTERIOSO tiene BARBA? Pues bien, esto es una expresión booleana donde:

• "tiene" es el operador.
• "EL PERSONAJE MISTERIOSO" es un operando variable.
• "BARBA" es un operando constante.

El resultado de aplicar esta expresión a un personaje concreto dará cierto si el personaje tiene barba, y falso en caso contrario.

Cuando en la primera consulta de este curso:

select NOMBRE, APELLIDOS
  from EMPLEADOS
 where SALARIO > 1350
            

indicábamos en la cláusula WHERE: SALARIO > 1350 (¿es SALARIO mayor a 1350?), estábamos estableciendo una expresión booleana donde:

">" es el operador, «SALARIO» es un operando variable, que tomará valores de cada registro de la tabla EMPLEADOS, y «1350» es un operando constante. El resultado de esta expresión depende del valor que tome la variable SALARIO, pero en cualquier caso solo puede dar dos posibles resultados: cierto o falso. Por lo tanto, una expresión booleana solo tiene dos posibles resultados.

El motor SQL evalúa la expresión booleana de la cláusula WHERE para cada registro de la tabla, y el resultado determina si el registro que se está tratando se tomará en consideración. Lo hará si el resultado de evaluar la expresión es cierto, y lo ignorará si el resultado es falso.

Ejemplo de expresiones booleanas:

• "4 > 3": ¿es cuatro mayor que tres?
• "3 = 12": ¿es tres igual a doce?

Fíjese que los operandos son del mismo tipo (tipo INT). Sin embargo, el resultado obtenido no es un dato de tipo INT, sino booleano, cuyos posibles valores son cierto o falso.

(4 > 3) = cierto

(3 = 12) = falso

Operadores de Comparación

Algunos de los operadores que nos permiten construir expresiones booleanas son:

• > : "A > B" devuelve cierto si A es estrictamente mayor que B.
• < : "A < B" devuelve cierto si A es estrictamente menor que B.
• = : "A = B" devuelve cierto si A es igual a B.
• >= : "A >= B" devuelve cierto si A es mayor o igual a B.
• <= : "A <= B" devuelve cierto si A es menor o igual a B.
• != : "A != B" devuelve cierto si A es distinto de B. Para este mismo propósito puede usar la notación: “A <> B”

Al construir expresiones con estos operadores, los dos operandos deben ser del mismo tipo, ya sean números, cadenas o fechas.

Ejemplo de expresión booleana con cadenas: ('Aranda, Pedro' < 'Zapata, Mario') = cierto, puesto que por orden alfabético 'Aranda, Pedro' está posicionado antes que 'Zapata, Mario', por lo tanto es menor el primero que el segundo.

Operadores Lógicos

Los operadores lógicos permiten formar expresiones booleanas tomando como operandos otras expresiones booleanas. El conjunto forma una nueva expresión booleana que, como toda expresión booleana, dará como resultado cierto o falso.

• AND : "A and B" devuelve cierto si A y B valen cierto, y falso en cualquier otro caso.
• OR : "A or B" devuelve cierto si A o B valen cierto, y falso únicamente cuando tanto A como B valen falso.
• NOT : "not A" devuelve falso si A vale cierto, y cierto si A vale falso.

Veamos una aplicación en el mundo cotidiano. Supongamos el siguiente enunciado:

Mi jefe quiere contratar a una persona para repartir género. Solamente pueden optar a la vacante aquellos candidatos que tengan vehículo propio y licencia de conducir automóviles.

Convertimos el anunciado en una expresión booleana:

Sea C: pasa al proceso de selección.
Sea A: tiene vehículo propio.
Sea B: tiene licencia de conducir automóviles.

Entonces para que un candidato satisfaga C, se debe dar A y B:
C = A AND B

Resolvamos la expresión para cada candidato:

• Aplicado a Ángela (Vehículo=falso, Licencia=cierto): C = (falso AND cierto) = falso.
• Aplicado a Salva (Vehículo=cierto, Licencia=cierto): C = (cierto AND cierto) = cierto.
• Aplicado a Teresa (Vehículo=cierto, Licencia=falso): C = (cierto AND falso) = falso.

Por lo tanto solo Salva pasa al proceso de selección.

Veamos esto mismo aplicado al SQL. Consideremos ahora la tabla PERSONAS, donde se guarda una «S» en el campo RUBIA si la persona es rubia y una «N» en caso contrario, análogamente se ha aplicado el mismo criterio para ALTA y GAFAS, es decir, para indicar si es alta y si lleva gafas.

El Operador AND

Como ya hemos dicho el operador AND devuelve cierto si ambas expresiones son ciertas. Supongamos que queremos saber ¿qué personas son rubias y altas?, para ello construimos la siguiente consulta SQL:

select NOMBRE
  from PERSONAS
 where (RUBIA = 'S') and (ALTA = 'S') 
            

Resultado:

Evaluar (RUBIA = 'S') da como resultado cierto o falso, al igual que evaluar (ALTA = 'S'). Si para un registro ambos son ciertos, el resultado es cierto, y se mostrarán los datos de ese registro que indica la cláusula SELECT.

En el caso de tener una expresión de la forma: "A AND B AND D" la expresión se evalúa por partes en orden de aparición: Primero se evalúa (A AND B) = E y finalmente (E AND D).

Si todos los operadores de la expresión son AND, entonces todas las expresiones deben valer cierto para que el resultado sea cierto.

Veamos un ejemplo de esto mientras jugamos a ¿Quién es quién?

Usted pregunta:

¿Es rubia? Y la respuesta es cierto
¿Es alta? Y la respuesta es falso
¿Lleva gafas? Y la respuesta es cierto

Por lo tanto, debe ser una persona que sea rubia y, no sea alta y, lleve gafas.

select NOMBRE
  from PERSONAS
 where (RUBIA = 'S') and (ALTA = 'N') and (GAFAS='S') 
            

Resultado:

Antes de dejar el operador AND, recordar el modo equivalente y más simplificado que se comentó en la lección 3 en que podemos condicionar un campo a un rango de valores mediante el operador BETWEEN:

where SALARIO >= 1300 and SALARIO <= 1500
            

...que el salario sea mayor o igual a 1300 y menor o igual a 1500.

Forma equivalente:

where SALARIO between 1300 and 1500
            

...que el salario esté entre 1300 y 1500.

El Operador OR

Con el operador OR, basta que uno de los dos operandos sea cierto para que el resultado sea cierto

Supongamos que queremos saber las personas que son rubias o bien altas, es decir, queremos que si es rubia la considere con independencia de su altura, y a la inversa, también queremos que la seleccione si es alta independientemente del color de pelo. La consulta sería la siguiente.

select NOMBRE
  from PERSONAS
 where (RUBIA = 'S') or (ALTA = 'S') 
            

Resultado:

Si todos los operadores de la expresión son OR, por ejemplo "A OR B OR C", entonces todos las expresiones deben valer falso para que el resultado sea falso, con que solo una valga cierto el resultado es cierto.

Uso de OR con el mismo campo (IN)

Supongamos que quiere seleccionar tres registros concretos de la tabla EMPLEADOS, le interesan los registros con identificador 1, 2 y 4. Para esta situación debe usar el operador OR:

select *
  from EMPLEADOS
 where ID_EMPLEADO = 1 or ID_EMPLEADO = 2 or ID_EMPLEADO = 4
            

Resultado:

El asterisco presente en la cláusula SELECT equivale a indicar todos los campos de la tabla.

Fíjese cómo en la anterior consulta para cualquier registro de la tabla EMPLEADOS que el campo ID_EMPLEADO contenga un valor distinto a 1, 2 o 4, el resultado de evaluar la expresión será falso, puesto que todos las expresiones booleanas darán falso, pero con que una de ellas valga cierto, el registro será seleccionado. De hecho si un mismo campo aparece dos o más veces en expresiones de la cláusula WHERE como en el ejemplo anterior, carece de sentido que el operador sea AND: usted puede esperar al salir de casa encontrarse un día seco o lluvioso, pero no puede esperar encontrar un día seco y lluvioso. Del mismo modo el identificador de un registro nunca podrá ser 1 y 2, o es 1 o es 2 o es X.

Un modo de simplificar la anterior consulta es mediante la palabra clave IN, donde se establece una lista de valores posibles. La palabra clave IN equivale a establecer condiciones sobre un mismo campo conectadas por el operador OR.

select *
  from EMPLEADOS
 where ID_EMPLEADO in (1,2,4) 
            

Resultado:

El Operador NOT

Este operador tan solo tiene un operando, el resultado es negar el valor del operando de modo que:

(4 > 3) = cierto. Luego NOT (4 > 3) = falso

Si negamos dos veces una expresión booleana es equivalente a la expresión original:

(4 > 3) = cierto. Luego NOT ( NOT (4 > 3) ) = cierto

Cuando descubrimos al personaje misterioso, a la pregunta ¿es alta? la respuesta era falso. Como en el campo ALTA solo esperamos encontrar 'S' o 'N', podríamos haber establecido lo siguiente: NOT (ALTA = 'S') en lugar de (ALTA = 'N'):

select NOMBRE 
  from PERSONAS 
 where (RUBIA = 'S') and not (ALTA = 'S') and (GAFAS='S')
              

Resultado:

Otro ejemplo: si negamos toda la expresión de la cláusula WHERE, estaremos precisamente seleccionando los registros que antes descartábamos, y al revés, descartando los que antes seleccionábamos.

Tomemos la anterior consulta y neguemos la cláusula WHERE, si antes el resultado era: Carmen, ahora el resultado ha de ser todas las personas menos Carmen. Para hacer esto cerramos entre paréntesis toda la expresión y le colocamos el operador NOT delante, de ese modo primero se resolverá lo que está dentro de los paréntesis y finalmente se negará el resultado.

select NOMBRE
  from PERSONAS
 where not ( (RUBIA = 'S')
              and not(ALTA = 'S')
              and (GAFAS= 'S')
            )
              

Efectivamente el resultado es justo el complementario, todas las personas salvo Carmen:

Y, además, otro ejemplo de este operador combinado con el operador IN: tomemos la consulta que seleccionaba tres registros concretos de la tabla EMPLEADOS, y modifiquémosla únicamente incluyendo el operador NOT para que devuelva lo complementario, es decir, todos los registros menos los tres que antes seleccionaba:

select * from EMPLEADOS 
 where ID_EMPLEADO not in (1,2,4)
              

Resultado:

El uso de Paréntesis

Los paréntesis se comportan como en matemáticas, no es lo mismo "5 + 4 / 3", donde primero se calculará la división y después se sumará 5, que "(5 + 4) / 3", donde primero se resolverá la suma y el resultado parcial se dividirá por 3. Sin paréntesis la división tiene prioridad sobre la suma, con paréntesis forzamos a que la operación se realice en el orden deseado.

Los operadores AND y OR tienen la misma prioridad de modo que se evalúa la expresión por orden de aparición:

No es lo mismo: "RUBIA AND ALTA OR GAFAS" = "(RUBIA AND ALTA) OR GAFAS" que, "RUBIA AND (ALTA OR GAFAS)". En el primer caso estamos diciendo: «que sea rubia y alta, o bien lleve gafas», y en el segundo «que sea rubia y, sea alta o lleve gafas».

select NOMBRE
  from PERSONAS
 where RUBIA = 'S' and ALTA = 'S' or GAFAS = 'S'
              

Resultado:

select NOMBRE 
  from PERSONAS 
 where RUBIA = 'S' and (ALTA = 'S' or GAFAS = 'S')
              

Resultado:

Resumen

En esta lección se ha descrito cómo construir expresiones booleanas y cómo trabajar con ellas para establecer condiciones en la cláusula WHERE de una consulta SQL.

Las expresiones booleanas con operadores tales como ( > , = , != ...) precisan operandos de tipo número, cadena o fecha, y el resultado devuelve siempre cierto o falso.

Ejemplo: (SALARIO > 1350)

Las expresiones con operadores tales como (AND , OR , NOT) precisan expresiones booleanas como operandos, el conjunto forma una nueva expresión booleana que al evaluarla será cierta o falsa.

Ejemplo: RUBIA = 'S' AND ALTA = 'S'

El uso de paréntesis garantiza que, en una expresión compleja, las expresiones simples que la forman se evalúen en el orden que usted desea.

Ejemplo: NOT ( (RUBIA = 'S' OR ALTA = 'S') AND (ALTA ='N' OR GAFAS = 'S') )

select NOMBRE
  from PERSONAS
 where ALTA = 'S' or (RUBIA = 'S' and GAFAS = 'S') 
                    

select NOMBRE, APELLIDOS
  from EMPLEADOS
 where SEXO = 'M'
   and SALARIO > 1300
                    

select NOMBRE
  from PERSONAS
 where GAFAS = 'S'
   and not RUBIA = 'S'
   and not ALTA = 'S'