# SQL `NOT`: búsquedas precisas con criterios de exclusión

`NOT` es uno de los operadores lógicos de SQL y permite **filtrar de forma precisa y eficaz resultados de búsquedas mediante el procedimiento de exclusión**. Al utilizar el operador `NOT` para excluir datos que cumplen determinadas condiciones, los resultados se limitan a la información relevante.

## ¿Qué es el operador SQL `NOT`?

SQL NOT, junto con SQL `AND` y [SQL OR](https://www.ionos.mx/digitalguide/servidores/configuracion/sql-like/), es uno de los [operadores de SQL](https://www.ionos.mx/digitalguide/servidores/configuracion/sql-operators/) lógicos con los que puedes formular condiciones y criterios al realizar consultas de datos. Mientras que los operadores `AND` y `OR` filtran conjuntos de datos que cumplen todas o al menos una de las condiciones especificadas, **el operador `NOT` se basa en el procedimiento de exclusión**, pues excluye en tu resultado toda la información en los registros seleccionados que *no* cumpla una condición determinada.

El operador SQL `NOT` suele utilizarse en combinación con [SQL SELECT](https://www.ionos.mx/digitalguide/servidores/configuracion/sql-select/), [SQL WHERE](https://www.ionos.mx/digitalguide/servidores/configuracion/sql-where/) y SQL `HAVING`. Para hacer una búsqueda lo más precisa posible, también puedes **combinar el operador `NOT` con los operadores `AND` y `OR`**. De esta manera, puedes filtrar los resultados irrelevantes que no cumplen las condiciones específicas (`AND`) o que no cumplen al menos una de las condiciones mencionadas (`OR`).

### Diferencia entre SQL `NOT`, `AND` y `OR`

A continuación, te explicamos las diferencias clave entre los operadores `NOT`, `AND` y `OR`:

<table>
  <thead>
    <tr>
      <th>SQL `NOT`</th>
      <th>SQL `AND`</th>
      <th>SQL `OR`</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>Solo devuelve conjuntos de datos que no cumplen una condición definida</td>
      <td>Devuelve conjuntos de datos que cumplen todos los criterios de búsqueda predefinidos</td>
      <td>Devuelve toda la información que cumple al menos una de las condiciones definidas</td>
    </tr>
    <tr>
      <td>Niega una condición irrelevante para la búsqueda</td>
      <td>Combina condiciones para limitar la búsqueda a información que cumpla varios criterios de búsqueda</td>
      <td>Amplía los resultados de búsqueda a datos que cumplan uno de varios criterios</td>
    </tr>
  </tbody>
</table>

Consejo ¿Te gustaría saber lo básico sobre [SQL](https://www.ionos.mx/digitalguide/servidores/know-how/que-es-sql/) para poder comenzar a trabajar con este lenguaje de programación? En ese caso, no dudes en consultar los ejemplos de nuestra [introducción a SQL](https://www.ionos.mx/digitalguide/servidores/configuracion/sql-introduccion-con-ejemplos/).

## La sintaxis del operador `NOT`

La sintaxis simple de `NOT` tiene este aspecto:

```sql
SELECT  *
FROM tabla
WHERE  NOT  (condición)
```

Se utilizan estos parámetros:

- `SELECT`: selecciona las columnas que son relevantes para tu búsqueda. Al utilizar un asterisco `*`, puedes buscar en toda la tabla seleccionada, incluidas todas las columnas asociadas. También puedes especificar columnas individuales con su respectiva clave primaria o foránea.
- `FROM`: define la tabla que quieres buscar.
- `WHERE`: define condiciones mediante operadores como SQL `NOT` para limitar la consulta.
- `NOT`: en combinación con `WHERE`, establece la negación de una condición que los resultados de la búsqueda no deben cumplir.

Para precisar la consulta, puedes combinar con `AND` o `OR`.

### SQL `NOT` combinado con `AND`

Al combinarlo con `AND`, se devuelven los **registros que no cumplan ambas condiciones**.

```sql
SELECT  *
FROM  tabla
WHERE  NOT  (condición1  AND  condición2)
```

### SQL `NOT` combinado con `OR`

Al combinarlo con `OR`, se obtienen resultados que **excluyen los registros que cumplen al menos una de las condiciones**.

```sql
SELECT  *
FROM  tabla
WHERE  NOT  (condición1  OR  condición2)
```

## Posibles usos del operador `NOT`

Las posibilidades de uso de `NOT` al realizar consultas y búsquedas son **casi ilimitadas**. Por ejemplo, puedes hacer lo siguiente:

- excluir datos de clientes, pedidos o productos según región, año, categoría, precio o características;
- ignorar registros que tengan valores inválidos o a los que les falten valores;
- filtrar datos financieros que no cumplan con ciertos criterios de transacción;
- excluir datos de empleados que no pertenezcan a un departamento específico;
- filtrar a candidatos que no tengan una cualificación determinada.

## Ejemplos de uso del operador SQL `NOT`

La búsqueda con el operador `NOT` puede variar enormemente dependiendo de cómo definas la condición con la cláusula `WHERE`, el operador `NOT` y otros operadores opcionales. Te lo mostramos en **tres ejemplos de aplicación**.

### Exclusión de empleados por región

Imagina que en la tabla “Empleados” quieres mostrar solo información sobre empleados que no viven en Estados Unidos. Para ello, estableces la condición usando la columna “país”, la cláusula `WHERE`, el operador `NOT` y el operador de comparación `=` de la siguiente manera:

```sql
SELECT  *
FROM  empleados
WHERE  NOT  (país  =  'Estados Unidos')
```

De forma similar, si en una tabla de productos quieres mostrar únicamente **productos que ya no están en stock**, debes proceder de esta forma:

```sql
SELECT  *
FROM  productos
WHERE  NOT  (stock  >  0)
```

### Filtrar grupos de clientes

Imagina que tienes la tabla “Clientes” y debes buscar un grupo de clientes determinado que **no cumpla condiciones predefinidas**. En este ejemplo, no se debe tener menos de 30 años ni vivir en Nueva York, por lo que, además de `NOT`, también se utilizan operadores de comparación y el operador `AND`.

```sql
SELECT  *
FROM  clientes
WHERE  NOT  (edad  <  30  AND  ciudad  =  'Nueva York')
```

### Filtrar cualificaciones que faltan en una candidatura

Imagina que tienes la tabla “Candidatos” y necesitas excluir los resultados que no cumplan **cualificaciones específicas** como “grado” o “experiencia”. La búsqueda quedaría así:

```sql
SELECT  *
FROM  candidatos
WHERE  NOT  (titulación  =  ´grado´  OR  experiencia  <  3)
```

## Alternativas a SQL `NOT`

El operador `NOT` se caracteriza por negar criterios de búsqueda y no existe una alternativa que cuente con esa misma función. Sin embargo, SQL `NOT` es versátil y se puede combinar para realizar **consultas precisas** con varios [comandos SQL](https://www.ionos.mx/digitalguide/servidores/configuracion/comandos-sql/). Algunos de ellos son [SQL JOIN](https://www.ionos.mx/digitalguide/servidores/configuracion/sql-joins/) o funciones de agregación de SQL `HAVING` como [SQL SUM](https://www.ionos.mx/digitalguide/servidores/configuracion/sql-sum/) o `AVG`, operadores de comparación como `=` o `>`, así como comandos y operadores como [SQL LIKE](https://www.ionos.mx/digitalguide/servidores/configuracion/sql-like/). Para limitar o ampliar el procedimiento de exclusión a múltiples condiciones, también pueden emplearse los operadores lógicos `AND` y `OR`.


This is a markdown version of: [https://www.ionos.mx/digitalguide/servidores/configuracion/sql-not/](https://www.ionos.mx/digitalguide/servidores/configuracion/sql-not/) for AI/LLM consumption.