Saltar a contenido

El operador ANY de PostgreSQL compara un valor con un conjunto de valores devueltos por una subconsulta. Se usa comúnmente en combinación con operadores de comparación como =, <, >, <=, >=, y <>.

Ésta es la sintaxis básica del operador ANY:

expresion operator ANY(subquery)

En esta sintaxis:

  • expresión es un valor que desea comparar.
  • operator es un operador de comparación que incluye =, <, >, <=, >= y <>.
  • subconsulta" es una subconsulta que devuelve un conjunto de valores con los que comparar. Debe devolver exactamente una columna.

El operador ANY devuelve true si la comparación devuelve true para al menos uno de los valores del conjunto, y false en caso contrario.

Si la subconsulta devuelve un conjunto vacío, el resultado de la comparación ANY es siempre true.

Además de la subconsulta, puede utilizar cualquier construcción que devuelva un conjunto de valores, como un ARRAY.

Tenga en cuenta que SOME es un sinónimo de ANY, lo que significa que puede utilizarlos indistintamente.

Ejemplos del operador ANY

Veamos algunos ejemplos de uso del operador ANY.

Creando una tabla de ejemplo

Primero, cree una tabla llamada employees y managers, e inserte algunos datos en ella:

CREATE TABLE employees (
    id SERIAL PRIMARY KEY,
    first_name VARCHAR(255) NOT NULL,
    last_name VARCHAR(255) NOT NULL,
    salary DECIMAL(10, 2) NOT NULL
);

CREATE TABLE managers(
    id SERIAL PRIMARY KEY,
    first_name VARCHAR(255) NOT NULL,
    last_name VARCHAR(255) NOT NULL,
    salary DECIMAL(10, 2) NOT NULL
);

INSERT INTO employees (first_name, last_name, salary) 
VALUES
('Bob', 'Williams', 45000.00),
('Charlie', 'Davis', 55000.00),
('David', 'Jones', 50000.00),
('Emma', 'Brown', 48000.00),
('Frank', 'Miller', 52000.00),
('Grace', 'Wilson', 49000.00),
('Harry', 'Taylor', 53000.00),
('Ivy', 'Moore', 47000.00),
('Jack', 'Anderson', 56000.00),
('Kate', 'Hill',  44000.00),
('Liam', 'Clark', 59000.00),
('Mia', 'Parker', 42000.00);

INSERT INTO managers(first_name, last_name, salary) 
VALUES
('John', 'Doe',  60000.00),
('Jane', 'Smith', 55000.00),
('Alice', 'Johnson',  58000.00);

En segundo lugar, recuperar los empleados con el tipo de empleado:

SELECT * FROM employees;

Salida:

 id | first_name | last_name |  salary
----+------------+-----------+----------
  1 | Bob        | Williams  | 45000.00
  2 | Charlie    | Davis     | 55000.00
  3 | David      | Jones     | 50000.00
  4 | Emma       | Brown     | 48000.00
  5 | Frank      | Miller    | 52000.00
  6 | Grace      | Wilson    | 49000.00
  7 | Harry      | Taylor    | 53000.00
  8 | Ivy        | Moore     | 47000.00
  9 | Jack       | Anderson  | 56000.00
 10 | Kate       | Hill      | 44000.00
 11 | Liam       | Clark     | 59000.00
 12 | Mia        | Parker    | 42000.00
 13 | John       | Doe       | 60000.00
 14 | Jane       | Smith     | 55000.00
 15 | Alice      | Johnson   | 58000.00
(15 rows)

En tercer lugar, recuperar los empleados con el gestor de tipo:

SELECT * FROM managers;

Salida:

 id | first_name | last_name |  type   |  salary
----+------------+-----------+---------+----------
  1 | John       | Doe       | manager | 60000.00
  2 | Jane       | Smith     | manager | 55000.00
  3 | Alice      | Johnson   | manager | 58000.00
(3 rows)

Ejemplo de uso del operador ANY con el operador =

La siguiente sentencia utiliza el operador ANY para encontrar los empleados que tienen el mismo salario que el gerente:

SELECT 
  * 
FROM 
  employees 
WHERE 
  salary = ANY (
    SELECT 
      salary 
    FROM 
      managers
  );

Devuelve una fila:

 id | first_name | last_name |  salary
----+------------+-----------+----------
  2 | Charlie    | Davis     | 55000.00
(1 row)

Cómo funciona.

Primero, ejecuta la subconsulta en el operador ANY que devuelve el salario de los empleados con tipo manager:

SELECT salary FROM managers;

Salida:

  salary
----------
 60000.00
 55000.00
 58000.00
(3 rows)Code language: CSS (css)

En segundo lugar, compara el salario de cada fila de la tabla tipo employees con los valores devueltos por la subconsulta e incluye la fila que tenga un salario igual al del conjunto (60K, 55K y 58K).

Ejemplo de uso del operador ANY con el operador >

El siguiente ejemplo utiliza el operador ANY para encontrar los empleados que tienen sueldos superiores a los sueldos del gerente:

SELECT 
  * 
FROM 
  employees 
WHERE 
  salary > ANY (
    SELECT 
      salary 
    FROM 
      managers
  );

Salida:

 id | first_name | last_name |  salary
----+------------+-----------+----------
  9 | Jack       | Anderson  | 56000.00
 11 | Liam       | Clark     | 59000.00
(2 rows)

El resultado indica que los dos empleados tienen un salario superior al del director.

  • Jack tiene un salario de 56.000 que es superior a 55.000.
  • Liam tiene un salario de 59K que es mayor que 55K y 58K.

Ejemplo de uso del operador ANY con el operador <

El siguiente ejemplo utiliza el operador ANY para encontrar los empleados que tienen salarios menores que los salarios del gerente:

SELECT 
  * 
FROM 
  employees 
WHERE 
  salary < ANY (
    SELECT 
      salary 
    FROM 
      employees
  );

Salida:

 id | first_name | last_name |  salary
----+------------+-----------+----------
  1 | Bob        | Williams  | 45000.00
  2 | Charlie    | Davis     | 55000.00
  3 | David      | Jones     | 50000.00
  4 | Emma       | Brown     | 48000.00
  5 | Frank      | Miller    | 52000.00
  6 | Grace      | Wilson    | 49000.00
  7 | Harry      | Taylor    | 53000.00
  8 | Ivy        | Moore     | 47000.00
  9 | Jack       | Anderson  | 56000.00
 10 | Kate       | Hill      | 44000.00
 12 | Mia        | Parker    | 42000.00
(11 rows)

Devuelve todas las filas con el tipo employee porque tienen un valor en la columna salary menor que cualquier valor del conjunto (55K, 58K y 60K).

Resumen

  • Utilice el operador ANY de PostgreSQL para comparar un valor con un conjunto de valores devueltos por una subconsulta.