-- EJERCICIO 0. Obtén todos los empleados.
SELECT * FROM HR.EMPLOYEES;

-- EJERCICIO 0.1 Obtén el id de todos los empleados. (OJO únicamente el ID)
-- SELECT * FROM EMPLOYEE_ID; ¡ERROR!.
SELECT EMPLOYEE_ID FROM HR.EMPLOYEES;

-- EJERCICIO 0.2 Obtén el [id, el nombre y el apellido] de todos los empleados.
-- SELECT pepito, juanito, alvaro, andres FROM HR.EMPLOYEES; --SENTENCIA DE EJEMPLO.
SELECT EMPLOYEE_ID,FIRST_NAME, LAST_NAME FROM HR.EMPLOYEES;

-- EJERCICIO 0.3 Obtén el [id, el nombre y el apellido] Y ¡RENOMBRA LAS COLUMNAS! de todos los empleados.
SELECT EMPLOYEE_ID as "ID",FIRST_NAME as "NOMBRE", LAST_NAME AS "APELLIDO" FROM HR.EMPLOYEES;

------------------------------------------------------------------------

-- EJERCICIO 0.4 Obten los empleados que tengan como nombre 'Steven'.
SELECT * FROM HR.EMPLOYEES WHERE FIRST_NAME='Steven';

-- EJERCICIO 0.5 Obtén los empleados que tengan un salario superior a 5000
SELECT * FROM HR.EMPLOYEES WHERE SALARY>5000;

-- EJERCICIO 0.6 Obtén los empleados que tengan un salario igual o inferior a 3000
SELECT * FROM HR.EMPLOYEES WHERE SALARY<=3000;

-- EJERCICIO 0.7 Obtén el id de empleado, nombre, apellido y fecha de contratación de aquellos empleados que tengan un id mayor que 180.
SELECT EMPLOYEE_ID, FIRST_NAME, LAST_NAME, HIRE_DATE FROM HR.EMPLOYEES WHERE EMPLOYEE_ID>180;

-- EJERCICIO 0.8 Obtén los empleados que tengan un salario superior a 5.000 Y ADEMÁS su JOB_ID sea igual a IT_PROG.
-- AND [EQUIVALENTE] &&

-- SELECT * FROM HR.EMPLOYEES WHERE SALARY>5000 AND JOB_ID=IT_PROG; ERROR

-- Aclaración un valor es como un literal siempre tiene que ir entre comillado, sino, entiende que se trata de una columna,
-- de forma similar en programación ocurre cuando diferencia variable y literal.

SELECT * FROM HR.EMPLOYEES WHERE SALARY>5000 AND JOB_ID='IT_PROG';

-- EJERCICIO 0.8 Obtén los empleados que tengan un salario superior a 5.000 O BIEN su JOB_ID sea igual a IT_PROG.
-- OR [EQUIVALENTE] ||

SELECT * FROM HR.EMPLOYEES WHERE SALARY>5000 OR JOB_ID= 'IT_PROG';

-- EJERCICIO 0.9 Obten el id, nombre y apellido de los empleados que tenga el JOB_ID IT_PROG, un salario superior a 1800 
-- y id de empleado inferior a 107.

SELECT EMPLOYEE_ID, FIRST_NAME, LAST_NAME FROM HR.EMPLOYEES WHERE JOB_ID= 'IT_PROG' AND SALARY>1800 AND EMPLOYEE_ID<107;

-- EJERCICIO 0.10 Similar al ejercicio anterior, pero renombrando las columnas por la traducción al Español. (First_Name → Nombre)

SELECT EMPLOYEE_ID AS "ID_EMPLEADO", FIRST_NAME AS "NOMBRE", LAST_NAME AS "APELLIDO" FROM HR.EMPLOYEES WHERE JOB_ID= 'IT_PROG' AND SALARY>1800 AND EMPLOYEE_ID<107;

-- Ejercicio 0.11 Muestra todos los empleados que ganen un salario diferente de 9000
SELECT * FROM HR.EMPLOYEES WHERE SALARY <> 9000;

-- Ejercicio 0.12 Muestra todos los empleados que ganen un salario diferente de 9000 y de 8000
SELECT * FROM HR.EMPLOYEES WHERE SALARY <> 9000 AND SALARY <> 8000;

-- Ejercicio 0.13 Muestra todos los empleados que ganen un salario diferente de 9000,8000,7.500,5000
SELECT * FROM HR.EMPLOYEES WHERE SALARY <> 9000 AND SALARY <> 8000 AND SALARY <> 7500 AND SALARY <> 5000;

-- Ejercicio 0.13.1 Muestra todos los empleados que ganen un salario igual de 9000,8000,7.500,5000,3000,2100
SELECT * FROM HR.EMPLOYEES WHERE SALARY IN (9000,8000,7500,5000,3000,2100);

-- Ejercicio 0.14 Muestra todos los empleados tegan comisión. (ES DECIR, QUE LA COMISIÓN NO SEA NULA).
SELECT * FROM HR.EMPLOYEES WHERE COMMISSION_PCT IS NOT NULL; -- EJERCICIO BONUS.

-- Ejercicio 0.15 Muestra aquellso empleados donde el salario sea mayor que 2.000 y la comissión sea nula.
SELECT * FROM HR.EMPLOYEES WHERE SALARY > 2000 AND COMMISSION_PCT IS NULL;

-- Ejercicio 0.16 Muestra todos los empleados que tengan un salario entre 6.000 y 9.000.
-- SELECT * FROM employees WHERE SALARY < 9000 AND SALARY > 6000; --Poco optimizado.
SELECT * FROM HR.EMPLOYEES WHERE SALARY BETWEEN 6000 AND 9000;
----
-- 0.17 Muestra los empleados cuyo nombre empiece por A.
SELECT * FROM employees WHERE first_name LIKE 'A%';

-- Utilizamos '%' para indicar a la consulta que va cualquier cosa (0 o N carácteres).


-- 0.18 Muestra los empleados cuyo apellido termina por e.
SELECT * FROM employees WHERE last_name LIKE '%e';

-- 0.19 Muestra los empleados cuyo apellido contenga una 'w'.
SELECT * FROM employees WHERE last_name LIKE '%w%';

-- 0.20 Muestra los empleados cuyo nombre contenga tengan 3 carácteres y el caracter del medio sea una e.
SELECT * FROM employees WHERE last_name LIKE '_e_';
-- Utilizamos '_' para indicar a la consulta que hay un caracter (Cualquiera que sea).

-- 0.21 Muestra los empleados cuyo apellido contenga tengan 6 carácteres y el caracter inicial sea A y el final n.
SELECT * FROM employees WHERE last_name LIKE 'A____n';

-- Bloque 1.

-- 1.1 Muestra el id, nombre, apellido de los empleados, salario y trabajo de los empleados que, ganen entre 2000 y 8000, su nombre contenga una A, el apellido contenga una S, y el job_id contenga una I, además excluye los id, 150,151,152,153 y 154 y aquellos donde la comisión sea nula. 
SELECT employee_id, first_name, last_name, salary, job_id FROM employees WHERE salary BETWEEN  2000 and 8000 and first_name LIKE '%a%' and last_name LIKE '%s%' and job_id LIKE '%i%' and employee_id not in (150,151,152,153,154) and commission_pct is null;

-- 1.2 Muestra únicamente el salario y nombre de aquellos empleados que tengan dos 'a' y su salario sea superior a 2000.
SELECT salary, first_name FROM employees WHERE first_name LIKE '%a%a%' and salary>2000;

-- 1.3 Muestra el nombre y salario de todos los empleados que su nombre empiece por A, E o I.
SELECT first_name, salary FROM employees WHERE first_name like 'A%' or first_name like 'E%' or first_name LIKE 'I%'; 

-- 1.4 Muestra el id, nombre, apellido, salario y fecha de contratación (El nombre de la columna debe aparecer en Español, y tal como se expone en el enunciado), y como condiciones: Tenga un salario entre 3000 y 10000, su nombre contenga una 'e', pero no una 'a', su apellido empieze por 'K' o 'M', su job_id contenga 'MAN' o 'CLERK', su id esté entre 150 y 180, y fueron contratados después del 1 de enero de 1999.
 SELECT employee_id as "id", first_name as "Nombre", last_name as "Apellido", salary as "Salario", hire_date as "Fecha de contratación" FROM employees WHERE salary BETWEEN 3000 and 10000 and first_name like '%e%' and first_name not like '%a%' and last_name like 'k%' or last_name like 'M%' and job_id like '%man%' or job_id like '%clerk%' and employee_id  BETWEEN 150 and 180 and hire_date > '1999-01-01';

  -- 1.5 Muestra el id, nombre, apellido, salario y departamento de los empleados que tengan un salario mayor a 4000 o tengan comisión, su nombre tenga exáctamente 3 letras donde la letra final sea 'n' o 'm', su apellido al menos tenga 1 vocal al menos, pertenece a los departamentos 30, 50 o 80 y su job id no sea 'IT_PROG' ni 'AD_VP'.
 SELECT employee_id, first_name, last_name, salary, department_id from employees where (salary > 4000 or commission_pct is not null) and (first_name like '__n' or first_name like '__m') and (last_name like'%a%' or last_name like '%e%' or last_name like '%i%' or last_name like '%o%' or last_name like '%u%') and department_id in (30,50,80) and job_id <> "IT_PROG" and job_id <> "AD_VP"; 

 -- Bloque 2

-- 2.1 Concatena el nombre y apellido de los empleados en una única columna
 SELECT concat(first_name," ",last_name) as "Nombre y Apellido" FROM EMPLOYEES;

-- 2.2 Concatena un nuevo campo llamado correo electrónico, que tengao nombre apellido, y @alumno.es.
SELECT concat(first_name,"_",last_name,"@alumno.es") as "Correo electrónico" FROM employees;

-- 2.3 Obten 2 carácteres a partir del segundo caracter del nombre. [Alejandro → le]
SELECT first_name, substring(first_name,2,2) from employees;

-- 2.4 Muestra los primeros 4 carácteres (año) de la fecha de contratación.
SELECT hire_date, substring(hire_date,1,4) as "Año"  FROM employees;

-- 2.5 Muestra la longitud de los nombres de los empleados, junto al nombre.
SELECT first_name, length(first_name) FROM employees;

-- 2.6 Elimina los espacios en blanco de los alumnos tanto los que están a la izquierda, como los que hay en la derecha.
 SELECT first_name, trim(first_name) FROM employees;

-- 2.7 Elimina los espacios en blanco de los alumnos tanto los que están a la izquierda,.
 SELECT first_name, ltrim(first_name) FROM employees;

-- 2.8 Elimina los espacios en blanco de los alumnos tanto los que están a la derecha.
 SELECT first_name, rtrim(first_name) FROM employees;

-- 2.9 Muestra todos los ejemplos en la misma consulta [2.6, 2.7, 2.8].
SELECT first_name, trim(first_name),ltrim(first_name),rtrim(first_name) FROM employees;

-- 2.10 Muestra los nombres de los empleados, sustituyendo la 'a' por '1'.
 SELECT first_name, replace(replace(first_name, "A","1"),"a","1") FROM employees;

-- 2.11 Muestra los nombres de los empleados, sustituyendo la 'a' por '1', incluyendo mayúsculas y minúsculas.
SELECT first_name, replace(replace(first_name, "A","1"),"a","1") FROM employees;
-- Ejemplo de funcionamiento.
-- Alejandro  
-- → Aplicio el primer replace (El que va dentro) Alejandro → 1lejandro
-- → Aplicio el segundo replace (El que va fuera) Al1j1ndro → 1lej1ndro

-- 2.12 Muestra el nombre de todos los empleados en mayúsculas
 SELECT first_name, UPPER(first_name) from employees;

-- 2.13 Muestra el nombre de todos los empleados en minúsculas
SELECT first_name, LOWER(first_name) from employees;

-- Bloque 2.5
-- 2.51 Crea un nuevo campo llamado correo electrónico, utilizando la letra inicial del nombre, el apellido completo, y la fecha de nacimiento los dos últimos dígitos incluendo @alumno.com.
SELECT concat(SUBSTRING(first_name,1,1),last_name, SUBSTRING(hire_date,3,2), "@alumno.com") as "Correo electrónico" from employees;

-- 2.52 Similar al ejercicio anterior pero convierte todo a minúsculas.
-- SELECT concat(LOWER(SUBSTRING(first_name,1,1)),LOWER(last_name), SUBSTRING(hire_date,3,2), "@alumno.com") as "Correo electrónico" from employees; -- Opción 1.

SELECT LOWER(concat(SUBSTRING(first_name,1,1),last_name, SUBSTRING(hire_date,3,2), "@alumno.com")) as "Correo electrónico" from employees;

-- 2.53 Muestra el JOB_ID de todos los empleados, remplazando las vocales por '$' y transformándo todo a minúsculas, también muestra los campos de nombre, apellidos, salario y fecha de contratación.

SELECT JOB_ID, lower(replace(replace(replace(replace(replace(JOB_ID,"A","$"),"E","$"),"I","$"),"O","$"),"U", "$")) as "Trabajo", first_name, last_name, salary, hire_date from employees;

-- Bloque 3 Funciones de fechas.

-- 3.1 Fecha Actual, junto al nombre.
-- SELECT first_name, now() FROM employees;

-- 3.2 Fecha Actual, junto al nombre.
-- SELECT first_name, curdate() FROM employees;

-- 3.3 Hora Actual, junto al nombre.
-- SELECT first_name, curtime() FROM employees;

-- 3.4 Muestra nombre, apellido, y fecha y hora actual (fecha y hora en la misma columna)
SELECT first_name, last_name, concat(curdate()," | ", curtime()) as "Fecha y hora actual" from employees;

-- 3.5 Muestra la diferncia en días entre la fecha de contratación y la fecha de hoy.
-- SELECT DATEDIFF("1998-01-01","1999-01-01") from DUAL -- Ejemplo de funcionamiento.
-- SELECT DATEDIFF(hire_date, curdate()) from employees;

-- 3.6 Muestra la diferncia en años entre la fecha de contratación y la fecha de hoy.
SELECT  DATEDIFF(hire_date, curdate())/365 as "Años" from employees;

-- 3.7 Muestra todos los empleados que tengan menos de 32 años en la empresa.
 SELECT  DATEDIFF(curdate(),hire_date)/365 as "Años"  from employees WHERE DATEDIFF(curdate(),hire_date)/365 < 32;

-- 3.8 [Bonus] Muestra todos los empleados que su nombre empiece por A.
SELECT * from employees WHERE  first_name LIKE "A%"; -- Opción válida
SELECT * from employees WHERE  SUBSTRING(first_name, 1,1)="A"; 

-- Bloque 4. Funciones de Agrupación.

-- 4.1 Muestra la cantidad de empleados que hay en la tabla employees.
 SELECT COUNT(*) FROM employees;

-- 4.2 Muestra la cantidad de empleados que tienen el trabajo 'IT_PROG'.
SELECT COUNT(*) FROM employees where job_id = "IT_PROG";

-- 4.3 Muestra la cantidad de empleados que tienen un salario superior a 2000 y su JOB_ID contiene una P.
SELECT COUNT(*) FROM employees where salary>2000 and JOB_ID like '%P%';

-- 4.4 Muestra la cantidad de empleados que tienen un salario entre 2.000 y 5.000 y su JOB_ID contiene una P y una O.
SELECT COUNT(*) FROM employees where salary BETWEEN 2000 and 5000 and job_id like '%p%' and job_id like '%o%';

-- 4.5 Muestra la suma de todos los salarios.
-- sum(salary)
-- SELECT sum(salary) FROM employees;

-- 4.6 Muestra la suma de todos los salarios exceptuando los salarios que sean iguales de 17.000 y 4.800.
SELECT sum(salary) FROM employees where salary <> 17000 and salary <> 4000; -- Forma Convencional
SELECT sum(salary) FROM employees where salary NOT IN (17000,4000); -- Forma más eficiente.

-- 4.6 Muestra la suma de los salarios de los empleados que estén en el departamento 100 y su salario esté entre 2.000 y 7.000
 SELECT sum(salary) FROM employees where department_id = 100 and salary BETWEEN 2000 and 7000;

 -- 4.8 Muestra la media de salario de los empleados cuyo nombre empiece por A.
-- AVG(salary)
SELECT AVG(salary) FROM employees where first_name like 'A%';

-- 4.9 Muestra la media de salario de los empleados cuyo departamento sea 90.
SELECT AVG(salary) FROM employees where department_id = 90;

-- 4.10 Muestra el salario máximo de los empleados con departamento 90.
SELECT MAX(salary) FROM employees where department_id = 90;

-- 4.11 Muestra el salario minimo de los empleados con departamento 90.
SELECT MIN(salary) FROM employees where department_id = 90;

-- Bloque 5. Uso de GROUP BY.

-- 5.0 Muestra los empleados *agrupando* por departamentos.
SELECT department_id, count(employee_id) FROM employees GROUP BY department_id;

-- 5.1 Muestra la media de los salarios agrupados por departamentos.
SELECT department_id, AVG(salary) FROM employees GROUP BY department_id;

-- 5.2 Muestra los máximos salarios por departamentos excluyendo el departamento 90.
SELECT department_id, MAX(salary) FROM employees WHERE department_id <> 90 GROUP BY department_id; 

-- 5.3 Muestra la cantidad de empleados agrupados por el jefe de los mismos. 
SELECT manager_id, count(employee_id) FROM employees  GROUP BY manager_id;

-- 5.4 Muestra la cantidad de empleados, la media de salarios, los salarios mínimos, y máximos agrupados por el jefe de los empleados..
SELECT manager_id, count(employee_id), AVG(salary), MIN(salary), MAX(salary) FROM employees GROUP BY manager_id;

-- Bloque 6. Uso de ORDER BY.

-- 6.0 Muestra la cantidad de empleados por departamentos, mostrando los departamentos en orden descendente.
SELECT department_id, COUNT(employee_id) FROM employees GROUP BY department_id ORDER BY  department_id DESC;
-- Importante, primero anotar la columna o función por la que discrimino y luego poner [ASC | DESC]

-- 6.1 Muestra los salarios mínimos agrupados por departamento mostrando primero los salarios más altos.
-- SELECT department_id, MIN(salary) FROM employees GROUP BY department_id ORDER BY salary DESC; 

-- 6.2 Muestra los salarios máximos agrupados por departamento mostrando primero los salarios más bajos.
SELECT department_id, MAX(salary) FROM employees GROUP BY department_id ORDER BY salary ASC;

-- 6.3 Muestra los salarios máximos agrupados por departamento mostrando primero los salarios más bajos, y en caso de empate como segundo discriminante que tenga en cuenta el departmanet_id.

SELECT department_id, MAX(salary) FROM employees GROUP BY department_id ORDER BY MAX(salary) ASC, department_id DESC;

-- 6.4 Muestra el conteo de los empleados, salarios máximos, mínimos de aquellos empleados que  terminen por A y agrupalo por Department id ordenando por salario máximo y mínimo.
SELECT employee_id, COUNT(employee_id), MAX(salary), MIN(salary) FROM employees where first_name like '%A' GROUP BY department_id ORDER BY MAX(salary) DESC, MIN(salary) ASC;

-- 6.5 Muestra la cantidad de historial que tiene cada empleados TABLA → (job_history).
SELECT employee_id, COUNT(job_id) FROM job_history GROUP BY employee_id;

-- 6.6 Muestra la cantidad de historial que tiene cada empleados TABLA → (job_history). Además ordena descendentemente por la cantidad de historial.
SELECT employee_id, COUNT(job_id) FROM job_history GROUP BY employee_id ORDER BY COUNT(job_id) DESC;

-- 6.7 Muestra la cantidad de historial que tiene cada empleados TABLA → (job_history). Además ordena descendentemente por la cantidad de historial y en caso de empate por id de empleado descedentemente.
SELECT employee_id, COUNT(job_id) FROM job_history GROUP BY employee_id ORDER BY COUNT(job_id) DESC, employee_id DESC;

-- HAVING (Condiciones dentro de una función de agrupación).

-- 7.0 Muestra una agrupación de departamentos y la cantidad de empleados en dichos departamentos, mostrando solo aquellos departamentos que sean más de 10 empleados.
-- Ahora la condición reside en la función de agrupación, es decir, no queremos filtrar ninguna fila en concreto sino una función de agrupado dentro de una fila.
SELECT department_id, COUNT(employee_id) FROM employees GROUP BY department_id;

SELECT department_id, COUNT(employee_id) FROM employees WHERE COUNT(employee_id)>10 GROUP BY department_id ; -- Está mal porque no podemos filtrar sobre agrupaciones usando WHERE.
SELECT department_id, COUNT(employee_id) FROM employees GROUP BY department_id HAVING COUNT(employee_id)>10;

-- 7.1 Muestra una agrupación de departamentos y la cantidad de 
-- empleados en dichos departamentos, filtrando los empleados por aquellos 
-- que su nombre empiece por A o su apellido termina por A, y el resultado 
-- de la agrupación (empleados en cada departamento) sea mayor de 2.

SELECT department_id, COUNT(employee_id) FROM employees WHERE first_name like 'A%' OR last_name like '%a' GROUP BY department_id HAVING COUNT(employee_id)>2;

--  7.2 Muestra los jefes (manager_id) y la cantidad de empleados que tiene cada jefe, excluye aquellos empleados que su salario esté por debajo de 3.000 
-- y muestra solo aquellos jefes que tengan a su cargo más de 3 empleados.
SELECT manager_id, COUNT(employee_ID) FROM employees WHERE salary>=3000 GROUP BY manager_id HAVING COUNT(employee_id)>3;

-- 7.3 Muestra la cantidad de empleados por JOB_ID excluyendo aquellos que su 
-- nombre tenga más de 7 carácteres, mostrando solo los trabajos que tengan más de 4 empleados por trabajo.
SELECT job_id, COUNT(employee_ID) FROM employees WHERE job_id GROUP BY job_id HAVING employee_id>4; -- ❌
SELECT job_id, COUNT(employee_ID) FROM employees WHERE length(first_name)<=7 GROUP BY job_id HAVING COUNT(employee_id)>4;

-- 7.4 Muestra la suma de salarios por trabajo (job_id) incluyendo solos los registros que tengan un salario mayor que 5000 y donde la suma sea mayor que 70.000
SELECT job_id, SUM(salary) FROM employees WHERE salary>5000 GROUP BY job_id HAVING sum(salary)>70000;

-- 7.5 Muestra la suma de salarios por jefe (manager_id) excluyendo los empleados que tienen id 103,102,104  
-- e incluyendo los que tienen departamento 80 y 50, muestra aquellos que el salario sea inferior a 60.000 y ordena el resultado por orden de más salario a menos
-- SELECT manager_id, SUM(salary) FROM employees WHERE employee_id <> 103 and employee_id <> 102 and employee_id <>104 and department_id = 80 and department_id = 50
-- GROUP BY salary<6000 ORDER BY salary desc;

SELECT manager_id, SUM(salary) FROM employees WHERE employee_id not in (103,102,104) and department_id = 80 and department_id = 50
GROUP BY salary<6000 ORDER BY salary desc;

-- 7.7 Muestra la media de comisiones agrupadas por manager, excluyendo aquellas que no superan el 0.1.
SELECT manager_id, AVG(commission_pct) FROM employees GROUP BY manager_id HAVING AVG(commission_pct)>=0.1;

-- 7.8 Trabajo de investigación:
-- 7.8.1 Muestra los empleados que tengan el JOB_ID 'IT_PROG'.
SELECT * FROM employees WHERE job_id = 'IT_PROG';

-- 7.8.2 Puedes decirme todos los jefes que están involucrados en este trabajo.
SELECT manager_id  FROM employees WHERE job_id = 'IT_PROG' GROUP BY manager_id;

-- 7.8.3 Muestra la fecha del empleado más antiguo que sea programador (IT_PROG)
SELECT hire_date FROM employees WHERE job_id = 'IT_PROG' GROUP BY hire_date HAVING COUNT(hire_date)<=1;
SELECT hire_date FROM EMPLOYEES WHERE job_id = 'IT_PROG' GROUP BY job_id HAVING MAX(HIRE_DATE);

-- 7.8.4 Cuantos empleados tiene el trabajo de IT_PROG sin tener en cuenta aquellos que su jefe es el id 102.
SELECT job_id, COUNT(employee_id) FROM employees WHERE job_id = 'IT_PROG' AND manager_id<>102;

-- 7.8.5 Muestra la media salarial, el máximo salario y el mínimo de la consulta anterior (aparte de los descrito en el mismo enunciado.).
SELECT job_id, COUNT(employee_id), AVG(salary), MAX(SALARY), MIN(SALARY) FROM employees WHERE job_id = 'IT_PROG' AND manager_id<>102;

-- CONSULTAS ENTRE TABLAS
-- 8.1 Muestra los empleados con sus departamentos (solo los que tengan departamentos asignados)

SELECT * FROM employees
INNER JOIN departments -- tabla con la que vas a unir
ON  employees.department_id = departments.department_id; -- porque clave los voy a unir (de ambas tablas)

-- 8.2 Muestra todos los empleados, mostrando departamento si existe.
-- Ejemplo para mostrar las dos opciones con dos planteamientos diferentes.
SELECT * FROM employees
LEFT JOIN departments
ON employees.department_id = departments.department_id;

SELECT * FROM departments
RIGHT JOIN employees
ON employees.department_id = departments.department_id;

-- 8.3 Muestra solo los empleados que tengan trabajos y todos los trabajos (tabla jobs).
 SELECT * FROM employees
 RIGHT JOIN jobs
 ON employees.job_id = jobs.job_id;
 
 -- 8.4 Muestra las localizaciones de todos los departamentos. [Mostrando id de departamento, nombre de departamento, calle, codigo postal ciudad y provincia].
 SELECT departments.department_id, departments.department_name, locations.street_address, locations.postal_code, locations.city, locations.state_province FROM departments
 LEFT JOIN locations
 ON locations.location_id = departments.location_id;
 
-- 8.5 Muestra el id, nombre,  apellido, fecha de inicio y fecha de fin de los empleados que tengan historial de trabajos.
SELECT employees.employee_id, employees.first_name, employees.last_name, job_history.start_date, job_history.end_date  FROM job_history
INNER JOIN employees
ON employees.employee_id = job_history.employee_id;

-- 8.6 Muestra los nombres del trabajo donde han trabajado los antiguos empleados.
SELECT jobs.job_title, job_history.start_date, job_history.end_date FROM job_history
INNER JOIN jobs
ON job_history.job_id = jobs.job_id;

-- 8.7 Muestra los departamentos (id y nombre) con sus respectivos jefes (mostrando nombre y apellidos), sino tuviese jefe muestra el departamento de igual forma.
SELECT departments.department_id, departments.manager_id, employees.first_name, employees.last_name   FROM departments
LEFT JOIN employees
ON departments.manager_id = employees.employee_id;

-- 8.8 Muestra los empleados (id, nombre y apellidos) y los jefes asociados a los empleados (id, nombre y apellido) indica en el nombre de la columna cual es empleado y cual jefe
SELECT empleados.employee_id as "id_empleado", empleados.first_name as "Nombre_Empleado", 
empleados.last_name as "Apellido_Emoleado", jefe.employee_id as "Id_jefe", 
jefe.first_name as "Nombre_Jefe", jefe.last_name as "Apellido_ Jefe" 
FROM employees empleados INNER JOIN employees jefe ON empleados.manager_id = jefe.employee_id;

-- 8.9 Muestra los empleados (id, nombre y apellido), y el titulo del trabajo y el nombre de departamento.
-- Con este consulta solo se muetran aquellos empleados que tienen departamento y job_id
SELECT employee_id, first_name, last_name, jobs.job_title, departments.department_name FROM employees
INNER JOIN jobs ON employees.job_id = jobs.job_id
INNER JOIN departments ON employees.department_id = departments.department_id;

-- ¿Qué campos (EMPLOYEES) no se muestran? 
SELECT * FROM EMPLOYEES WHERE job_id is null or department_id is null;

-- 8.10 Muestra los nombres de departamentos, el id, nombre y apellido del jefe de dicho departamento y el titulo de trabajo del jefe.
-- Problema detectado: Una cosa es como se relacionan las tablas para poder utilizar sus campos, y otra distinta es que campos muestro.
SELECT departments.department_name, employee_id, first_name, last_name,jobs.job_title FROM employees
INNER JOIN departments ON departments.manager_id = employees.employee_id
INNER JOIN jobs ON jobs.job_id =  employees.job_id;

-- 8.11 Muestra el nombre y apellido de empleados, nombre de departamento al que pertenece y ciudad a la que corresponde dicho departamento.
SELECT first_name, last_name, departments.department_name, locations.city FROM employees
INNER JOIN departments ON departments.department_id = employees.department_id
INNER JOIN locations ON locations.location_id = departments.location_id;

-- 8.12 Muestra el id, nombre, apellido, fecha de contratación, nombre de departamento, nombre de trabajo, ciudad, calle, país y región (Continente)
SELECT employee_id, first_name, last_name, hire_date, departments.department_name, 
jobs.job_title, locations.city, locations.street_address, countries.country_name, regions.region_name FROM employees
INNER JOIN departments ON departments.department_id = employees.department_id
INNER JOIN jobs  ON jobs.job_id = employees.job_id
INNER JOIN locations ON locations.location_id = departments.location_id
INNER JOIN countries ON countries.country_id = locations.country_id
INNER JOIN regions 	ON regions.region_id = countries.region_id;

-- 8.13  Muestra los trabajadores que tengan historial con nombre y apellidos, nombre de trabajo y nombre de departamento.
SELECT first_name, last_name, jobs.job_title, departments.department_name FROM employees
RIGHT JOIN job_history ON job_history.employee_id = employees.employee_id
LEFT JOIN jobs ON job_history.job_id = jobs.job_id
LEFT JOIN departments ON job_history.department_id = departments.department_id;

-- 8.14 Muestra todos los empleados (id, nombre y apellidos) que tengan su departamento en Toronto.
SELECT employee_id, first_name, last_name, locations.city FROM employees
INNER JOIN departments ON departments.department_id = employees.department_id
INNER JOIN locations ON locations.location_id = departments.location_id
WHERE locations.city = "Toronto";










 

