Crea una cuenta o inicia sesión

¡Continúa aprendiendo sin ningún costo! Únete y comienza a potenciar tu carrera

Aprovecha el precio especial y haz tu profesión a prueba de IA

Antes: $249

Currency
$209
Suscríbete

Termina en:

0 Días
7 Hrs
7 Min
9 Seg

Principales sentencias SQL

6/34
Recursos

¿Qué debes saber sobre las sentencias SQL?

Cuando se trata de interactuar con bases de datos relacionales, las sentencias SQL son una herramienta fundamental que debes dominar. Este conocimiento es esencial no solo para las consultas básicas, sino también para operaciones más complejas. En este artículo, daremos un repaso a estas sentencias fundamentales que ayudarán en la gestión efectiva de bases de datos.

¿Cómo utilizar el entorno de trabajo y herramientas recomendadas?

Antes de sumergirnos en las sentencias, es importante familiarizarte con las herramientas que utilizaremos. Durante este curso, se usarán las mismas técnicas y herramientas del curso de PostgreSQL. Para la parte visual, se recomienda utilizar la herramienta "pgAdmin" que facilita la interacción con la base de datos.

Consejos:

  • Asegúrate de haber instalado correctamente las herramientas siguiendo las guías del curso de PostgreSQL.
  • Si encuentras algún problema de instalación, no dudes en buscar ayuda en los foros del curso.

¿Qué es la sentencia SELECT?

La sentencia SELECT es una de las más básicas y esenciales en SQL. Su propósito es extraer datos de una base de datos según las columnas que necesites.

Por ejemplo, si deseas obtener los datos más recientes de una tabla, podrías ejecutar una consulta así:

SELECT MAX(fecha_actualizacion) AS fecha_ultima_actualizacion
FROM peliculas;

En este caso, estamos seleccionando la fecha más reciente de actualización de la tabla peliculas y asignándole un alias más legible.

¿Cómo filtrar con la cláusula WHERE?

La cláusula WHERE es crucial para filtrar datos conforme a ciertas condiciones. Por ejemplo, para extraer datos de películas cuyo periodo de renta supera los tres días, podríamos aplicar esta condición:

SELECT *
FROM peliculas
WHERE duracion_renta > 3;

Esta cláusula te ayudará a centrarte solo en los datos relevantes y a reducir la cantidad de información que necesitarás procesar.

¿Cómo agrupar y ordenar datos?

Dos sentencias importantes que complementan el manejo de datos en SQL son GROUP BY y ORDER BY.

  • GROUP BY: Sirve para agrupar filas que tienen el mismo valor en columnas especificadas, ideal para agregar datos y realizar funciones como COUNT, SUM, etc.

    SELECT clasificacion, COUNT(*) AS cantidad_peliculas
    FROM peliculas
    GROUP BY clasificacion;
    
  • ORDER BY: Permite ordenar la información según el criterio seleccionado, lo que facilita la lectura y el análisis de datos.

    SELECT *
    FROM peliculas
    ORDER BY fecha_actualizacion DESC;
    

Ambas clausulas son esenciales para presentar datos de manera efectiva y comprensible.

Practica y ten las sentencias claras

Este fue un breve repaso por las sentencias básicas de SQL. Un punto clave es mantener siempre presente cómo y cuándo usar cada una. Practicar con ejemplos cotidianos ayuda a fortalecer este conocimiento. Aunque este artículo presenta un caso hipotético de una base de datos de alquiler de películas, en futuras lecciones se profundizará más sobre cómo aplicar estas herramientas en proyectos reales.

Mantén estas sentencias en mente mientras desarrollas tus habilidades en el mundo de las bases de datos. ¡El aprendizaje continuo es la clave del éxito!

Aportes 35

Preguntas 6

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

Recuerden que para abrir esta base de datos deben seguir los siguientes pasos:

  1. Descargan la base de datos platzimovies en formato .tar que esta en esta url = https://drive.google.com/file/d/1oE7A4z_D2o-udn_yflwZ03uN3cA0gVpr/view
  2. en el servidor de postgres crean una nueva base de datos con el nombre “platzimovies”
  3. dan click derecho en la base de datos nueva llamada “platzimovies” y eligen restore
  4. en format = "custom or tar "y en Filenime dan click en (…)
  5. aparece la ventana Select File eligen la ruta del archivo tar que descargaron
  6. en la parte de format eligen All files para que les aparezca el archivo, luego select y restore

finalmente queda importada la base de datos platzivideos

¡Pilas con la función count() !

  • Count(*) : Cuenta la cantidad de registros (Cantidad de filas) de la consulta (todas, sin discriminar si son duplicados).

  • Count(Distinct <Campo objetivo >) : Cuenta la cantidad distinta de registros de la consulta (discriminando duplicados, considerando solo los campos únicos).

Ejemplo:

select Count(*) from public.pagos;
--resultado: 14596

select Count(cliente_id) from public.pagos;
--resultado: 14596

select Count(distinct cliente_id) from public.pagos;
--resultado: 599

PD: tengamos presente que según la bd que utilicemos puede ser considerado, o no, los campos nulos. Siempre esta bueno verificar lo que puede parecer obvio, cuando pasas de un motor de bd a otro.

Buen ejemplo pero creo que el MAX sobre ultima_actualizacion no sería necesario dado que se usa más adelante en el GROUP BY.

Este es la clase de instalación de PostgreSQL:
https://platzi.com/clases/1480-postgresql/24177-instalacion-y-configuracion-de-la-base-de-datos/

Pero recomiendo que ya tengan conocimientos o hayan llevado el curso.

Programación en SQL con PostgreSQL

https://www.um.es/geograf/sigmur/sigpdf/postgresql.pdf

ufff que buena clase!! Fundamentos de SQL en 6 minutos

Salió bien el código:

SELECT 	MAX(ultima_actualizacion) AS fecha_ultima_actualizacion,
		clasificacion,
		COUNT (*) AS cantidad_peliculas
FROM	peliculas
WHERE 	duracion_renta > 3
GROUP BY 	clasificacion, ultima_actualizacion
ORDER BY 	fecha_ultima_actualizacion;

Me pongo contento que el código se haya ejecutado de 10:

Hola les comparto este otro programa alternativo a pgadmin
https://www.beekeeperstudio.io/
A mi me ha gustado mucho ya que es ligero y maneja distintos motores (mongo,oracle,postgres y otros más) . Ademas la interfaz es muy buena.

Muy buen repaso, faltó únicamente el LIMIT y el HAVING

Estoy trabajando con MySQL y no tengo la posibilidad de hacer restore. La solucion que encontre es modificar los archivos a .csv e importarlos directamente.
Hay que crear las tablas previamente ya que los documentos no traen headers

6. Principales sentencias SQL

SELECT MAX(ultima_actualizacion) AS fecha_ultima_actualizacion,
		clasificacion,
		COUNT(*) AS cantidad_peliculas
FROM 	peliculas
WHERE 	duracion_renta > 3
GROUP BY 	clasificacion, ultima_actualizacion
ORDER BY 	fecha_ultima_actualizacion

;

Para tener en cuenta. En ORDER BY el orden por defecto es ascendente pero si se desea lo contrario entonces se debe especificar DESC despues del nombre del campo en ORDER BY

Me parece que el ejemplo debia ser de la siguiente manera :

SELECT MAX(ultima_actualizacion) AS fecha_ultima_actualizacion, 
	clasificacion, COUNT(*) AS cantidad_peliculas
FROM peliculas
WHERE duracion_renta > 3
GROUP BY clasificacion
ORDER BY fecha_ultima_actualizacion, clasificacion
sin la agrupacion por ultima_actualizacion ya que anula el uso del Max.

Al momento de realizar la restauración de la base de datos “platzimovies”, me salia este error .
Tenía pgAdminIII

Error file "couldn't be moved (error 2: No such file or directory)

Encontré la solución en:

https://stackoverflow.com/questions/39796268/errno-2-no-such-file-or-directory-when-trying-to-backup-a-database-in-pgadmi

Ahí explican que es debido a que en pgAdminIII hacen la restauración con este comando

$ pg_restore -d <DBNAME> --username=postgres g=<FILENAME> 

Lo que genera el error :

pg_restore: [archiver] could not open input file "g=<FILENAME>": No such file or directory

y en pgAdmin4 cambiaron a :

$ pg_restore -d <DBNAME> --username=postgres <FILENAME>

Por lo que puedes ejecutarlo desde la terminal aún con pgAdmin3 o simplemente cambiar a pgAdmin4

https://www.pgadmin.org/download/

Para quienes usan Docker y Docker Compose. en tu editor de código crea un archivo llamado `docker-compose.yaml `y copia y pega lo siguiente: ```js services: db: image: postgres:latest restart: always ports: - "5432:5432" # Puerto por defecto de PostgreSQL environment: POSTGRES_USER: ${POSTGRES_USER} POSTGRES_PASSWORD: ${POSTGRES_PASSWORD} volumes: - ./database:/var/lib/postgresql/data - ./data:/usr/src/data networks: - mynetwork pgadmin: image: dpage/pgadmin4:latest restart: always ports: - "8080:80" # pgAdmin en el puerto 8080 environment: PGADMIN_DEFAULT_EMAIL: ${PGADMIN_DEFAULT_EMAIL} PGADMIN_DEFAULT_PASSWORD: ${PGADMIN_DEFAULT_PASSWORD} volumes: - ./pgadmin:/var/lib/pgadmin - ./data:/usr/src/data depends_on: - db # Asegura que pgAdmin se inicie después de la base de datos networks: - mynetwork networks: mynetwork: # Definir una red común para que ambos servicios se puedan comunicar driver: bridge ```Recuerda también crear el archivo `.env ` ```js # Variables para la base de datos PostgreSQL POSTGRES_USER=postgres POSTGRES_PASSWORD=secret_password # Variables para pgAdmin [email protected] PGADMIN_DEFAULT_PASSWORD=secret_pgadmin ```Listo ve a tu navegador y escribe `localhost:8080 ` ingresa las credenciales y listo
![](https://static.platzi.com/media/user_upload/image-c1b8e9fa-6421-4e0c-9c5e-02e5559a1a04.jpg)
Las **sentencias SQL** son comandos que se utilizan para interactuar con bases de datos, ya sea para **consultar** datos, **modificarlos**, **eliminarlos** o **insertarlos**. A continuación te presento las **principales sentencias SQL** y su uso: ### 1. **SELECT** * Se utiliza para **consultar datos** de una o más tablas. * Sintaxis básica:SELECT columna1, columna2, ... FROM nombre\_tabla; * También se puede usar para filtrar, ordenar o agrupar resultados:SELECT columna1, columna2 FROM nombre\_tabla WHERE condicion ORDER BY columna GROUP BY columna; ### 2. **INSERT INTO** * Se utiliza para **insertar nuevos registros** en una tabla. * Sintaxis básica:INSERT INTO nombre\_tabla (columna1, columna2, ...) VALUES (valor1, valor2, ...); ### 3. **UPDATE** * Se usa para **modificar los valores** de registros existentes en una tabla. * Sintaxis básica:UPDATE nombre\_tabla SET columna1 = valor1, columna2 = valor2 WHERE condicion; * **WHERE** es importante para especificar qué registros se deben actualizar; si se omite, se actualizarán todos los registros. ### 4. **DELETE** * Se usa para **eliminar registros** de una tabla. * Sintaxis básica:DELETE FROM nombre\_tabla WHERE condicion; * Al igual que en **UPDATE**, es fundamental usar **WHERE** para especificar los registros a eliminar. Si se omite, se eliminarán todos los registros de la tabla. ### 5. **CREATE TABLE** * Se utiliza para **crear una nueva tabla** en la base de datos. * Sintaxis básica:CREATE TABLE nombre\_tabla ( columna1 tipo\_dato, columna2 tipo\_dato, ... ); ### 6. **ALTER TABLE** * Se usa para **modificar la estructura** de una tabla existente, como agregar, eliminar o modificar columnas. * Sintaxis básica:ALTER TABLE nombre\_tabla ADD columna\_nueva tipo\_dato; ALTER TABLE nombre\_tabla DROP COLUMN columna\_a\_eliminar; ALTER TABLE nombre\_tabla MODIFY COLUMN columna\_existente tipo\_dato; ### 7. **DROP TABLE** * Se usa para **eliminar** una tabla de la base de datos. * Sintaxis básica:DROP TABLE nombre\_tabla; ### 8. **CREATE INDEX** * Se usa para **crear un índice** en una o más columnas de una tabla. Los índices mejoran la velocidad de las consultas, pero pueden ralentizar las inserciones y actualizaciones. * Sintaxis básica:CREATE INDEX nombre\_indice ON nombre\_tabla (columna1, columna2); ### 9. **DROP INDEX** * Se usa para **eliminar un índice** previamente creado. * Sintaxis básica:DROP INDEX nombre\_indice; ### 10. **TRUNCATE** * Se usa para **eliminar todos los registros** de una tabla, pero **mantener la estructura** de la tabla. Es más rápido que **DELETE**, pero no puede ser revertido con un `ROLLBACK`. * Sintaxis básica:TRUNCATE TABLE nombre\_tabla; ### 11. **GRANT** * Se usa para **asignar permisos** a un usuario o rol sobre una tabla, vista u otros objetos de la base de datos. * Sintaxis básica:GRANT permiso ON objeto TO usuario; Ejemplo:GRANT SELECT, INSERT ON empleados TO juan; ### 12. **REVOKE** * Se usa para **revocar permisos** previamente otorgados a un usuario o rol. * Sintaxis básica:REVOKE permiso ON objeto FROM usuario; ### 13. **JOIN** * **JOIN** se usa para combinar filas de dos o más tablas basándose en una condición relacionada entre ellas. * **INNER JOIN**: Devuelve solo las filas que tienen coincidencias en ambas tablas. * **LEFT JOIN**: Devuelve todas las filas de la tabla izquierda y las filas coincidentes de la tabla derecha. * **RIGHT JOIN**: Devuelve todas las filas de la tabla derecha y las filas coincidentes de la tabla izquierda. * **FULL OUTER JOIN**: Devuelve filas cuando hay una coincidencia en una de las tablas. Ejemplo de un **INNER JOIN**: SELECT empleados.nombre, departamentos.nombre FROM empleados INNER JOIN departamentos ON empleados.departamento\_id = departamentos.id; ### 14. **GROUP BY** * Se usa para agrupar filas que tienen los mismos valores en columnas específicas y aplicar funciones agregadas (como COUNT, SUM, AVG). * Sintaxis básica:SELECT columna, COUNT(\*) FROM nombre\_tabla GROUP BY columna; ### 15. **HAVING** * Se usa para **filtrar los resultados** de una consulta después de que se ha aplicado el `GROUP BY`. * Sintaxis básica:SELECT columna, COUNT(\*) FROM nombre\_tabla GROUP BY columna HAVING COUNT(\*) > 5; ### 16. **ORDER BY** * Se usa para **ordenar** los resultados de una consulta. * `ASC` para orden ascendente. * `DESC` para orden descendente. * Sintaxis básica:SELECT columna1, columna2 FROM nombre\_tabla ORDER BY columna1 ASC; ### 17. **DISTINCT** * Se usa para **eliminar duplicados** y mostrar solo valores únicos. * Sintaxis básica:SELECT DISTINCT columna FROM nombre\_tabla; ### 18. **LIMIT** * Se usa para **limitar el número de resultados** de una consulta. * Sintaxis básica:SELECT columna1, columna2 FROM nombre\_tabla LIMIT 10; ### 19. **EXPLAIN** * Se usa para obtener el **plan de ejecución** de una consulta, lo que permite entender cómo se está procesando la consulta. * Sintaxis básica:EXPLAIN SELECT columna1, columna2 FROM nombre\_tabla; Estas son las **principales sentencias SQL** que se utilizan para interactuar con bases de datos relacionales. Cada una tiene su propósito específico y se utiliza en distintos contextos para gestionar datos de manera eficiente.
donde descargo el documento de base de datos con el que se esta trabajando, no la encuentro en los recursos.
```ts SELECT MAX(ultima_actualizacion) AS "Ultima Versión", clasificacion, COUNT (*) AS "Cantidad Peliculas" FROM peliculas WHERE duracion_renta > 3 GROUP BY clasificacion, ultima_actualizacion ORDER BY "Ultima Versión" ```
Para ver el diagrama entidad-relación de la base de datos `platzimovies` 1. Clic derecho sobre la base de datos `platzimovies` 2. Seleccionar la opción "EDR for database" pgAdmin abrira una pestaña interactiva con el diagrama de entidad de relación de la base de datos. ![](https://res.cloudinary.com/dmwsbri4c/image/upload/v1715907059/platimovies_edr.png) Espero este aporte les sea de ayuda 💚
Para restaurar la base desde SQL Shell: 1. Nos localizamos en la base platzimovies: \c platzimovies (o la creamos si no existe) 2. Restauramos desde la consola con el siguiente comando: \i 'dirección en donde se localiza el .sql' Con esos paso tendremos la estructura de la base.
🌹🌹

La query del ejemplo tiene varias inconcistencias, en donde se utiliza una función de agregación max, pero se agrupa por ultima_actualización y luego se agrupa por la funcion de agregación nuevamente:

select max(ultima_actualizacion) as fecha_ultima_actualizacion,
	clasificacion,
	count(*) as cantidad_peliculas
	from peliculas
where duracion > 3
group by clasificacion, ultima_actualizacion
order by fecha_ultima_actualizacion

Una forma más clara y lógica de realizar la query:

select ultima_actualizacion,
	clasificacion,
	count(*) as cantidad_peliculas
	from peliculas
where duracion > 3
group by ultima_actualizacion, clasificacion
order by ultima_actualizacion 

muy buen repaso

yo si de verdad quiero saber como crearon las descripciones de las peliculas, 1000 descripciones y no son texto aleatorio, por ejemplo: la pelicula: Ace Goldfinger: “A Astounding Epistle of a Database Administrator And a Explorer who must Find a Car in Ancient China”

Asi funciona tambien:

SELECT ultima_actualizacion, clasificacion,
            COUNT(*) AS cantidad_peliculas 
FROM peliculas
WHERE duracion_renta > 3
GROUP BY clasificacion, ultima_actualizacion
ORDER BY ultima_actualizacion;  

aqui les dejo como hacer el restore de la base de datos usando
Docker

Falto agregar a HAVING y recomendaciones al momento de agrupar

Para aquellos quienes no le guste pgadmin o tengan problemas para restaurar lo puede hacer creando primero la base datos platzimovies con psql:

CREATE DATABASE platzimovies;

luego en la terminal vamos a :

cd /Applications/Postgres.app/Contents/Versions/latest/bin

el path lo pueden hallar utlizando:

which psql

luego estando en dicha ruta escribimos la siguiente linea de código.

pg_restore --dbname=platzimovies --create --verbose rutadelbackup

En este link pueden encontrar parte de la anterior información.
PostgreSQL Restore Database

Empecemos

interesante

Me parece genial este curso, justo cambie de proyecto en donde trabajan con JAVA SPRING BOOT y POSTGRESQL

En este enlace pueden descargar el backup, si tienen problemas con la importación les recomiendo tener la versión 12 de postgreSQL

https://drive.google.com/file/d/1oE7A4z_D2o-udn_yflwZ03uN3cA0gVpr/view

SELECT MAX(ultima_actualizacion) AS fecha_ultima_actualizacion, clasificacion, COUNT(*) AS cantidad_peliculas
FROM peliculas
WHERE duracion_renta > 3
GROUP BY clasificacion, ultima_actualizacion
ORDER BY fecha_ultima_actualizacion