SELECT

Una de las tareas más comunes, cuando se trabaja con la base de datos, es consultar los datos de las
tablas mediante la sentencia SELECT.

La declaración de selección tiene las siguientes cláusulas:

 Seleccione filas distintas usando el operador DISTINCT.

 Ordena las filas usando la cláusula ORDER BY.
 Filtrar filas usando la cláusula WHERE.
 Seleccionar un subconjunto de filas de una tabla usando la cláusula LIMIT o FETCH.
 Agrupar las filas en grupos utilizando la cláusula GROUP BY
 Filtrar grupos usando la cláusula HAVING.
 Únete a otras tablas usando las cláusulas INNER JOIN, LEFT JOIN, FULL OUTER JOIN, CROSS JOIN.
 Realizar operaciones de conjunto usando UNION, INTERSECT, y EXCEPT.

A continuación se ilustra la sintaxis de la declaración SELECT:

SELECT
select_list
FROM
table_name;

1. Uso de la instrucción SELECT para consultar datos de un ejemplo de columna:

SELECT
first_name
FROM
customer;

2. Uso de la instrucción SELECT para consultar datos en todas las columnas de un ejemplo de tabla:

SELECT
*
FROM
customer;

3. Uso de la declaración SELECT con expresiones de ejemplo:

SELECT
first_name || ' ' || last_name AS full_name,
email
FROM
customer;

4. Uso de la declaración SELECT con expresiones de ejemplo:

SELECT 5 * 3 AS result;

ORDER BY

La cláusula ORDER BY permite ordenar las filas devueltas de una instrucción SELECT en orden
ascendente o descendente según los criterios especificados.

A continuación se ilustra la sintaxis de la cláusula ORDER BY:

SELECT
columna_1,
columna_2
FROM
nombre_tabla
ORDER BY
columna_1 [ASC | DESC],
columna_2 [ASC | DESC];

SELECT DISTINCT

PostgreSQL SELECT DISTINCT para eliminar filas duplicadas de un conjunto de resultados devueltos
por una consulta.

SELECT
DISTINCT column_1
FROM
table_name;

WHERE

En el tutorial anterior, ha aprendido a utilizar la instrucción SELECT para consultar datos de una tabla.
¿Qué ocurre si desea consultar sólo determinadas filas de una tabla que satisfacen una determinada
condición. En este caso, debe usar la cláusula WHERE.

SELECT select_list
FROM table_name
WHERE condition;

LIMIT

PostgreSQL LIMIT es una cláusula opcional de la sentencia SELECT que devuelve un subconjunto de
filas devueltas por la consulta.

SELECT
*
FROM
table_name
LIMIT n;

La declaración devuelve n filas generadas por la consulta. Si n es cero, la consulta devuelve un

conjunto vacío. Si n es NULL, la consulta devuelve el mismo conjunto de resultados que si se omitiera
la cláusula LIMIT.

En caso de que desee omitir varias filas antes de devolver las n filas, utilice la cláusula OFFSET situada
después de la cláusula LIMIT como la siguiente declaración:

SELECT
*
FROM
table
LIMIT n OFFSET m;
FETCH

Para cumplir con el estándar SQL, PostgreSQL proporciona la cláusula FETCH para recuperar una
porción de las filas devueltas por una consulta.

OFFSET start { ROW | ROWS }

FETCH { FIRST | NEXT } [ row_count ] { ROW | ROWS } ONLY

En esta sintaxis:

 ROW y FIRST son sinónimos de ROWS y NEXT respectivamente.

 El inicio es un número entero que debe ser cero o positivo. Por defecto, es cero si no se
especifica la cláusula OFFSET. En caso de que el inicio sea mayor que el número de filas del
conjunto de resultados subyacente, no se devuelve ninguna fila;
 El recuento_de_filas es uno o superior. De forma predeterminada, el valor de row_count es uno
si no se especifica.

Debido a que el orden de las filas almacenadas en la tabla es impredecible, debe utilizar la cláusula
FETCH con la cláusula ORDER BY para que el conjunto de resultados sea coherente.

SELECT
film_id,
title
FROM
film
ORDER BY
title
OFFSET 3 ROW
FETCH FIRST 5 ROW ONLY;

IN

Utiliza el operador IN en la cláusula WHERE para comprobar si un valor coincide con algún valor de
una lista de valores. La sintaxis del operador IN es la siguiente:

value IN (value1,value2,...)

La expresión devuelve verdadero si el valor coincide con cualquier valor de la lista, es decir, el valor1 y
el valor2. La lista de valores puede ser una lista de números o cadenas o el conjunto de resultados de
una instrucción SELECT como se muestra en la siguiente consulta:

value IN (SELECT value FROM tbl_name);

SELECT
customer_id,
rental_id,
return_date
FROM
rental
WHERE
customer_id IN (1, 2)
ORDER BY
return_date DESC;
NOT IN

Puede combinar el operador IN con el operador NOT para seleccionar filas cuyos valores no coincidan
con los de la lista. La siguiente afirmación encuentra que todos los alquileres con el ID de cliente no
son 1 o 2.

SELECT
customer_id,
rental_id,
return_date
FROM
rental
WHERE
customer_id NOT IN (1, 2);

IN CON UNA SUBCONSULTA

SELECT
first_name,
last_name
FROM
customer
WHERE
customer_id IN (
SELECT
customer_id
FROM
rental
WHERE
CAST (return_date AS DATE) = '2005-05-27'
);

BETWEEN

Se utiliza el operador BETWEEN para comparar un valor con un rango de valores. A continuación se
ilustra la sintaxis del operador BETWEEN:

value BETWEEN low AND high;

Puede reescribir el operador BETWEEN usando los operadores mayor o igual ( >=) o menor o igual
( <=) como la siguiente declaración:

value >= low and value <= high

Si quiere comprobar si un valor está fuera de rango, combine el operador NOT con el operador
BETWEEN de la siguiente manera:

value NOT BETWEEN low AND high;

A menudo se utiliza el operador BETWEEN en la cláusula WHERE de una declaración de SELECCIONAR,

INSERTAR, ACTUALIZAR o BORRAR.

Si quiere comprobar un valor contra los rangos de fechas, debe usar la fecha literal en formato ISO
8601, es decir, AAAA-MM-DD. Por ejemplo, para obtener el pago cuya fecha de pago está entre 2007-
02-07 y 2007-02-15, se utiliza la siguiente consulta:
SELECT
customer_id,
payment_id,
amount,
payment_date
FROM
payment
WHERE
payment_date BETWEEN '2007-02-07'
AND '2007-02-15';

LIKE

Supongamos que el gerente de la tienda te pide que encuentres un cliente que no recuerda el nombre
exactamente. Sólo recuerda que el nombre de pila del cliente comienza con algo como Jen. ¿Cómo
encuentras al cliente exacto al que el gerente de la tienda está preguntando? Puedes encontrar al
cliente en la tabla de clientes mirando la columna del nombre para ver si hay algún valor que
comience con Jen. Es algo tedioso porque hay muchas filas en la tabla de clientes.

Afortunadamente, puedes usar el operador PostgreSQL como la siguiente consulta:

SELECT
first_name,
last_name
FROM
customer
WHERE
first_name LIKE 'Jen%';

Construye un patrón combinando una cadena con caracteres comodín y utiliza el operador LIKE o NOT
LIKE para encontrar las coincidencias. PostgreSQL proporciona dos caracteres comodín:

 Porcentaje ( %) para hacer coincidir cualquier secuencia de caracteres.

 Subrayado ( _) para coincidir con cualquier carácter individual.

La sintaxis del operador PostgreSQL LIKE es la siguiente:

string LIKE pattern

string NOT LIKE pattern

SELECT first_name, last_name

FROM customer
WHERE first_name LIKE '_her%';

PostgreSQL proporciona el operador ILIKE que actúa como el operador LIKE. Además, el operador
ILIKE coincide con el valor de caso insensible. Véase el siguiente ejemplo:

SELECT
first_name,
last_name
FROM
customer
WHERE
first_name ILIKE 'BAR%';
NULL

En el mundo de las bases de datos, NULL significa información perdida o no aplicable. NULL no es un
valor, por lo tanto, no se puede comparar con ningún valor como un número o una cadena. La
comparación de NULL con un valor siempre dará como resultado NULL, lo que significa un resultado
desconocido.

Aunque hay un NULL en la columna telefónica, la expresión NULL = NULL devuelve false. Esto se debe
a que NULL no es igual a ningún valor, ni siquiera a sí mismo.

Para comprobar si un valor es NULL o no, se utiliza el operador IS NULL:

value IS NULL

SELECT
id,
first_name,
last_name,
email,
phone
FROM
contacts
WHERE
phone IS NULL;

Para comprobar si un valor no es NULL, se utiliza el operador IS NOT NULL

value IS NOT NULL

Alias

Un alias PostgreSQL asigna a una tabla o a una columna un nombre temporal en una consulta. Los
alias sólo existen durante la ejecución de la consulta.

SELECT column_name AS alias_name

FROM table;

SELECT column_name alias_name

FROM table;

SELECT
first_name || ' ' || last_name AS full_name
FROM
customer
ORDER BY
full_name;

Alias de la tabla

SELECT
column_list
FROM
table_name AS alias_name;
JOIN

La unión PostgreSQL se utiliza para combinar las columnas de una (auto-unión) o más tablas en base a
los valores de las columnas comunes entre las tablas. Las columnas comunes suelen ser las columnas
clave primarias de la primera tabla y las columnas clave externas de la segunda tabla.

PostgreSQL admite inner join, left join, right join, full outer join, cross join, natural join, y un tipo
especial de unión llamada self-join.

GROUP BY

La cláusula GROUP BY divide las filas devueltas de la declaración SELECT en grupos. Para cada grupo,
se puede aplicar una función agregada, por ejemplo, SUM() para calcular la suma de elementos o
COUNT() para obtener el número de elementos de los grupos.

SELECT
column_1,
column_2,
aggregate_function(column_3)
FROM
table_name
GROUP BY
column_1,
column_2;

Usando el ejemplo de la función PostgreSQL GROUP BY con SUM()

La cláusula GROUP BY es útil cuando se utiliza junto con una función agregada. Por ejemplo, para
obtener el importe que se ha pagado a un cliente, se utiliza la cláusula GROUP BY para dividir la tabla
de pagos en grupos; para cada grupo, se calculan los importes totales mediante la función SUM():

SELECT
 customer_id,
SUM (amount)
FROM
payment
GROUP BY
customer_id;

Para contar el número de transacciones de pago que cada personal ha estado procesando, se agrupan
las filas de la tabla de pagos en función de staff_id y se utiliza la función COUNT() para obtener el
número de transacciones como se muestra en la siguiente consulta:

SELECT
staff_id,
COUNT (payment_id)
FROM
payment
GROUP BY
staff_id;

El siguiente ejemplo utiliza múltiples columnas en la cláusula GROUP BY:

SELECT
customer_id,
staff_id,
SUM(amount)
FROM
payment
GROUP BY
staff_id,
customer_id
ORDER BY
customer_id;

La fecha_de_pago es una columna de marca de tiempo. Para agrupar los pagos por fechas, utilice la
función DATE() para convertir primero las marcas de tiempo en fechas y luego agrupar los pagos por
la fecha de resultado:

SELECT
DATE(payment_date) paid_date,
SUM(amount) sum
FROM
payment
GROUP BY
DATE(payment_date);

HAVING
A menudo utilizamos la Cláusula HAVING junto con la cláusula GROUP BY para filtrar las filas de grupo
que no satisfacen una condición específica.

SELECT
column_1,
aggregate_function (column_2)
FROM
tbl_name
GROUP BY
column_1
HAVING
condition;

La cláusula HAVING establece la condición para las filas de grupo creadas por la cláusula GROUP BY
después de que se aplique la cláusula GROUP BY, mientras que la cláusula WHERE establece la
condición para las filas individuales antes de que se aplique la cláusula GROUP BY. Esta es la principal
diferencia entre las cláusulas HAVING y WHERE.

SELECT
customer_id,
SUM (amount)
FROM
payment
GROUP BY
customer_id
HAVING
SUM (amount) > 200;

Usando HAVING con la funcion COUNT()

SELECT
store_id,
COUNT (customer_id)
FROM
customer
GROUP BY
store_id
HAVING
COUNT (customer_id) > 300;

UNION

El operador UNION combina conjuntos de resultados de dos o más declaraciones SELECT en un único
conjunto de resultados. A continuación se ilustra la sintaxis del operador UNION que combina
conjuntos de resultados de dos consultas:

SELECT
 column_1,
column_2
FROM
tbl_name_1
UNION
SELECT
column_1,
column_2
FROM
tbl_name_2;

Las siguientes son las normas que se aplican a las consultas:

 Ambas consultas deben devolver el mismo número de columnas.

 Las columnas correspondientes en las consultas deben tener tipos de datos compatibles.

El operador UNION elimina todas las filas duplicadas a menos que se utilice UNION ALL.

UNIÓN con ORDER BY ejemplo

SELECT *
FROM
sales2007q1
UNION ALL
SELECT *
FROM
sales2007q2
ORDER BY
name ASC,
amount DESC;

INTERSET

Al igual que los operadores UNION y EXCEPT, el operador PostgreSQL INTERSECT combina los
conjuntos de resultados de dos o más instrucciones SELECT en un único conjunto de resultados. El
operador INTERSECT devuelve cualquier fila que esté disponible en ambos conjuntos de resultados o
devuelta por ambas consultas.

SELECT
column_list
FROM
A
INTERSECT
SELECT
column_list
FROM
B;

Para utilizar el operador INTERSECT, las columnas que aparecen en las declaraciones SELECT deben
seguir las reglas siguientes:

El número de columnas y su orden en las cláusulas SELECT debe ser el mismo.

Los tipos de datos de las columnas deben ser compatibles.

Para clasificar el conjunto de resultados devueltos por el operador INTERSECT, se coloca la cláusula
ORDER BY al final de la declaración, no al final de cada declaración SELECT.

SELECT
employee_id
FROM
keys
INTERSECT
SELECT
employee_id
FROM
hipos
ORDER BY employee_id;

EXCEPT

Al igual que los operadores UNION e INTERSECT, el operador EXCEPT devuelve las filas comparando
los conjuntos de resultados de dos o más consultas.

El operador EXCEPT devuelve filas distintas de la primera consulta (izquierda) que no están en la salida
de la segunda consulta (derecha). A continuación se ilustra la sintaxis del operador EXCEPT.

SELECT column_list
FROM A
WHERE condition_a
EXCEPT
SELECT column_list
FROM B
WHERE condition_b;

Para combinar las consultas usando el operador EXCEPTO, debe obedecer las siguientes reglas:

El número de columnas y su orden debe ser el mismo en las dos consultas.

Los tipos de datos de las respectivas columnas deben ser compatibles.

SELECT
film_id,
title
FROM
film
EXCEPT
SELECT
DISTINCT inventory.film_id,
title
FROM
inventory
INNER JOIN film ON film.film_id = inventory.film_id
ORDER BY title;

GROUPING SETS
PostgreSQL proporciona el GROUPING SETS que es la subcláusula de la cláusula GROUP BY.

El GROUPING SETS permite definir múltiples conjuntos de agrupación en la misma consulta. La

sintaxis general de los GROUPING SETS es la siguiente:

SELECT
c1,
c2,
aggregate_function(c3)
FROM
table_name
GROUP BY
GROUPING SETS (
(c1, c2),
(c1),
(c2),
()
);

CUBE

PostgreSQL CUBE es una subcláusula de la cláusula GROUP BY. El CUBE permite generar múltiples
conjuntos de agrupación.

SELECT
c1,
c2,
c3,
aggregate (c4)
FROM
table_name
GROUP BY
CUBE (c1, c2, c3);

ROLLUP

A diferencia de la subcláusula CUBE, ROLLUP no genera todos los conjuntos de agrupación posibles
basados en las columnas especificadas. Sólo hace un subconjunto de ellos.

El ROLLUP asume una jerarquía entre las columnas de entrada y genera todos los conjuntos de
agrupación que tienen sentido considerando la jerarquía. Esta es la razón por la que ROLLUP se utiliza
a menudo para generar los subtotales y el total general de los informes.

SELECT
c1,
c2,
c3,
aggregate(c4)
FROM
table_name
GROUP BY
ROLLUP (c1, c2, c3);

El uso mas comun de ROLLUP es en las evaluaciones de las fechas

SELECT
EXTRACT (YEAR FROM rental_date) y,
EXTRACT (MONTH FROM rental_date) M,
EXTRACT (DAY FROM rental_date) d,
COUNT (rental_id)
FROM
rental
GROUP BY
ROLLUP (
EXTRACT (YEAR FROM rental_date),
EXTRACT (MONTH FROM rental_date),
EXTRACT (DAY FROM rental_date)
);

SUBCONSULTA

Una subconsulta es una consulta anidada dentro de otra consulta como SELECCIONAR, INSERTAR,
BORRAR y ACTUALIZAR. En este tutorial, nos centramos sólo en la declaración SELECT.

Para construir una subconsulta, ponemos la segunda consulta entre paréntesis y la usamos en la
cláusula WHERE como expresión:

SELECT
film_id,
title,
rental_rate
FROM
film
WHERE
rental_rate > (
SELECT
AVG (rental_rate)
FROM
film
);

La consulta dentro de los paréntesis se llama subconsulta o consulta interna. La consulta que contiene
la subconsulta se conoce como una consulta externa.

PostgreSQL ejecuta la consulta que contiene una subconsulta en la siguiente secuencia:

Primero, ejecuta la subconsulta.

Segundo, obtiene el resultado y lo pasa a la consulta externa.
Tercero, ejecuta la consulta externa.

Subconsulta PostgreSQL con operador IN

Una subconsulta puede devolver cero o más filas. Para utilizar esta subconsulta, se utiliza el operador
IN en la cláusula WHERE.

Por ejemplo, para obtener películas que tengan la fecha de devolución entre 2005-05-29 y 2005-05-
30, se usa la siguiente consulta:

SELECT
film_id,
 title
FROM
film
WHERE
film_id IN (
SELECT
inventory.film_id
FROM
rental
INNER JOIN inventory ON inventory.inventory_id = rental.inventory_id
WHERE
return_date BETWEEN '2005-05-29'
AND '2005-05-30'
);

Subconsulta PostgreSQL con el operador EXISTS

EXISTS subquery

Una subconsulta puede ser una entrada del operador EXISTS. Si la subconsulta devuelve cualquier fila,
el operador EXISTS devuelve true. Si la subconsulta no devuelve ninguna fila, el resultado del
operador EXISTS es falso.

El operador EXISTS sólo se preocupa por el número de filas devueltas por la subconsulta, no por el
contenido de las filas, por lo que la convención común de codificación del operador EXISTS es la
siguiente:

EXISTS (SELECT 1 FROM tbl WHERE condition);

SELECT
first_name,
last_name
FROM
customer
WHERE
EXISTS (
SELECT
1
FROM
payment
WHERE
payment.customer_id = customer.customer_id
);

ANY

El operador PostgreSQL ANY compara un valor con un conjunto de valores devueltos por una
subconsulta. A continuación se ilustra la sintaxis del operador ANY:

operador de expresión ANY(subconsulta)

En esta sintaxis:

La subconsulta debe devolver exactamente una columna.

El operador ANY debe ser precedido por uno de los siguientes operadores de comparación =, <=, >, <,
> y <>
El operador ANY devuelve true si algún valor de la subconsulta cumple la condición, de lo contrario,
devuelve false.

SELECT title
FROM film
WHERE length >= ANY(
SELECT MAX( length )
FROM film
INNER JOIN film_category USING(film_id)
GROUP BY category_id );

ALL

El operador PostgreSQL ALL permite consultar los datos comparando un valor con una lista de valores
devueltos por una subconsulta.

A continuación se ilustra la sintaxis del operador ALL:

operador_comparación ALL (subconsulta)

En esta sintaxis:

El operador ALL debe ser precedido por un operador de comparación como igual (=), no igual (!=),
mayor que (>), mayor o igual a (>=), menor que (<), y menor o igual a (<=).
El operador ALL debe ser seguido por una subconsulta que también debe estar rodeada por los
paréntesis.

SELECT
film_id,
title,
length
FROM
film
WHERE
length > ALL (
SELECT
ROUND(AVG (length),2)
FROM
film
GROUP BY
rating
)
ORDER BY
length;