Una de las tareas más comunes, cuando se trabaja con la base de datos, es recuperar los datos de las tablas utilizando la declaración SELECT.

La declaración SELECT es una de las declaraciones más complejas en PostgreSQL. Tiene muchas cláusulas que se puede utilizar para formar una consulta flexible.

Debido a su complejidad, lo dividiremos en muchos ejercicios más cortos y fáciles de entender para que puedas aprender sobre cada cláusula más rápido.

La declaración SELECT tiene las siguientes cláusulas:

Seleccionar filas distintas usando el operador DISTINCT.
Ordenar las filas usando la cláusula ORDER BY.
Filtrar filas usando la cláusula WHERE.
Seleccione un subconjunto de filas de una tabla usando la cláusula LIMIT o FETCH.
Agrupar filas en grupos usando la cláusula GROUP BY.
Grupos de filtro utilizando la cláusula HAVING
Unirse a otras tablas usando uniones con las cláusulas INNER JOIN, LEFT JOIN, FULL OUTER JOIN, CROSS JOIN.
Realizar operaciones establecidas mediante UNION, INTERSECT, y EXCEPT.

En este tutorial, vas a enfocarte en las cláusulas SELECT y FROM.

Sintaxis de declaración PostgreSQL SELECT¶

Comenzamos con la forma básica de la declaración SELECT que recupera los datos de una sola tabla.

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

SELECT
   select_list
FROM
   table_name;

En esta sintaxis:

Primero, especifique una lista de selección que puede ser una columna o una lista de columnas en una tabla de la que desea recuperar datos. Si especifica una lista de columnas, necesita colocar una coma (,) entre dos columnas para separarlas. Si desea seleccionar datos de todas las columnas de la tabla, puede utilizar un asterisco (*) abreviatura en lugar de especificar todos los nombres de la columna. La select_list también puede contener expresiones o valores literales.
En segundo lugar, proporcione el nombre de la tabla desde la que desea consultar los datos después de la palabra clave FROM.

La cláusula FROM es opcional. Si no estás consultando datos de ninguna tabla, puedes omitir la cláusula FROM en la declaración SELECT.

PostgreSQL evalúa la cláusula FROM antes de la cláusula SELECT en la declaración del SELECT:

Tenga en cuenta que las palabras clave SQL son insensibles a mayúsculas/minúsculas. Significa que SELECT es equivalente a select a Select. Por convención, usaremos todas las palabras clave SQL en mayúsculas para hacer las consultas más fáciles de leer.

Ejemplos de PostgreSQL SELECT¶

Exploremos algunos ejemplos de uso de la declaración SELECT.

Usaremos la tabla customer en la BD dvdrental para la demostración.

customer table

Primero, conéctese al servidor PostgreSQL usando el usuario postgres:

psql -U postgres

Se le pedirá que introduzca una contraseña para el usuario postgres. Después de introducir la contraseña correctamente, estará conectado al servidor PostgreSQL:

postgres=#

En segundo lugar, cambie la base de datos actual a dvdrental:

\c dvdrental

Tercero, ejecutar la consulta en los siguientes ejemplos.

Usar la declaración `SELECT` para consultar los datos de una columna¶

Este ejemplo utiliza la declaración SELECT para encontrar los nombres de los primeros nombres de todos los clientes de la tabla customer:

SELECT first_name FROM customer;

Aquí está la salida parcial:

 first_name
-------------
 Jared
 Mary
 Patricia
 Linda
 Barbara
...

Observe que añadimos un punto y coma (;) al final de la declaración SELECT. El punto y coma no es parte de la declaración SQL; más bien, sirve como señal a PostgreSQL indicando la conclusión de una declaración SQL. Además, se utilizan los (;) para separar dos o más declaraciones SQL.

Ejemplo.- Uso de SELECT para consultar datos de varias columnas¶

La siguiente consulta utiliza SELECT para recuperar el nombre, apellido y correo electrónico de los clientes de la tabla customer:

SELECT
   first_name,
   last_name,
   email
FROM
   customer;

Salida parcial:

 first_name  |  last_name   |                  email
-------------+--------------+------------------------------------------
 Jared       | Ely          | jared.ely@sakilacustomer.org
 Mary        | Smith        | mary.smith@sakilacustomer.org
 Patricia    | Johnson      | patricia.johnson@sakilacustomer.org
...

La salida muestra tres columnas correspondientes de nombre, apellido y correo electrónico.

Ejemplo.- Uso de SELECT para consultar datos de todas las columnas de una tabla¶

La siguiente consulta utiliza la la declaración SELECT * para recuperar los datos de todas las columnas de la tabla customer:

SELECT * FROM customer;

Salida parcial:

 customer_id | store_id | first_name  |  last_name   |                  email                   | address_id | activebool | create_date |       last_update       | active
-------------+----------+-------------+--------------+------------------------------------------+------------+------------+-------------+-------------------------+--------
         524 |        1 | Jared       | Ely          | jared.ely@sakilacustomer.org             |        530 | t          | 2006-02-14  | 2013-05-26 14:49:45.738 |      1
           1 |        1 | Mary        | Smith        | mary.smith@sakilacustomer.org            |          5 | t          | 2006-02-14  | 2013-05-26 14:49:45.738 |      1
           2 |        1 | Patricia    | Johnson      | patricia.johnson@sakilacustomer.org      |          6 | t          | 2006-02-14  | 2013-05-26 14:49:45.738 |      1
...

En este ejemplo, usamos un asterisco (*) en la cláusula SELECT, que sirve de abreviatura para "todas las columnas".

En lugar de enumerar todas las columnas en la cláusula SELECT individualmente, podemos utilizar el asterisco (*) para hacer la consulta más corta.

Sin embargo, el uso del asterisco (*) en la declaración SELECT se considera una mala práctica cuando se incrustan declaraciones de SQL en el código de solicitud, como Python, Java o PHP por las siguientes razones:

Rendimiento de la base de datos.- Supongamos que se tiene una tabla con muchas columnas y datos sustanciales, la delcaración SELECT con el asterisco (*) seleccionará los datos de todas las columnas de la tabla, potencialmente recuperando más datos de los requeridos para la aplicación.
Rendimiento de la aplicación. La recuperación de datos innecesarios aumenta el tráfico entre el servidor PostgreSQL y el servidor de la aplicación. En consecuencia, esto puede resultar en tiempos de respuesta más lentos y una escalabilidad reducida para sus aplicaciones.

Por estas razones, se recomienda especificar explícitamente los nombres de las columnas requeridas en la cláusula SELECT siempre que sea posible. Esto garantiza que sólo los datos necesarios se recuperen de la base de datos, contribuyendo a consultas más eficientes y optimizadas.

La abreviatura (*) debe reservarse exclusivamente para las consultas ad-hoc que examinan los datos de la base de datos.

Ejemplo.- Uso de SELECT con expresiones¶

El siguiente ejemplo utiliza el SELECT para devolver los nombres completos y correos electrónicos de todos los clientes de la tabla customer:

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

Producto:

       ?column?        |                  email
-----------------------+------------------------------------------
 Jared Ely             | jared.ely@sakilacustomer.org
 Mary Smith            | mary.smith@sakilacustomer.org
 Patricia Johnson      | patricia.johnson@sakilacustomer.org
...

En este ejemplo, utilizamos el operador de || para concatenar el primer nombre, el espacio y el apellido de cada cliente.

Observa que la primera columna de la salida no tiene un nombre (?column?). Para asignar un nombre a una columna temporalmente en la consulta, se puede utilizar un alias de columna:

expression AS column_alias

La palabra clave AS es opcional. Por lo tanto, se puede utilizar una sintaxis más corta:

expression column_lias

Por ejemplo, se puede asignar una columna alias full-name a la primera columna de la consulta de la siguiente manera:

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

Salida:

       full_name       |                  email
-----------------------+------------------------------------------
 Jared Ely             | jared.ely@sakilacustomer.org
 Mary Smith            | mary.smith@sakilacustomer.org
 Patricia Johnson      | patricia.johnson@sakilacustomer.org
...

Uso de SQL SELECT sin una cláusula FROM¶

La cláusula FROM de la declaración SELECT es opcional. Por lo tanto, se puedes omitirlo.

Típicamente, se usa la cláusula SELECT con una función para recuperar el resultado de la función. Por ejemplo:

SELECT NOW();

En este ejemplo, utilizamos la función NOW() en la declaración SELECT que devuelve la fecha y hora actuales del servidor PostgreSQL.

Resumen¶

Utiliza la declaración SELECT ... FROM para recuperar los datos de una tabla.
PostgreSQL evalúa primero la declaración FROM en la cláusula SELECT.
Utiliza un alias de columna para asignar un nombre temporal a una columna o a una expresión en una consulta.
En PostgreSQL, la cláusula FROM es opcional.