¡El poder de los datos!

1

¡El poder de los datos!

Introducción a las bases de datos relacionales

2

Buenas prácticas de bases de datos con SQL

3

Tipos de datos en SQL

4

¿Cómo crear una base de datos en SQL?

5

Práctica: Tu primera consulta en bases de datos

6

Historia y Evolución de SQL

7

Práctica: Creación de Tablas en SQL (CREATE TABLE)

Manipulación de Datos

8

Insertando Datos con SQL (INSERT)

9

Consultas y Selecciones en SQL (SELECT)

10

Práctica: SELECT en SQL

11

Actualización de Datos con SQL (UPDATE)

12

Eliminación de Datos con SQL (DELETE)

13

Práctica: CRUD con SQL

Manipulación Avanzada de Datos

14

Instalación de MySQL Server y MySQL Workbench

15

¿Qué es la cláusula WHERE de SQL?

16

Filtrar y Ordenar Datos en SQL (LIKE)

17

Práctica: Filtrar Datos con WHERE en SQL

18

Cláusulas de Comparación Textual en SQL (AND, NULL, IN, NOT)

19

Funciones de Aritmética Básica en SQL (COUNT, SUM, AVG)

20

Funciones de Aritmética Básica en SQL (MIN, MAX)

Agrupación de Datos

21

Agrupación de Datos en SQL: GROUP BY, HAVING y CASE para Análisis Avanzado

22

Práctica: Agrupamiento y Ordenamiento de Datos

23

Tipos de JOIN en SQL

24

¿Cómo funciona INNER JOIN, LEFT JOIN, RIGHT JOIN y FULL JOIN?

25

Práctica: LEFT JOIN en SQL

Transformación de Datos

26

Vistas Materializadas en SQL: Como optimizar tus consultas y reportes.

27

Práctica: Crear Vistas Materializadas en SQL

28

Optimización de Bases de Datos con SQL: CREATE INDEX y TRIGGER

29

Vistas Materializadas y Temporales en SQL

30

Expresiones de Tablas Comunes (CTE) en SQL

Procedimientos Almacenados

31

Procedimientos Almacenados en SQL

32

Procedimientos Almacenados en SQL: Gestión de Variables y Manejo de Excepciones

Administración de Base de Datos

33

Respaldos y Restauración de Bases de Datos

34

Seguridad en Bases de Datos SQL

Análisis de Datos Avanzados

35

Potenciando los Datos en la Nube: Data Science, Big Data, ML e AI

36

SQL para Análisis de Datos: Primeros pasos con Power BI

No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Vistas Materializadas en SQL: Como optimizar tus consultas y reportes.

26/36
Recursos

Aportes 35

Preguntas 2

Ordenar por:

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

![](https://static.platzi.com/media/user_upload/Vistas%20Materializadas%20en%20SQL-f53cd3a2-6828-4ab0-b0cf-d85d3d053d68.jpg)
`E`xtract `T`ransform `L`oad
sería genial que hicieran un curso de procedimientos almacenados
Para lo que quizás como yo usen SQL server para modificar alguna vista si usan **CREATE OR REPLACE** VIEW no es soportado y generara un error de sintaxis. En este motor sea usa **ALTER VIEW**
Caro, me gusto mucho ver ETL en esta clase 👩‍💻 es uno de los primeros términos técnicos que se aprenden en Data Analytic
Ejemplo de vista: `CREATE OR ALTER VIEW VW_TEACHERS_COURSES AS ` `SELECT I.instructor_id, I.first_name, I.last_name, I.salary, C.course_name` `FROM INSTRUCTORS I` `INNER JOIN COURSES C` `ON I.instructor_id = C.instructor_id` `WHERE I.instructor_id IN (1,2,3)` Resultado: ![](https://static.platzi.com/media/user_upload/view-7f00ec4b-78b0-429e-87c5-a5f35fc06ead.jpg)
Las **vistas materializadas** son una poderosa herramienta en SQL que te permiten optimizar el rendimiento de tus consultas y reportes, especialmente cuando trabajas con grandes volúmenes de datos o consultas complejas. A continuación, te explicaré qué son, cómo funcionan y cómo pueden ayudarte a mejorar la eficiencia en tus sistemas de bases de datos. #### ¿Qué es una Vista Materializada? Una **vista materializada** es una estructura de datos que almacena los resultados de una consulta SQL en una tabla física. A diferencia de una vista normal (o "vista lógica"), que se recalcula cada vez que se accede a ella, la vista materializada guarda una copia de los datos en el momento en que se crea o actualiza, permitiendo accesos más rápidos. ##### Diferencias clave: * **Vista lógica**: No almacena datos, solo define una consulta que se ejecuta cuando accedes a ella. Siempre muestra los datos actuales de las tablas subyacentes. * **Vista materializada**: Almacena una copia de los resultados de la consulta, lo que permite acceder a datos precomputados, mejorando el rendimiento en consultas repetitivas o costosas. #### Beneficios de Usar Vistas Materializadas 1. **Mejora en el Rendimiento**: Almacenar los resultados de consultas complejas evita tener que recalcular los datos cada vez que se necesita, lo que reduce drásticamente los tiempos de ejecución para reportes o análisis. 2. **Reducción de Carga en el Servidor**: Las consultas costosas pueden ejercer una gran carga en el servidor. Al usar una vista materializada, se reduce la necesidad de ejecutar repetidamente estas consultas, liberando recursos y mejorando la eficiencia general del sistema. 3. **Optimización de Reportes**: Si tus reportes requieren cálculos complejos o agregaciones sobre grandes conjuntos de datos, las vistas materializadas pueden precomputar estos resultados, haciendo que la generación de reportes sea casi instantánea. #### Cómo Funcionan las Vistas Materializadas * **Creación**: Al crear una vista materializada, la consulta subyacente se ejecuta y los resultados se almacenan en una tabla física. * **Actualización**: La vista materializada puede ser actualizada de diferentes maneras, dependiendo de la configuración: * **Actualización Manual**: Necesitas ejecutar una instrucción específica para refrescar los datos. * **Actualización Programada**: Puedes configurar la vista para que se actualice automáticamente en intervalos regulares. * **Actualización Inmediata**: En algunos sistemas, la vista materializada se actualiza automáticamente cada vez que cambian los datos subyacentes. #### Ejemplo de Uso Imagina que tienes una base de datos con millones de transacciones de ventas y quieres generar reportes frecuentes sobre las ventas totales por mes. Sin una vista materializada, cada vez que ejecutes la consulta, el sistema tendrá que procesar todas las transacciones nuevamente. Con una vista materializada, puedes precomputar y almacenar los totales mensuales: sqlCopiar código`CREATE MATERIALIZED VIEW ventas_mensuales AS` `SELECT` ` DATE_TRUNC('month', fecha_venta) AS` mes, ` SUM(monto_venta) AS` total\_ventas `FROM` transacciones `GROUP BY` ` DATE_TRUNC('month'`, fecha\_venta); Ahora, cuando necesites los totales mensuales, simplemente consultas la vista materializada: sqlCopiar código`SELECT * FROM` ventas\_mensuales; #### Consideraciones * **Espacio de Almacenamiento**: Las vistas materializadas ocupan espacio en disco, ya que almacenan físicamente los datos. Es importante balancear el costo de almacenamiento con los beneficios de rendimiento. * **Mantenimiento**: Si los datos subyacentes cambian con frecuencia, necesitarás actualizar regularmente la vista materializada para asegurarte de que los datos sean actuales. #### Conclusión Las vistas materializadas son una herramienta poderosa para optimizar el rendimiento de tus consultas y reportes en SQL. Al precomputar y almacenar los resultados de consultas complejas, puedes reducir significativamente los tiempos de respuesta y la carga en tu servidor, lo que es especialmente útil en aplicaciones de análisis de datos y generación de reportes. 4o
```js SELECT vc.coursename, vc.description, vc.durationhours, i.firstname || ' ' || i.lastname AS instructor_name FROM vw_courses vc INNER JOIN instructors i ON instructorid = i.instructorid WHERE vc.durationhours > 10 AND i.firstname = 'John'; ```
Resumen de la clase 📋 ![](https://static.platzi.com/media/user_upload/Clase26-8167350e-c2d8-49ba-b71d-19c52638c2ac.jpg)
**PostgreSQL** no permite modificar columnas de una vista utilizando `CREATE OR REPLACE VIEW`. Para resolver esto, puedes eliminar la vista existente y luego crearla nuevamente con la nueva definición.
Que buena clase
```js CREATE OR REPLACE VIEW AA_PRODUCTOS AS SELECT P.ID AS ID_PRODUCTOS, P.TIPO, M.ID AS ID_MARCAS, M.NOMBRE FROM PRODUCTOS P LEFT JOIN MARCAS M ON P.marca_id = M.id; ```CREATE OR REPLACE VIEW AA\_PRODUCTOS AS SELECT P.ID AS ID\_PRODUCTOS, P.TIPO, M.ID AS ID\_MARCAS, M.NOMBRE FROM PRODUCTOS P LEFT JOIN MARCAS M ON P.marca\_id = M.id;
Aquí ya me confundí un poco (no conocía el concepto de vista materializada) pero si he trabajado con vistas, bueno aprendí que hay diferencias: **Vista:** es dinámica, no almacena datos. **Vista Materializada:** almacena datos físicamente, ofrece más rendimiento a costa de sincronización manual o programada. ademas su sintaxis es diferente: **VISTA**: ```js CREATE VIEW PortlandAreaAddresses_vw AS SELECT AddressID, AddressLine1, City, StateProvinceID, PostalCode, ModifiedDate FROM Person.Address WHERE PostalCode LIKE '970%' OR PostalCode LIKE '971%' OR PostalCode LIKE '972%' OR PostalCode LIKE '986[6-9]%' WITH CHECK OPTION; ``` * Es un select almacenado que genera datos dinámicamente cuando se consulta la vista. * No almacena datos físicamente; depende siempre de las tablas de origen que forman la vista. * Los cambios en las tablas de rigen se reflejan inmediatamente en la vista. **VISTA MATERIALIZADA**: ```js CREATE MATERIALIZED VIEW mi_dataset.mi_vista_materializada AS SELECT columna1, columna2 FROM mi_dataset.mi_tabla WHERE condicion; ``` * Almacena los datos físicamente, como si fuera una tabla. * Ofrece mejor rendimiento para consultas frecuentes, pero requiere mantenimiento para mantener los datos actualizados. * Necesita ser actualizada explícitamente (REFRESH MATERIALIZED VIEW) para reflejar los cambios en las tablas de origen.
Te explico las vistas (VIEWS) con ejemplos prácticos y casos de uso reales. \### 1. Vista para un Sistema de E-commerce ```sql \-- Vista que muestra resumen de ventas por producto CREATE VIEW resumen\_ventas\_productos AS SELECT p.nombre\_producto, COUNT(v.id) as total\_ventas, SUM(v.cantidad) as unidades\_vendidas, SUM(v.cantidad \* p.precio) as ingresos\_totales FROM productos p JOIN ventas v ON p.id = v.producto\_id GROUP BY p.nombre\_producto; ``` \### 2. Vista para Recursos Humanos ```sql \-- Vista que muestra información de empleados con sus departamentos CREATE VIEW info\_empleados AS SELECT e.id, e.nombre, e.apellido, d.nombre as departamento, e.salario, e.fecha\_contratacion FROM empleados e JOIN departamentos d ON e.departamento\_id = d.id WHERE e.activo = true; ``` \### 3. Vista para Sistema Educativo ```sql \-- Vista que muestra promedio de calificaciones por estudiante CREATE VIEW promedio\_estudiantes AS SELECT e.nombre, c.nombre\_curso, AVG(n.calificacion) as promedio, COUNT(n.id) as total\_evaluaciones FROM estudiantes e JOIN notas n ON e.id = n.estudiante\_id JOIN cursos c ON n.curso\_id = c.id GROUP BY e.nombre, c.nombre\_curso; ``` \### Ventajas y Usos Principales: 1\. \*\*Simplificación de Consultas Complejas\*\* ```sql \-- En lugar de escribir una consulta compleja SELECT \* FROM resumen\_ventas\_productos WHERE ingresos\_totales > 10000; ``` 2\. \*\*Seguridad de Datos\*\* ```sql \-- Vista que oculta información sensible CREATE VIEW datos\_publicos\_empleados AS SELECT nombre, departamento, fecha\_contratacion FROM info\_empleados; ``` 3\. \*\*Consistencia de Datos\*\* ```sql \-- Vista que asegura formato consistente CREATE VIEW clientes\_formateados AS SELECT id, UPPER(nombre) as nombre, LOWER(email) as email, FORMAT(telefono, '###-###-####') as telefono FROM clientes; ``` \### Casos de Uso Reales: 1\. \*\*Reportes Financieros\*\* ```sql CREATE VIEW reporte\_financiero\_mensual AS SELECT DATE\_TRUNC('month', fecha) as mes, SUM(monto) as ingresos\_totales, COUNT(DISTINCT cliente\_id) as clientes\_unicos FROM transacciones GROUP BY DATE\_TRUNC('month', fecha); ``` 2\. \*\*Dashboard de Métricas\*\* ```sql CREATE VIEW metricas\_diarias AS SELECT fecha, COUNT(usuarios\_activos) as usuarios\_activos, SUM(tiempo\_sesion) / COUNT(id) as tiempo\_promedio\_sesion, COUNT(CASE WHEN es\_nuevo = true THEN 1 END) as nuevos\_usuarios FROM estadisticas\_uso GROUP BY fecha; ``` \### Beneficios Principales: 1\. \*\*Reutilización de código\*\* \- Evitas escribir las mismas consultas complejas repetidamente \- Mantenimiento más fácil 2\. \*\*Seguridad\*\* \- Control de acceso a datos sensibles \- Exposición limitada de información 3\. \*\*Rendimiento\*\* \- Algunas bases de datos materializan las vistas \- Consultas complejas se ejecutan más rápido 4\. \*\*Abstracción\*\* \- Los usuarios no necesitan conocer la estructura completa de la base de datos \- Simplifica el acceso a datos para usuarios no técnicos \### Ejemplo de Uso Práctico: ```sql \-- Crear la vista CREATE VIEW ventas\_mensuales AS SELECT EXTRACT(YEAR FROM fecha) as año, EXTRACT(MONTH FROM fecha) as mes, SUM(monto) as total\_ventas, COUNT(\*) as numero\_transacciones FROM ventas GROUP BY EXTRACT(YEAR FROM fecha), EXTRACT(MONTH FROM fecha); \-- Usar la vista SELECT \* FROM ventas\_mensuales WHERE año = 2024 AND total\_ventas > 10000 ORDER BY mes; ``` Las vistas son especialmente útiles en: \- Aplicaciones empresariales grandes \- Sistemas con múltiples usuarios \- Reportes recurrentes \- Casos donde la seguridad de datos es crítica
![](https://static.platzi.com/media/user_upload/image-2a5ae0e9-2655-4ffc-8453-81f5e424c62f.jpg)
Les comparto la view que cree: CREATE OR REPLACE VIEW teacher\_course AS SELECT instructors.INSTRUCTORID, instructors.FIRSTNAME, courses.COURSENAME FROM instructors INNER JOIN courses ON instructors.INSTRUCTORID = courses.INSTRUCTORID;
No estoy muy familiarizado con sql workbench y hasta ahora en la clase 26 supe como ver las tablas en el panel ja
\-- Hacer una vista en la que tenga los estudiantes y sus crusos inscritos `CREATE OR REPLACE VIEW students_courses as` `select students.name, courses.course_name` `from enrollments` `join students on students.id = enrollments.student_id` `join courses on courses.id = enrollments.course_id;`
SELECT C.CourseID, C.CourseName, C.Description, C.DurationHours, I.InstructorID, I.FirstName, I.LastName FROM Courses C INNER JOIN Instructors I ON C.InstructorID = I.InstructorID WHERE C.DurationHours > 5;
Dejo una metáfora de las vistas materializadas y Caperucita Roja: *Imagina que Caperucita Roja está caminando por el bosque y decide visitar la casa de su abuela. Cada vez que quiere saber si la abuela está en casa, tiene que caminar hasta allí (esto sería como una **vista normal**: cada vez que ejecutas una consulta, recorres todo el "bosque" de datos).* *Ahora, imagina que en lugar de caminar hasta la casa cada vez, Caperucita decide **guardar una foto de la abuela en casa** la primera vez que la ve. Luego, cada vez que quiera saber si la abuela está en casa, simplemente **mira la foto** que ya tiene guardada (esto sería como una **vista materializada**: en lugar de ejecutar la consulta cada vez, accedes a una versión "guardada" o "pre-calculada" de los datos).* *Sin embargo, hay un problema: la abuela podría haber salido de casa después de que Caperucita tomó la foto. Si Caperucita quiere estar segura de que la abuela sigue en casa, tiene que **actualizar** su foto, tal como tienes que refrescar una vista materializada para asegurarte de que los datos siguen siendo correctos.*
Realice una vista que permita ver los cursos registrados, nombre de alumnos y de los maestros:CREATE OR REPLACE VIEW VW\_COURSE AS ```js CREATE OR REPLACE VIEW VW_COURSE AS SELECT CONCAT(S.FIRSTNAME, ' ', S.LASTNAME) AS 'STUDENT', S.EMAIL AS 'CONTACT', C.COURSENAME AS 'CURSE', CONCAT(I.FIRSTNAME, ' ', I.LASTNAME) AS 'TEACHER' FROM STUDENT_COURSE SC LEFT JOIN COURSES C ON SC.COURSEID = C.COURSEID LEFT JOIN STUDENTS S ON SC.STUDENTID = S.STUDENTID LEFT JOIN INSTRUCTORS I ON C.INSTRUCTORID = I.INSTRUCTORID ; ``` SELECT CONCAT(S.FIRSTNAME, ' ', S.LASTNAME) AS 'STUDENT', S.EMAIL AS 'CONTACT', C.COURSENAME AS 'CURSE', CONCAT(I.FIRSTNAME, ' ', I.LASTNAME) AS 'TEACHER' FROM STUDENT\_COURSE SC LEFT JOIN COURSES C ON SC.COURSEID = C.COURSEID LEFT JOIN STUDENTS S ON SC.STUDENTID = S.STUDENTID LEFT JOIN INSTRUCTORS I ON C.INSTRUCTORID = I.INSTRUCTORID ;
CREATE VIEW VW\_CLASE AS SELECT CLASE.NOMBRECLASE, INSTRUCTOR.PRIMERNOMBRE FROM INSTRUCTOR INNER JOIN CLASE on CLASE.IDCLASE = INSTRUCTOR.IDINSTRUCTOR;
```js CREATE OR REPLACE VIEW VW_TOP_3_MOST_PAID AS SELECT FIRSTNAME, LASTNAME, SALARY FROM INSTRUCTORS ORDER BY SALARY DESC LIMIT 3; ```CREATE OR REPLACE VIEW VW\_TOP\_3\_MOST\_PAID AS SELECT FIRSTNAME, LASTNAME, SALARY FROM INSTRUCTORS ORDER BY SALARY DESC LIMIT 3;
\### VIEWS \> Las vistas nos permiten limitar la cantidad de información que el usuario va a ver o al proceso que va a requerir \> la información de esta forma estamos optimizando el rendimiento al no tener que consultar todo. ```mysql \-- CREAR VISTA CREATE OR REPLACE VIEW V\_STUDENTS AS SELECT STUDENTID, FIRSTNAME, LASTNAME FROM STUDENTS; ```
De las vistas, podemos sacar todo su provecho cuando la usamos en el desarrollo. Esto permitira que llames la vista desde allí en vez de realizar la consulta.
Les recomiendo ver el curso práctico de bases de datos con postgreSQL y el anterior de bases de datos para entender todo eso mucho mejor.
EJEMPLO DE VISTA: CREATE OR REPLACE VIEW PRODUCTS\_VIEW AS SELECT PRODUCTS.NAME\_PRODUCT , BRAND.NAME\_BRAND ,PRODUCTS.PRICE FROM PRODUCTS INNER JOIN BRAND ON BRAND.ID\_BRAND = PRODUCTS.ID\_BRAND AND PRICE > 200
Como dato interesante: En SQL Server la palabra reservada no es REPLACE sino ALTER
CREATE OR REPLACE VIEW VW\_INSTRUCTORS AS SELECT I.INSTRUCTORID, I.FIRSTNAME, I.LASTNAME, I.SALARY FROM INSTRUCTORS I INNER JOIN COURSES C ON I.INSTRUCTORID = C.INSTRUCTORID WHERE C.COURSEID > 1;
Una vista puede simplificar consultas complejas al encapsularlas en una sola "tabla virtual". Luego, puedes seleccionar datos de esta vista como si fuera una tabla regular, sin tener que escribir la consulta compleja cada vez.
![](https://static.platzi.com/media/user_upload/image-b690b1bb-48d4-4e1b-9113-01009c056e8b.jpg)
Extraer (Extraer datos de BD) Transform (Transformación y Manipulación de los datos) Load (Carga de Vistas de Información de la información transformada).
CREATE VIEW vista\_productos AS SELECT marca.marca, idProducto, producto, precio FROM producto INNER JOIN marca ON producto.marca = marca.id\_marca WHERE id\_marca >2;
Muy bien explicado 👏