En SQL, el operador distinto de (<> ) compara la no igualdad de dos expresiones. Es decir, prueba si una expresión es no igual a otra expresión.
Si uno o ambos operandos son NULL , NULL es devuelto.
SQL también tiene otro operador no igual a (!= ), que hace lo mismo. El que use puede depender de su DBMS, con cuál se sienta más cómodo y quizás también si su organización tiene alguna convención de codificación que dicte cuál debe usarse.
Tabla de origen
Imagine que nuestra base de datos contiene la siguiente tabla. Esta es la tabla que usaremos para los ejemplos de esta página.
SELECT * FROM Pets;Resultado:
+---------+-------------+-----------+-----------+------------+ | PetId | PetTypeId | OwnerId | PetName | DOB | |---------+-------------+-----------+-----------+------------| | 1 | 2 | 3 | Fluffy | 2020-11-20 | | 2 | 3 | 3 | Fetch | 2019-08-16 | | 3 | 2 | 2 | Scratch | 2018-10-01 | | 4 | 3 | 3 | Wag | 2020-03-15 | | 5 | 1 | 1 | Tweet | 2020-11-28 | | 6 | 3 | 4 | Fluffy | 2020-09-17 | | 7 | 3 | 2 | Bark | NULL | | 8 | 2 | 4 | Meow | NULL | +---------+-------------+-----------+-----------+------------+ (8 rows affected)
Ejemplo
Si quisiéramos obtener todas las mascotas que no tiene un propietario determinado, podríamos hacer esto:
SELECT *
FROM Pets
WHERE OwnerId <> 3;Resultado:
+---------+-------------+-----------+-----------+------------+ | PetId | PetTypeId | OwnerId | PetName | DOB | |---------+-------------+-----------+-----------+------------| | 3 | 2 | 2 | Scratch | 2018-10-01 | | 5 | 1 | 1 | Tweet | 2020-11-28 | | 6 | 3 | 4 | Fluffy | 2020-09-17 | | 7 | 3 | 2 | Bark | NULL | | 8 | 2 | 4 | Meow | NULL | +---------+-------------+-----------+-----------+------------+
Nuestra consulta utiliza el operador no igual a (<> ) para probar si el OwnerId la columna no es igual a 3 . La consulta devuelve todas las mascotas que no tienen el propietario número 3 como propietario.
Cuerdas
Al comparar con un valor de cadena, use comillas alrededor de la cadena. Por ejemplo, si quisiéramos obtener información sobre todas las mascotas que no se llaman Fluffy, podríamos hacer lo siguiente:
SELECT *
FROM Pets
WHERE PetName <> 'Fluffy';Resultado:
+---------+-------------+-----------+-----------+------------+ | PetId | PetTypeId | OwnerId | PetName | DOB | |---------+-------------+-----------+-----------+------------| | 2 | 3 | 3 | Fetch | 2019-08-16 | | 3 | 2 | 2 | Scratch | 2018-10-01 | | 4 | 3 | 3 | Wag | 2020-03-15 | | 5 | 1 | 1 | Tweet | 2020-11-28 | | 7 | 3 | 2 | Bark | NULL | | 8 | 2 | 4 | Meow | NULL | +---------+-------------+-----------+-----------+------------+
Múltiples Condiciones
Si tiene varias condiciones, puede usar varios operadores (ya sean los mismos operadores o diferentes).
Así:
SELECT * FROM Pets
WHERE OwnerId <> 1 AND OwnerId <> 3;Resultado:
+---------+-------------+-----------+-----------+------------+ | PetId | PetTypeId | OwnerId | PetName | DOB | |---------+-------------+-----------+-----------+------------| | 3 | 2 | 2 | Scratch | 2018-10-01 | | 6 | 3 | 4 | Fluffy | 2020-09-17 | | 7 | 3 | 2 | Bark | NULL | | 8 | 2 | 4 | Meow | NULL | +---------+-------------+-----------+-----------+------------+
Negar la Condición
Si usa el NOT operador para negar la condición proporcionada por el operador no igual a, terminará obteniendo los resultados de igual a (= ) operador:
SELECT *
FROM Pets
WHERE NOT PetName <> 'Fluffy';Resultado:
+---------+-------------+-----------+-----------+------------+ | PetId | PetTypeId | OwnerId | PetName | DOB | |---------+-------------+-----------+-----------+------------| | 1 | 2 | 3 | Fluffy | 2020-11-20 | | 6 | 3 | 4 | Fluffy | 2020-09-17 | +---------+-------------+-----------+-----------+------------+
En este caso, es mejor usar el igual a (= ) operador, así:
SELECT *
FROM Pets
WHERE PetName = 'Fluffy';
Por supuesto, esto mismo podría negarse con el NOT operador, que nos daría el mismo resultado que el igual a (<> ) el operador nos da:
SELECT *
FROM Pets
WHERE NOT PetName = 'Fluffy';Valores NULOS
Es posible que haya notado que nuestra tabla de muestra original contiene un par de NULL valores en la columna DOB.
Una columna que contiene NULL significa que no tiene valor. Esto es diferente a 0 o false , o incluso una cadena vacía.
No puede usar el operador no igual a para comparar con NULL . En realidad, esto puede depender de su DBMS y su configuración. Pero por ahora, veamos qué sucede si trato de comparar la columna DOB con NULL .
SELECT * FROM Pets
WHERE DOB <> NULL;Resultado:
(0 rows affected)
La forma de probar no NULL valores es usar IS NOT NULL .
Por lo tanto, necesitaríamos reescribir la declaración anterior de la siguiente manera.
SELECT * FROM Pets
WHERE DOB IS NOT NULL;Resultado:
+---------+-------------+-----------+-----------+------------+ | PetId | PetTypeId | OwnerId | PetName | DOB | |---------+-------------+-----------+-----------+------------| | 1 | 2 | 3 | Fluffy | 2020-11-20 | | 2 | 3 | 3 | Fetch | 2019-08-16 | | 3 | 2 | 2 | Scratch | 2018-10-01 | | 4 | 3 | 3 | Wag | 2020-03-15 | | 5 | 1 | 1 | Tweet | 2020-11-28 | | 6 | 3 | 4 | Fluffy | 2020-09-17 | +---------+-------------+-----------+-----------+------------+
Ahora obtenemos solo aquellas filas que no son NULL en el DOB columna.
Si está interesado, consulte SQL Server ANSI_NULLS Explained para ver cómo puedes cambiar la forma NULL los valores se tratan en SQL Server.
