¡El poder de los datos!
¡El poder de los datos!
Introducción a las bases de datos relacionales
Buenas prácticas de bases de datos con SQL
Tipos de datos en SQL
¿Cómo crear una base de datos en SQL?
Práctica: Tu primera consulta en bases de datos
Historia y Evolución de SQL
Práctica: Creación de Tablas en SQL (CREATE TABLE)
Manipulación de Datos
Insertando Datos con SQL (INSERT)
Consultas y Selecciones en SQL (SELECT)
Práctica: SELECT en SQL
Actualización de Datos con SQL (UPDATE)
Eliminación de Datos con SQL (DELETE)
Práctica: CRUD con SQL
Manipulación Avanzada de Datos
Instalación de MySQL Server y MySQL Workbench
¿Qué es la cláusula WHERE de SQL?
Filtrar y Ordenar Datos en SQL (LIKE)
Práctica: Filtrar Datos con WHERE en SQL
Cláusulas de Comparación Textual en SQL (AND, NULL, IN, NOT)
Funciones de Aritmética Básica en SQL (COUNT, SUM, AVG)
Funciones de Aritmética Básica en SQL (MIN, MAX)
Agrupación de Datos
Agrupación de Datos en SQL: GROUP BY, HAVING y CASE para Análisis Avanzado
Práctica: Agrupamiento y Ordenamiento de Datos
Tipos de JOIN en SQL
¿Cómo funciona INNER JOIN, LEFT JOIN, RIGHT JOIN y FULL JOIN?
Práctica: LEFT JOIN en SQL
Transformación de Datos
Vistas Materializadas en SQL: Como optimizar tus consultas y reportes.
Práctica: Crear Vistas Materializadas en SQL
Optimización de Bases de Datos con SQL: CREATE INDEX y TRIGGER
Vistas Materializadas y Temporales en SQL
Expresiones de Tablas Comunes (CTE) en SQL
Procedimientos Almacenados
Procedimientos Almacenados en SQL
Procedimientos Almacenados en SQL: Gestión de Variables y Manejo de Excepciones
Administración de Base de Datos
Respaldos y Restauración de Bases de Datos
Seguridad en Bases de Datos SQL
Análisis de Datos Avanzados
Potenciando los Datos en la Nube: Data Science, Big Data, ML e AI
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
Si ya tienes una cuenta,
Procedimientos Almacenados en SQL
31/36Recursos
Aportes 30
Preguntas 2
Ordenar por:
Mucha producción audiovisual, animaciones, pero pocas explicaciones, cero práctica. Sería ideal que al menos corriera los scripts.
Caro 👩💻 si utilizamos DELIMITER podemos deliminar el procedimiento en SQL
`DELIMITER //`
`CREATE PROCEDURE spInsertEmployee(`
` IN FirstName NVARCHAR(50),`
` IN LastName NVARCHAR(50),`
` IN DepartmentID INT,`
` IN Salary DECIMAL(10, 2),`
` IN HireDate DATE`
`)`
`BEGIN`
` INSERT INTO Employees (FirstName, LastName, DepartmentID, Salary, HireDate)`
` VALUES (FirstName, LastName, DepartmentID, Salary, HireDate);`
`END //`
`DELIMITER ;`
Aqui va mi feedback:
1. Conceptos extensos como los mencionados hasta el minuto 1:53 recomiendo algun tipo de ayuda visual paralela.
2. Se comprende mejor, si se compara vs crear una sintaxis completa. Para entender la diferencia.
3. Explicar varios lenguajes en MySQL puede confuso si no se detalla en cual caso usar cua.
Profe Caro, sin duda tienes un gran conocimiento, simplificar puede ser mejor en varios puntos.
Ejemplo\_ Explicar un concepto en 1 o dos minutos , puede ayudarte como idea principal un slide.
a alguien le corrio el codigo? me sale error de sintaxis escribiendolo tal cual
El problema del es curso es que me cuenta todo pero no me muestra procedimiento, hace falta material de apoyo. hay punto donde parece un audio curso
```js
CREATE OR REPLACE PROCEDURE spInsertEmployee(
IN first_name VARCHAR(50),
IN last_name VARCHAR(50),
IN email VARCHAR(100),
IN job_title VARCHAR(50),
IN department_id INT,
IN salary NUMERIC(10, 2),
IN hire_date DATE
)
LANGUAGE plpgsql
AS $$
BEGIN
INSERT INTO employees (first_name, last_name, email, job_title, department_id, salary, hire_date)
VALUES (first_name, last_name, email, job_title, department_id, salary, hire_date);
END;
$$;
CALL spInsertEmployee(
'Juan',
'Lopez',
'[email protected]',
'Manager',
3,
14000,
'2024-03-01'
);
```
# Detalles del Procedimiento Para PostgreSQL
* **Nombre**: `spInsertEmployee`
* **Parámetros de Entrada**:
* `first_name` (tipo `VARCHAR(50)`)
* `last_name` (tipo `VARCHAR(50)`)
* `email` (tipo `VARCHAR(100)`)
* `job_title` (tipo `VARCHAR(50)`)
* `department_id` (tipo `INT`)
* `salary` (tipo `NUMERIC(10, 2)`)
* `hire_date` (tipo `DATE`)
los procedimientos van muy de la mano con los jobs
los jobs lo que hacen es automatizar la ejecucion de los procedimientos ej un procedimiento que inserta datos creando el job hago que se ejecute cada dia o n veces por dia ,semana,etc...
Una consulta, veo que en los comentarios la mayoría están utilizando DELIMITER $$, ¿para qué sirve? en la clase no vi cuando lo ocupo :/
Usando esTe codigo me funcionó, le tuve que preguntar a Dios (chatgpt):
```js
DELIMITER $$
CREATE PROCEDURE spInsertEmployee(
IN pFirstName NVARCHAR(50),
IN pLastName NVARCHAR(50),
IN pDepartmentID INT,
IN pSalary DECIMAL(10, 2),
IN pHireDate DATE
)
BEGIN
INSERT INTO Employees (FirstName, LastName, DepartmentID, Salary, HireDate)
VALUES (pFirstName, pLastName, pDepartmentID, pSalary, pHireDate);
END$$
DELIMITER ;
-- Llamar al procedimiento almacenado
CALL spInsertEmployee('VICTOR', 'AUDITORE', 2, 56000, '2024-05-01');
```DELIMITER $$
CREATE PROCEDURE spInsertEmployee(
IN pFirstName NVARCHAR(50),
IN pLastName NVARCHAR(50),
IN pDepartmentID INT,
IN pSalary DECIMAL(10, 2),
IN pHireDate DATE
)
BEGIN
INSERT INTO Employees (FirstName, LastName, DepartmentID, Salary, HireDate)
VALUES (pFirstName, pLastName, pDepartmentID, pSalary, pHireDate);
END$$
DELIMITER ;
\-- Llamar al procedimiento almacenado
CALL spInsertEmployee('VICTOR', 'AUDITORE', 2, 56000, '2024-05-01');
Alguien si pudo correr en Workbench algun Stored Procedure, a mi me marca error de los del varchart y no supe que hacer
Procedimiento almacenado para insertar nuevo instructor con verificacion NULL
CREATE PROCEDURE insert\_instructor(
@first\_name VARCHAR(50),
@last\_name VARCHAR(50),
@email VARCHAR(100),
@salary DECIMAL(10,2),
@load\_date DATE,
@update\_date DATE
)
BEGIN
IF
@first\_name IS NULL OR
@last\_name IS NULL OR
@email IS NULL OR
@salary IS NULL OR
@load\_date IS NULL OR
@update\_date IS NULL
THEN
SIGNAL SQLSTATE '45000' SET MESSAGE\_TEXT = 'Faltan datos para insertar un instructor.';
ELSE
INSERT INTO INSTRUCTORS
(
FIRSTNAME, LASTNAME, EMAIL, SALARY, LOAD\_DATE, UPDATE\_DATE
) VALUES (
@first\_name, @last\_name, @email, @salary, @load\_date, @update\_date
);
END IF;
END;
Soy yo o se ve muy nerviosa? hasta temblando de la mano derecha
Generalmente no califico los cursos pero este si es necesario calificarlo para que hagan las correcciones necesarias.
Todo mal, no ponen los codigos de las tablas, no indican que vamos a cambiar de schema, muy poca expliacion.
En la app sí están los recursos, en la web no.
o soy muy menso.
o ambas cosas.
Esto vendría a ser como crear una función en programación, en MySQl se utilizaría la sentencia CALL para ''llamar a la función" y asignar los parametros.
Buena explicación, estoy de acuerdo que se debe de hacer mas ejecución de código, pero es una buena introducción a SQL.
dependiendo de la versión de mysql que se esté utilizando puede ser opcional o no el uso de **AS**, al igual que requerir delimitar de una manera más explicita el campo del procedimiento
`DELIMITER $$`
`CREATE PROCEDURE spInsertInstructors(`
` IN FIRSTNAME VARCHAR(50),`
` IN LASTNAME VARCHAR(50),`
` IN EMAIL VARCHAR(100),`
` IN SALARY DECIMAL(10, 2)`
`)`
`BEGIN`
` INSERT INTO INSTRUCTORS (FIRSTNAME, LASTNAME, EMAIL, SALARY)`
` VALUES (FIRSTNAME, LASTNAME, EMAIL, SALARY);`
`END$$`
`DELIMITER ;`
```js
#BORRAR DATOS
DELIMITER //
CREATE PROCEDURE SP_ELIMINAR_INSTRUCTOR(
ID INT
)
BEGIN
DELETE FROM INSTRUCTOR
WHERE
INSTRUCTORID = ID;
END //
DELIMITER ;
CALL SP_ELIMINAR_INSTRUCTOR(7);
```Decidi hacer los cruds de los procedures se que hay mas pero estoy cansado de elaborar mas complejos. Sus datos extra ya viene de su imaginacion y logica.
```js
#ACTUALIZAR UN INSTRUCOTR
DELIMITER //
CREATE PROCEDURE SP_ACTUALIZAR_INSTRUCTOR(
ID INT,
FIRSTNAME NVARCHAR(50),
LASTNAME NVARCHAR(50),
EMAIL NVARCHAR(50),
SALARY DECIMAL(10,2)
)
BEGIN
UPDATE INSTRUCTOR
SET FIRSTNAME = FIRSTNAME,
LASTNAME = LASTNAME,
EMAIL = EMAIL,
SALARY = SALARY
WHERE
INSTRUCTORID = ID;
END //
DELIMITER ;
CALL SP_ACTUALIZAR_INSTRUCTOR(7, 'Eduardo', 'Camavinga', '[email protected]', 50000);
```
```js
#LISTADO DE ELEMENTOS
DELIMITER //
CREATE PROCEDURE SP_LISTARCURSOS()
BEGIN
SELECT * FROM COURSES;
END //
DELIMITER ;
CALL SP_LISTARCURSOS();
```
```js
#INSERTAR ELEMENTOS
DELIMITER //
CREATE PROCEDURE SP_INSERT_INSTRUCTOR(
IN FIRSTNAME NVARCHAR(50),
IN LASTNAME NVARCHAR(100),
IN EMAIL NVARCHAR(50),
IN SALARY DECIMAL (10, 2)
)
BEGIN
INSERT INTO INSTRUCTOR (FIRSTNAME, LASTNAME, EMAIL, SALARY)
VALUES (FIRSTNAME, LASTNAME, EMAIL, SALARY);
END //
DELIMITER ;
CALL SP_INSERT_INSTRUCTOR('Eduardo', 'Camavinga', '[email protected]', 3423.32);
```
Lo haria con python y sus poderosas bibliotecas, ya que es mas automatizado que sql, y se puede extraer archivos de todo tipo en el jajaj
PARA AQUELLOS PERDIDOS.
uso mariaDB, pero creo que funciona para MySQL.
usé el delimiter y corrió el script. Buena suerte
```js
DELIMITER //
CREATE PROCEDURE insertar_student (
IN firstname VARCHAR(200),
IN lastname VARCHAR(200),
IN age int,
IN email_student VARCHAR(300)
)
BEGIN
INSERT INTO `course`.`students` (firstname, lastname, age, email_student)
VALUES (firstname, lastname, age, email_student);
END //
DELIMITER ;
CALL insertar_student('Richard', 'Urrego', 20, '[email protected]');CALL insertar_student('Manuel', 'Sanz', 23, '[email protected]');
```DELIMITER //
CREATE PROCEDURE insertar\_student (
IN firstname VARCHAR(200),
IN lastname VARCHAR(200),
IN age int,
IN email\_student VARCHAR(300)
)
BEGIN
INSERT INTO `course`.`students` (firstname, lastname, age, email\_student)
VALUES (firstname, lastname, age, email\_student);
END //
DELIMITER ;
CALL insertar\_student('Richard', 'Urrego', 20, '[email protected]');CALL insertar\_student('Manuel', 'Sanz', 23, '[email protected]');
Hola, soy nuevo en SQL
si alguien puede aclararme algo, que beneficios trae la aplicación de los procedimientos guardados, en sí nos dijo que a ahorra tiempo en evitar escribir nuevamente la queri
pero en el ejemplo que nos da, llamar al procedimiento es casi igual a introducir los datos directamente en la tabla con `INSERT INTO`, o que otras aplicaciones puede tener los procedimientos guardados
Siento que me está dando clases KarolG jajaja
EL ERROR ES QUE LOS PUNTO Y COMA LOS TOMA SQL COMO EL FIN DE LA SENTENCIA LO QUE SE DEBE HACER ES USAR DELIMTIER // PARA CAMBIAR LA FORMA DE DELIMITAR TEMPORALMENTE
```js
--Crear el procedimiento
CREATE PROCEDURE Ingresar_Estudiante (
IN FIRSTNAME VARCHAR(50),
IN LASTNAME VARCHAR(50),
IN AGE INT,
IN EMAIL VARCHAR(100)
)
BEGIN
INSERT INTO STUDENTS (FIRSTNAME, LASTNAME, AGE, EMAIL)
VALUES (FIRSTNAME, LASTNAME, AGE, EMAIL);
END;
--Ejecutar el procedimiento
CALL Ingresar_Estudiante('John', 'Wick', 51, '[email protected]')
```CREATE PROCEDURE Ingresar\_Estudiante ( IN FIRSTNAME VARCHAR(50), IN LASTNAME VARCHAR(50), IN AGE INT, IN EMAIL VARCHAR(100) ) BEGIN INSERT INTO STUDENTS (FIRSTNAME, LASTNAME, AGE, EMAIL) VALUES (FIRSTNAME, LASTNAME, AGE, EMAIL); END;
Actualizar datos con procedimiento almacenado:
```txt
CREATE PROCEDURE actualizar_employee
@employee_id INT,
@first_name VARCHAR(50),
@last_name VARCHAR(50),
@departament_id INT,
@salary NUMERIC (10,2),
@hire_date DATE
AS
BEGIN
UPDATE EMPLOYEE
SET
first_name = @first_name,
last_name = @last_name,
departament_id = @departament_id,
salary = @salary,
hire_date = @hire_date
WHERE employee_id = @employee_id
END
```Ejecución del procedimiento almacenado:
```js
EXEC actualizar_employee
@employee_id = 1,
@first_name = 'Juan',
@last_name = 'Lopez',
@departament_id = 3,
@salary = 14000,
@hire_date = '2024-03-01'
```
Actualizar datos con procedimiento almacenado:
`CREATE PROCEDURE actualizar_employee`
`@employee_id INT,`
`@first_name VARCHAR(50),`
`@last_name VARCHAR(50),`
`@departament_id INT,`
`@salary NUMERIC (10,2),`
`@hire_date DATE`
`AS`
`BEGIN`
`UPDATE EMPLOYEE `
`SET `
`first_name = @first_name,`
`last_name = @last_name,`
`departament_id = @departament_id,`
`salary = @salary,`
`hire_date = @hire_date`
`WHERE employee_id = @employee_id`
`END`
Ejecución del procedimiento almacenado:
`EXEC actualizar_employee `
`@employee_id = 1,`
`@first_name = 'Juan',`
`@last_name = 'Lopez',`
`@departament_id = 3,`
`@salary = 14000,`
`@hire_date = '2024-03-01'`
Me encanto la clase, muy buena explicación del tema!!
¿Quieres ver más aportes, preguntas y respuestas de la comunidad?