En este laboratorio, aprenderá cómo realizar el filtrado de datos y consultas simples en PostgreSQL. Comenzará conectándose a una base de datos PostgreSQL y creando una tabla de ejemplo employees con datos.
El laboratorio luego lo guiará a través del uso de la cláusula WHERE para filtrar datos basados en condiciones específicas, empleando LIKE para la coincidencia de patrones (pattern matching), ordenando los resultados con ORDER BY y limitando el número de filas devueltas usando LIMIT y OFFSET.
Este es un Guided Lab, que proporciona instrucciones paso a paso para ayudarte a aprender y practicar. Sigue las instrucciones cuidadosamente para completar cada paso y obtener experiencia práctica. Los datos históricos muestran que este es un laboratorio de nivel principiante con una tasa de finalización del 94%. Ha recibido una tasa de reseñas positivas del 100% por parte de los estudiantes.
Filtrar Datos con la Cláusula WHERE
En este paso, aprenderemos cómo usar la cláusula WHERE en PostgreSQL para filtrar datos basados en condiciones específicas. La cláusula WHERE es una herramienta poderosa que le permite recuperar solo las filas que cumplen con sus criterios.
Antes de comenzar, conectémonos a la base de datos PostgreSQL. Abra una terminal en su VM de LabEx. Puede usar la terminal Xfce predeterminada.
Primero, conéctese a la base de datos PostgreSQL usando el comando psql. Nos conectaremos a la base de datos postgres con el usuario postgres. Es posible que necesite usar sudo para ejecutar el comando.
sudo -u postgres psql
Ahora debería ver el prompt de PostgreSQL (postgres=#).
Ahora, creemos una tabla de ejemplo llamada employees e insertemos algunos datos en ella. Esta tabla almacenará información de los empleados, incluyendo su ID, nombre, departamento y salario.
CREATE TABLE employees (
id SERIAL PRIMARY KEY,
name VARCHAR(50),
department VARCHAR(50),
salary INTEGER
);
INSERT INTO employees (name, department, salary) VALUES
('Alice Smith', 'Sales', 60000),
('Bob Johnson', 'Marketing', 75000),
('Charlie Brown', 'Sales', 55000),
('David Lee', 'Engineering', 90000),
('Eve Wilson', 'Marketing', 80000),
('Frank Miller', 'Engineering', 95000);
Para verificar que la tabla se haya creado y poblado correctamente, ejecute la siguiente consulta SQL:
SELECT * FROM employees;
Debería ver una salida similar a esta:
id | name | department | salary
----+-----------------+-------------+--------
1 | Alice Smith | Sales | 60000
2 | Bob Johnson | Marketing | 75000
3 | Charlie Brown | Sales | 55000
4 | David Lee | Engineering | 90000
5 | Eve Wilson | Marketing | 80000
6 | Frank Miller | Engineering | 95000
(6 rows)
Ahora, usemos la cláusula WHERE para filtrar los datos. Supongamos que queremos recuperar solo los empleados que trabajan en el departamento de 'Sales' (Ventas). Podemos usar la siguiente consulta:
SELECT * FROM employees WHERE department = 'Sales';
Esta consulta devolverá solo las filas donde la columna department sea igual a 'Sales'. La salida debería ser:
id | name | department | salary
----+-----------------+------------+--------
1 | Alice Smith | Sales | 60000
3 | Charlie Brown | Sales | 55000
(2 rows)
También puede usar otros operadores de comparación en la cláusula WHERE, como >, <, >=, <= y <>. Por ejemplo, para recuperar empleados con un salario mayor a 70000, puede usar la siguiente consulta:
SELECT * FROM employees WHERE salary > 70000;
La salida debería ser:
id | name | department | salary
----+-----------------+-------------+--------
2 | Bob Johnson | Marketing | 75000
4 | David Lee | Engineering | 90000
5 | Eve Wilson | Marketing | 80000
6 | Frank Miller | Engineering | 95000
(4 rows)
También puede combinar múltiples condiciones usando operadores lógicos como AND y OR. Por ejemplo, para recuperar empleados que trabajan en el departamento de 'Sales' y tienen un salario mayor a 58000, puede usar la siguiente consulta:
SELECT * FROM employees WHERE department = 'Sales' AND salary > 58000;
La salida debería ser:
id | name | department | salary
----+---------------+------------+--------
1 | Alice Smith | Sales | 60000
(1 row)
Finalmente, salga del shell psql:
\q
Esto lo devolverá a la terminal del usuario labex.
Usar LIKE para la Coincidencia de Patrones
En este paso, aprenderemos cómo usar el operador LIKE en PostgreSQL para la coincidencia de patrones (pattern matching). El operador LIKE le permite buscar datos que coincidan con un patrón específico, lo cual es particularmente útil cuando no conoce el valor exacto que está buscando.
Primero, conectémonos a la base de datos PostgreSQL. Abra una terminal en su VM de LabEx.
Conéctese a la base de datos PostgreSQL usando el comando psql:
sudo -u postgres psql
Ahora debería ver el prompt de PostgreSQL (postgres=#).
Continuaremos usando la tabla employees creada en el paso anterior. Si no la ha creado, consulte el paso anterior para crear la tabla e insertar datos.
Revisemos los datos en la tabla employees:
SELECT * FROM employees;
Debería ver los datos de los empleados como antes.
El operador LIKE se usa en una cláusula WHERE para encontrar filas que coincidan con un patrón especificado. El patrón puede incluir caracteres comodín (wildcard characters):
%: Representa cero o más caracteres.
_: Representa un solo carácter.
Por ejemplo, para encontrar todos los empleados cuyos nombres comiencen con 'A', puede usar la siguiente consulta:
SELECT * FROM employees WHERE name LIKE 'A%';
Esta consulta devolverá todas las filas donde la columna name comience con 'A'. La salida debería ser:
id | name | department | salary
----+---------------+------------+--------
1 | Alice Smith | Sales | 60000
(1 row)
Para encontrar todos los empleados cuyos nombres contengan la letra 'o', puede usar la siguiente consulta:
SELECT * FROM employees WHERE name LIKE '%o%';
Esta consulta devolverá todas las filas donde la columna name contenga la letra 'o'. La salida debería ser:
id | name | department | salary
----+-----------------+-------------+--------
2 | Bob Johnson | Marketing | 75000
3 | Charlie Brown | Sales | 55000
5 | Eve Wilson | Marketing | 80000
(3 rows)
Para encontrar todos los empleados cuyos nombres terminen con 'n', puede usar la siguiente consulta:
SELECT * FROM employees WHERE name LIKE '%n';
Esta consulta devolverá todas las filas donde la columna name termine con 'n'. La salida debería ser:
id | name | department | salary
----+---------------+------------+--------
2 | Bob Johnson | Marketing | 75000
3 | Charlie Brown | Sales | 55000
5 | Eve Wilson | Marketing | 80000
(3 rows)
También puede usar el comodín _ para que coincida con un solo carácter. Por ejemplo, para encontrar todos los empleados cuyos nombres tengan 'e ' como el segundo y tercer carácter, puede usar la siguiente consulta:
SELECT * FROM employees WHERE name LIKE '_e%';
Esta consulta devolverá todas las filas donde la columna name tenga 'e' como el segundo carácter. La salida debería ser:
id | name | department | salary
----+------+------------+--------
(0 rows)
El operador LIKE distingue entre mayúsculas y minúsculas (case-sensitive). Si desea realizar una búsqueda que no distinga entre mayúsculas y minúsculas (case-insensitive), puede usar el operador ILIKE. Por ejemplo:
SELECT * FROM employees WHERE name ILIKE 'a%';
Esta consulta devolverá todas las filas donde la columna name comience con 'a' o 'A'.
Finalmente, salga del shell psql:
\q
Esto lo devolverá a la terminal del usuario labex.
Ordenar Datos con ORDER BY
En este paso, aprenderemos cómo usar la cláusula ORDER BY en PostgreSQL para ordenar datos. La cláusula ORDER BY le permite ordenar el conjunto de resultados de una consulta basándose en una o más columnas, ya sea en orden ascendente o descendente.
Primero, conectémonos a la base de datos PostgreSQL. Abra una terminal en su VM de LabEx.
Conéctese a la base de datos PostgreSQL usando el comando psql:
sudo -u postgres psql
Ahora debería ver el prompt de PostgreSQL (postgres=#).
Continuaremos usando la tabla employees creada en los pasos anteriores. Si no la ha creado, consulte los pasos anteriores para crear la tabla e insertar datos.
Revisemos los datos en la tabla employees:
SELECT * FROM employees;
Debería ver los datos de los empleados como antes.
La cláusula ORDER BY se usa para ordenar el conjunto de resultados de una consulta. De forma predeterminada, la cláusula ORDER BY ordena los datos en orden ascendente.
Por ejemplo, para ordenar los empleados por salario en orden ascendente, puede usar la siguiente consulta:
SELECT * FROM employees ORDER BY salary;
Esta consulta devolverá todas las filas de la tabla employees, ordenadas por la columna salary en orden ascendente. La salida debería ser:
id | name | department | salary
----+-----------------+-------------+--------
3 | Charlie Brown | Sales | 55000
1 | Alice Smith | Sales | 60000
2 | Bob Johnson | Marketing | 75000
5 | Eve Wilson | Marketing | 80000
4 | David Lee | Engineering | 90000
6 | Frank Miller | Engineering | 95000
(6 rows)
Para ordenar los datos en orden descendente, puede usar la palabra clave DESC después del nombre de la columna. Por ejemplo, para ordenar los empleados por salario en orden descendente, puede usar la siguiente consulta:
SELECT * FROM employees ORDER BY salary DESC;
Esta consulta devolverá todas las filas de la tabla employees, ordenadas por la columna salary en orden descendente. La salida debería ser:
id | name | department | salary
----+-----------------+-------------+--------
6 | Frank Miller | Engineering | 95000
4 | David Lee | Engineering | 90000
5 | Eve Wilson | Marketing | 80000
2 | Bob Johnson | Marketing | 75000
1 | Alice Smith | Sales | 60000
3 | Charlie Brown | Sales | 55000
(6 rows)
También puede ordenar los datos por múltiples columnas. Por ejemplo, para ordenar los empleados por departamento en orden ascendente y luego por salario en orden descendente, puede usar la siguiente consulta:
SELECT * FROM employees ORDER BY department ASC, salary DESC;
Esta consulta primero ordenará los datos por la columna department en orden ascendente. Dentro de cada departamento, los datos se ordenarán por la columna salary en orden descendente. La salida debería ser:
id | name | department | salary
----+---------------+-------------+--------
6 | Frank Miller | Engineering | 95000
4 | David Lee | Engineering | 90000
5 | Eve Wilson | Marketing | 80000
2 | Bob Johnson | Marketing | 75000
1 | Alice Smith | Sales | 60000
3 | Charlie Brown | Sales | 55000
(6 rows)
Finalmente, salga del shell psql:
\q
Esto lo devolverá a la terminal del usuario labex.
Limitar Resultados con LIMIT y OFFSET
En este paso, aprenderemos cómo usar las cláusulas LIMIT y OFFSET en PostgreSQL para limitar el número de filas devueltas por una consulta y para omitir un cierto número de filas, respectivamente. Estas cláusulas son útiles para implementar la paginación (pagination) o para recuperar un subconjunto específico de datos.
Primero, conectémonos a la base de datos PostgreSQL. Abra una terminal en su VM de LabEx.
Conéctese a la base de datos PostgreSQL usando el comando psql:
sudo -u postgres psql
Ahora debería ver el prompt de PostgreSQL (postgres=#).
Continuaremos usando la tabla employees creada en los pasos anteriores. Si no la ha creado, consulte los pasos anteriores para crear la tabla e insertar datos.
Revisemos los datos en la tabla employees:
SELECT * FROM employees;
Debería ver los datos de los empleados como antes.
La cláusula LIMIT se usa para limitar el número de filas devueltas por una consulta. Por ejemplo, para recuperar solo los primeros 3 empleados, puede usar la siguiente consulta:
SELECT * FROM employees LIMIT 3;
Esta consulta devolverá las primeras 3 filas de la tabla employees. La salida debería ser:
id | name | department | salary
----+-----------------+-------------+--------
1 | Alice Smith | Sales | 60000
2 | Bob Johnson | Marketing | 75000
3 | Charlie Brown | Sales | 55000
(3 rows)
La cláusula OFFSET se usa para omitir un cierto número de filas antes de comenzar a devolver filas. A menudo se usa en conjunto con la cláusula LIMIT para implementar la paginación (pagination). Por ejemplo, para recuperar los siguientes 3 empleados después de omitir los primeros 2, puede usar la siguiente consulta:
SELECT * FROM employees LIMIT 3 OFFSET 2;
Esta consulta omitirá las primeras 2 filas y luego devolverá las siguientes 3 filas de la tabla employees. La salida debería ser:
id | name | department | salary
----+-----------------+-------------+--------
3 | Charlie Brown | Sales | 55000
4 | David Lee | Engineering | 90000
5 | Eve Wilson | Marketing | 80000
(3 rows)
También puede combinar LIMIT y OFFSET con la cláusula ORDER BY. Por ejemplo, para recuperar los 2 empleados mejor pagados, puede usar la siguiente consulta:
SELECT * FROM employees ORDER BY salary DESC LIMIT 2;
Esta consulta primero ordenará los empleados por salario en orden descendente y luego devolverá las primeras 2 filas. La salida debería ser:
id | name | department | salary
----+-----------------+-------------+--------
6 | Frank Miller | Engineering | 95000
4 | David Lee | Engineering | 90000
(2 rows)
Para recuperar el tercer y cuarto empleado mejor pagados, puede usar la siguiente consulta:
SELECT * FROM employees ORDER BY salary DESC LIMIT 2 OFFSET 2;
Esta consulta primero ordenará los empleados por salario en orden descendente, omitirá las primeras 2 filas y luego devolverá las siguientes 2 filas. La salida debería ser:
id | name | department | salary
----+-----------------+-------------+--------
5 | Eve Wilson | Marketing | 80000
2 | Bob Johnson | Marketing | 75000
(2 rows)
Finalmente, salga del shell psql:
\q
Esto lo devolverá a la terminal del usuario labex.
Resumen
En este laboratorio, comenzamos conectándonos a una base de datos PostgreSQL utilizando el comando psql y creamos una tabla de ejemplo employees con columnas para ID, nombre, departamento y salario. Luego, poblamos la tabla con datos de empleados y verificamos su contenido utilizando una consulta SELECT.
El enfoque inicial fue en el uso de la cláusula WHERE para filtrar datos basados en condiciones específicas. Esto permite recuperar solo las filas que cumplen con los criterios definidos, lo que permite la recuperación de datos específicos de la tabla employees.
