Guía de SQL Not Equal

El operador de desigualdad (not equal), escrito <> o !=, es verdadero cuando dos valores son diferentes. Ponlo en una cláusula WHERE para dejar fuera las filas que coinciden con un valor. Los ejemplos funcionan en PostgreSQL, MySQL, SQLite y SQL Server.

Cómo usar not equal

Pon <> o != entre dos valores. Significan exactamente lo mismo. <> es la forma del estándar SQL, y != es la que usan la mayoría de los lenguajes de programación.

value1 <> value2
value1 != value2

SELECT 5 <> 3;
-- Output: true

SELECT 'apple' != 'apple';
-- Output: false

SELECT NULL <> 3;
-- Output: NULL

-- MySQL and SQLite show true and false as 1 and 0. SQL Server can't
-- select a comparison like this: use it in a WHERE clause there.

En una consulta, not equal va en la cláusula WHERE y conserva todas las filas cuyo valor es diferente:

-- Input: tickets
-- id | subject               | status
-- ---+-----------------------+--------
-- 1  | Login fails on Safari | open
-- 2  | Typo on pricing page  | closed
-- 3  | Export times out      | pending
-- 4  | Add a dark theme      | NULL

SELECT id, subject, status
FROM tickets
WHERE status <> 'closed';

-- Output:
-- id | subject               | status
-- ---+-----------------------+--------
-- 1  | Login fails on Safari | open
-- 3  | Export times out      | pending

El ticket 4 no aparece en el resultado, aunque su estado no es 'closed'. Esa es la primera regla de abajo.

Reglas que debes conocer

• Not equal nunca coincide con NULL. Comparar NULL con cualquier cosa da NULL (desconocido) en vez de verdadero, así que la cláusula WHERE descarta la fila. Agrega OR column IS NULL para conservar las filas sin valor:

-- Input: the tickets table above

SELECT id, subject, status
FROM tickets
WHERE status <> 'closed' OR status IS NULL;

-- Output:
-- id | subject               | status
-- ---+-----------------------+--------
-- 1  | Login fails on Safari | open
-- 3  | Export times out      | pending
-- 4  | Add a dark theme      | NULL

• Un NULL en una lista NOT IN elimina todas las filas. status NOT IN ('closed', 'pending') es una forma abreviada de status <> 'closed' AND status <> 'pending', así que un solo NULL en la lista vuelve desconocida toda la condición. Ten cuidado cuando la lista viene de una subconsulta sobre una columna que permite NULL:

-- Input: the tickets table above

SELECT id, status FROM tickets WHERE status NOT IN ('closed', 'pending');

-- Output:
-- id | status
-- ---+-------
-- 1  | open

SELECT id, status FROM tickets WHERE status NOT IN ('closed', NULL);

-- Output:
-- id | status
-- ---+-------
-- (0 rows)

• MySQL y SQL Server ignoran mayúsculas y minúsculas por defecto, así que ahí 'Apple' <> 'apple' es falso.

• Cuando puedas, pide lo que quieres. status <> 'closed' también coincide con cualquier estado que alguien agregue después, y como suele coincidir con la mayor parte de la tabla, la base de datos casi nunca aprovecha un índice. Si quieres decir “abierto o pendiente”, status IN ('open', 'pending') lo dice claramente.

Sintaxis alternativa

NOT (status = 'closed') es otra forma de escribir status <> 'closed', y omite los NULL de la misma manera.

Para comparar sin la sorpresa de los NULL, usa IS DISTINCT FROM, un not equal seguro ante NULL que trata NULL como un valor más (SQL Server lo agregó en 2022 y SQLite en la 3.39):

-- Input: the tickets table above

SELECT id, status FROM tickets WHERE status IS DISTINCT FROM 'closed';

-- Output:
-- id | status
-- ---+--------
-- 1  | open
-- 3  | pending
-- 4  | NULL

-- MySQL has no IS DISTINCT FROM. Use its NULL-safe <=> instead:
SELECT id, status FROM tickets WHERE NOT (status <=> 'closed');

¿Cuándo deberías usar not equal?

Usa not equal cuando una consulta deba omitir las filas que tienen un valor en particular. La mayoría de los usos caen en uno de estos cinco casos.

Excluir un estado o una categoría

Pedidos cancelados, facturas anuladas, una categoría que no manejas: <> deja fuera las filas con ese valor y conserva todo lo demás.

Omitir un registro específico

Compara un id para dejar fuera una fila o un grupo: el artículo que alguien está leyendo cuando listas los relacionados, el usuario con sesión iniciada en una lista de otros miembros o un departamento en un reporte de la empresa. Los números no necesitan comillas.

Acotar resultados con otras condiciones

Combina <> con AND y OR para excluir un valor mientras filtras por otras columnas, como pedidos que no están cancelados y superan cierto monto. Para excluir varios valores de la misma columna, usa NOT IN.

Encontrar filas donde dos columnas difieren

Not equal también funciona entre dos columnas. Compara un valor anterior con uno nuevo, una cantidad contada con la cifra registrada o una dirección de envío con una de facturación.

Conservar filas sin valor

Como <> omite los NULL, decide si las filas sin valor deben estar en el resultado. Agrega OR column IS NULL para conservarlas, o usa la sintaxis segura ante NULL de arriba.

Ejemplos reales de not equal

Sumar las facturas que cuentan

Las facturas anuladas no deberían contar en los ingresos:

-- Input: invoices
-- invoice_id | customer   | status | amount
-- -----------+------------+--------+--------
-- 1001       | Acme Corp  | paid   | 1200.00
-- 1002       | Birch & Co | void   | 450.00
-- 1003       | Acme Corp  | open   | 300.00
-- 1004       | Cobalt Ltd | paid   | 875.50

SELECT SUM(amount) AS invoiced
FROM invoices
WHERE status <> 'void';
-- Output: 2375.50

Listar artículos relacionados, sin el que se está leyendo

Un lector está en el artículo 2. Muestra los demás artículos del mismo tema:

-- Input: articles
-- id | title                | topic
-- ---+----------------------+-------
-- 1  | Indexing basics      | SQL
-- 2  | Your first JOIN      | SQL
-- 3  | Docker for beginners | DevOps
-- 4  | Window functions     | SQL

SELECT id, title
FROM articles
WHERE topic = 'SQL'
  AND id <> 2;

-- Output:
-- id | title
-- ---+-----------------
-- 1  | Indexing basics
-- 4  | Window functions

Mostrar solo productos que puedes vender

Deja fuera los productos descontinuados, los que no tienen precio y los que están agotados:

-- Input: products
-- product_name   | category     | price | stock_quantity
-- ---------------+--------------+-------+---------------
-- Desk Organizer | Office       | 18.50 | 40
-- Fax Machine    | Discontinued | 89.00 | 3
-- Gift Wrap      | Seasonal     | 0.00  | 120
-- Trail Backpack | Outdoors     | 64.00 | 0
-- Water Bottle   | Outdoors     | 12.99 | 75

SELECT product_name, category, price
FROM products
WHERE category <> 'Discontinued'
  AND price > 0
  AND stock_quantity <> 0;

-- Output:
-- product_name   | category | price
-- ---------------+----------+------
-- Desk Organizer | Office   | 18.50
-- Water Bottle   | Outdoors | 12.99

Encontrar los campos que realmente cambiaron

Un registro de auditoría guarda cada vez que se guarda algo, incluso cuando no cambió nada. Compara las dos columnas para quedarte solo con los cambios reales:

-- Input: audit_log
-- log_id | field_name | old_value   | new_value
-- -------+------------+-------------+------------
-- 1      | email      | dan@old.com | dan@new.com
-- 2      | city       | Austin      | Austin
-- 3      | plan       | free        | pro

SELECT log_id, field_name, old_value, new_value
FROM audit_log
WHERE old_value <> new_value;

-- Output:
-- log_id | field_name | old_value   | new_value
-- -------+------------+-------------+------------
-- 1      | email      | dan@old.com | dan@new.com
-- 3      | plan       | free        | pro

Si alguna de las columnas puede ser NULL, usa IS DISTINCT FROM (o NOT (old_value <=> new_value) en MySQL); si no, un valor asignado por primera vez no contará como cambio.

Recordarles a todos los que no han confirmado

Los invitados que no han respondido tienen rsvp en NULL, y son quienes más necesitan el recordatorio:

-- Input: invitations
-- guest       | email            | rsvp
-- ------------+------------------+------
-- Ines Moreau | ines@example.com | yes
-- Raj Patel   | raj@example.com  | no
-- Hana Sato   | hana@example.com | NULL
-- Leo Grant   | leo@example.com  | maybe

SELECT guest, email, rsvp
FROM invitations
WHERE rsvp <> 'yes' OR rsvp IS NULL;

-- Output:
-- guest     | email            | rsvp
-- ----------+------------------+------
-- Raj Patel | raj@example.com  | no
-- Hana Sato | hana@example.com | NULL
-- Leo Grant | leo@example.com  | maybe

Más lecturas sobre not equal

En este blog:

• Guía de SQL COALESCE: reemplaza los NULL con un valor antes de comparar
• Guía de SQL LIKE: NOT LIKE para dejar fuera texto que coincide con un patrón
• Guía de la sentencia CASE en SQL: usa comparaciones para elegir un valor
• Having vs Where en SQL: dónde va un filtro cuando agrupas filas
• Comparar dos valores en PostgreSQL: los demás operadores de comparación

Documentación oficial:

• PostgreSQL: Operadores de comparación
• MySQL: <> y !=
• SQLite: Operadores
• SQL Server: <>, != e IS DISTINCT FROM