SELECT last_name,job_title,department_name,city,country_name,region_name

FROM employees e
JOIN departments d ON e.department_id = d.department_id
JOIN locations l ON d.location_id = l.location_id
JOIN countries c ON l.country_id = c.country_id
JOIN regions r ON c.region_id = r.region_id
JOIN jobs j ON e.job_id = j.job_id;

SELECT last_name,job_title,department_name,city,country_name,region_name
FROM employees e
JOIN departments d using(department_id)
JOIN locations l using(location_id)
JOIN countries c using(country_id)
JOIN regions r using(region_id)
JOIN jobs j using(job_id);

SELECT last_name,department_name
FROM employees e
JOIN departments d using(department_id,manager_id);

SELECT last_name,department_name
FROM employees e
JOIN departments d using(department_id)
WHERE phone_number is not null ;

SELECT count(employee_id) liczba_pracownikow,department_id

FROM employees
GROUP BY department_id;

SELECT count(employee_id) liczba_pracownikow,manager_id,department_id

FROM employees
GROUP BY manager_id,department_id;

SELECT count(employee_id) liczba_pracownikow,manager_id,department_id

FROM employees
WHERE manager_id=100
GROUP BY manager_id,department_id;

SELECT count(employee_id) liczba_pracownikow,manager_id,department_id

FROM employees
WHERE department_id=50
GROUP BY manager_id,department_id;

SELECT count(employee_id) liczba_pracownikow,manager_id,department_id

FROM employees
GROUP BY ROLLUP(manager_id,department_id)
ORDER BY manager_id ;

SELECT count(employee_id) liczba_pracownikow,manager_id,department_id

FROM employees
GROUP BY ROLLUP(department_id,manager_id)
ORDER BY department_id ;

SELECT count(employee_id) liczba_pracownikow,manager_id,department_id

FROM employees
GROUP BY CUBE(department_id,manager_id)
ORDER BY department_id ;

SELECT count(employee_id) liczba_pracownikow,manager_id,department_id,

grouping(manager_id) podsumowanie_dep,
grouping(department_id) podsumowanie_man
FROM employees
GROUP BY CUBE(department_id,manager_id)
ORDER BY department_id ;

SELECT extract(year from hire_date) rok,

to_char(hire_Date,'YYYY') ROK
FROM employees;

/*
Wyswietl liczbe pracownikow, rok zatrudnienia, nazwe departmantu.
Wyswietl podsumowania zarowno dla lat, jak i departamentow.
*/

SELECT count(employee_id),extract(year from hire_date) rok,department_name

FROM employees
JOIN departments using(department_id)
GROUP BY CUBE(extract(year from hire_date),department_name)
ORDER BY 2,3;

SELECT *
FROM employees WHERE manager_id is null;

SELECT *
FROM employees WHERE manager_id=100;

SELECT *
FROM employees WHERE manager_id=101;

SELECT employee_id,first_name,last_name,manager_id,level
FROM employees
START WITH manager_id is null
CONNECT BY prior employee_id = manager_id ;

--10:25

SELECT employee_id,first_name,last_name,manager_id,level
FROM employees
WHERE level=4
START WITH manager_id is null
CONNECT BY prior employee_id = manager_id ;

SELECT sum(salary) suma_zarobkow,level

FROM employees
START WITH manager_id is null
CONNECT BY prior employee_id = manager_id
GROUP BY level
ORDER BY level ;

SELECT lpad(last_name,10,' ')

FROM employees;

SELECT lpad(' ',(level-1)*4)||last_name,first_name,employee_id,manager_id,level

 FROM employees e
START WITH e.manager_id is null
CONNECT BY prior employee_id = e.manager_id ;

/*
Wyswietl sume zarobkow,srednie zarobki, level, miasta.
Uwzglednij pracownikow zatrudnionych przed 01-01-2007.
*/
select to_Date('01-01-2007','dd-mm-yyyy') from dual;

SELECT sum(salary) suma, round(avg(salary)) srednia, level, city

FROM employees e
JOIN departments USING(department_id)
JOIN locations USING(location_id)
WHERE hire_date<to_Date('01-01-2007','dd-mm-yyyy')
START WITH e.manager_id is null
CONNECT BY prior employee_id = e.manager_id
GROUP BY level, city ;

SELECT *
FROM employees
WHERE salary>(
SELECT avg(salary)
FROM employees
WHERE level=3
START WITH manager_id is null
CONNECT BY prior employee_id = manager_id
);

SELECT *
FROM employees
WHERE manager_id=100;

SELECT employee_id,first_name,last_name,manager_id,level
FROM employees
START WITH employee_id =101
CONNECT BY prior employee_id = manager_id ;

SELECT employee_id,first_name,last_name,manager_id,level
FROM employees
START WITH manager_id=101
CONNECT BY prior employee_id = manager_id ;

/*
Wyswietl sume zarobkow w calej firmie.
Nie uwzglednij wszystkich podwladnych posrednich i bezposrednich Lex De Haan
*/

SELECT employee_id
FROM employees
START WITH manager_id =102
CONNECT BY prior employee_id = manager_id ;
SELECT sum(salary)
FROM employees
WHERE employee_id not in (
SELECT employee_id
FROM employees
START WITH manager_id =102
CONNECT BY prior employee_id = manager_id
);

SELECT sum(salary)-(SELECT sum(salary)

FROM employees
START WITH manager_id =102
CONNECT BY prior employee_id = manager_id )
FROM employees
GROUP BY 2 ;

select sum(salary)
from employees
start with manager_id is null
connect by prior employee_id = manager_id and manager_id <> 102
order by manager_id;

SELECT employee_id, salary,

(SELECT round(avg(salary)) FROM employees )
FROM employees;

SELECT employee_id, salary,

(SELECT round(avg(salary)) FROM employees )
FROM employees;

SELECT employee_id, salary,

(SELECT round(avg(salary)) FROM employees ) srednia ,
(SELECT sum(salary) FROM employees ) suma
FROM employees;

SELECT employee_id, salary,

round(avg(salary) over ()) srednia,
sum(salary) over () suma
FROM employees;

SELECT employee_id, salary,

(SELECT round(avg(salary)) FROM employees ) srednia_w_calej_firmie
FROM employees
WHERE department_id=60;

SELECT employee_id, salary,

round(avg(salary) over ()) srednia_w_dep60
FROM employees
WHERE department_id=60;

/*
Wyswielt numery pracownikow, imiona, nazwiska,zarobki,
sume zarobkow. Uwzglednij tylko pracownikow z panstwa United States of America.
*/

SELECT employee_id,first_name,last_name,salary,
sum(salary) over () suma
 FROM employees
JOIN departments USING(department_id)
JOIN locations USING(location_id)
JOIN countries USING(country_id)
WHERE country_name='United States of America';

--11:49

WITH dane AS (
SELECT employee_id,department_id,salary,
round(avg(salary) over ()) srednia_w_firmie
FROM employees )
SELECT *
FROM dane
WHERE department_id=60;

SELECT employee_id,department_id,salary,
(SELECT avg(salary) FROM employees WHERE department_id =
zew.department_id ) srednia_w_dep
FROM employees zew
ORDER BY 2 ;

SELECT employee_id,department_id,salary,
avg(salary) over (partition by department_id) srednia_w_dep
FROM employees;

/*
Wyswietl numery pracownikow,miasto,maksymlane zarobki w miescie,
zarobki pracownika, roznice pomiedzy maksymlane zarobki w miescie,
a zarobkami pracownika
*/

WITH dane as (
SELECT employee_id,city,max(salary) over (partition by city)
maks_w_miescie,salary
FROM employees
JOIN departments USING(department_id)
JOIN locations USING(location_id)
)
SELECT employee_id,
city,
maks_w_miescie,
salary,
maks_w_miescie-salary
FROM dane;

SELECT employee_id,salary,
dense_rank() over (order by salary ) ranking_po_zarobkach
FROM employees;

SELECT employee_id,salary,
dense_rank() over (order by salary desc) ranking_po_zarobkach_malejaco
FROM employees;

SELECT employee_id,hire_date,
dense_rank() over (order by hire_date desc) ranking_po_datach_malejaco
 FROM employees;

SELECT avg(salary),department_id,
dense_rank() over (order by avg(salary) desc) ranking_po_sredniej_malejaco
FROM employees
GROUP BY department_id ;

SELECT employee_id,salary,
rank() over (order by salary ) ranking_po_zarobkach
FROM employees;

/*
Wyswietl liczbe pracownikow, nazwy panstw, ranking po liczbie pracownikow malejaco.
*/
SELECT count(employee_id) liczba_pracownikow,
country_name,
dense_rank() over (order by count(employee_id) desc) ranking
FROM employees
JOIN departments USING(department_id)
JOIN locations USING(location_id)
JOIN countries USING(country_id)
GROUP BY country_name;

SELECT employee_id,salary,
row_number() over (order by salary ) ranking_po_zarobkach
FROM employees;

SELECT *
FROM (
SELECT employee_id,salary,
row_number() over (order by salary ) ranking_po_zarobkach
FROM employees
)
WHERE ranking_po_zarobkach<=10;

SELECT *
FROM (
SELECT employee_id,salary,
dense_rank() over (order by salary ) ranking_po_zarobkach
FROM employees
)
WHERE ranking_po_zarobkach<=3;

--row_number
--dense_rank
--rank

SELECT *
FROM (
SELECT employee_id,salary
FROM employees
ORDER BY salary
)
WHERE rownum<=10;
SELECT *
FROM (
SELECT employee_id,salary
FROM employees
ORDER BY salary
)
WHERE rownum<=20;

SELECT *
FROM (
SELECT employee_id,salary
FROM employees
ORDER BY salary
)
WHERE rownum between 20 and 30;

SELECT *
FROM (
SELECT employee_id,salary
FROM employees
ORDER BY salary
)
WHERE rownum>30;

SELECT *
FROM (
SELECT employee_id,salary,
row_number() over (order by salary ) ranking_po_zarobkach
FROM employees
)
WHERE ranking_po_zarobkach between 20 and 30;

/*
Wyswietl pracownikow o 4 najnizszych datach zatrudnienia z miasta Seattle
*/

SELECT *
FROM (
SELECT employee_id,
hire_date,
dense_rank() over (order by hire_date ) ranking
FROM employees
JOIN departments USING(department_id)
JOIN locations USING(location_id)
WHERE city='Seattle'
)
WHERE ranking<=4;

CREATE TABLE employees2 AS

SELECT *
FROM employees;

UPDATE employees2
SET salary = salary+100
 WHERE employee_id=(
SELECT employee_id
FROM (
SELECT employee_id,salary,
row_number() over (order by salary ) ranking
FROM employees2
JOIN departments USING(department_id)
WHERE department_name='IT'
)
WHERE ranking=1
);

COMMIT;

SELECT employee_id,salary,department_id,
row_number() over (partition by department_id order by salary desc )
ranking_part_dep
FROM employees;

SELECT *
FROM (
SELECT employee_id,salary,department_id,
row_number() over (partition by department_id order by salary desc )
ranking_part_dep
FROM employees
)
WHERE ranking_part_dep=1;

--13:40

/*Napisz update, ktory da podwyzke o 1000 2 najwczesniej zatrudnionym pracownikom

z kazdego regionu */

UPDATE employees2
SET salary = salary +1000
WHERE employee_id in (
SELECT employee_id
FROM (
SELECT employee_id,row_number() over (partition by region_name order by
hire_date) ranking
FROM employees2 e
JOIN departments d using(department_id)
JOIN locations l using(location_id)
JOIN countries c using(country_id)
JOIN regions r using(region_id)
)
WHERE ranking<=2
);

rollback;

SELECT employee_id,salary,
ratio_to_report(salary) over ()*100
FROM employees ;
SELECT employee_id,salary/(select sum(salary) from employees)
FROM employees ;

SELECT employee_id,salary,
round(ratio_to_report(salary) over ()*100,2)
FROM employees ;

SELECT employee_id,salary,
to_char(ratio_to_report(salary) over ()*100,'90.99')||'%'
FROM employees ;

SELECT employee_id,department_id,salary,
round(ratio_to_report(salary) over (partition by department_id)*100,2)
FROM employees ;

SELECT employee_id,salary,
lead(salary) over (order by salary desc ) oczko_nizej
FROM employees;

SELECT employee_id,salary,
lead(last_name) over (order by salary desc ) oczko_nizej
FROM employees;

SELECT employee_id,salary,
lead(salary,2) over (order by salary desc ) "2_oczka_nizej"
FROM employees;

SELECT employee_id,salary,
lag(salary) over (order by salary desc ) oczko_wyzej
FROM employees;

WITH dane AS
(
SELECT employee_id,salary,
lead(salary) over (order by salary desc ) oczko_nizej
FROM employees
)
SELECT employee_id,
salary,
oczko_nizej,
salary-oczko_nizej roznica
FROM dane;

WITH dane AS (
SELECT salary,lead(salary) over (order by salary desc) oczko_nizej
FROM (
SELECT distinct salary
FROM employees
)
)
SELECT salary,
oczko_nizej,
salary-oczko_nizej roznica
FROM dane;
/*
Wyswietl numery pracownikow, daty zatrudnienia, date zatrudnienia pracownika
zatrudnionego wczesniej,
liczbe dni pomiedzy tymi datami.
*/

with cte as (
SELECT
employee_id
,hire_date
,lag(hire_date) over (order by hire_date) hire_min_1
from employees
order by hire_date )

select
employee_id,
hire_date,
hire_min_1,
hire_date - hire_min_1 roznica
from cte;

with cte as (
SELECT
employee_id
,hire_date
,lead(hire_date) over (order by hire_date desc ) hire_min_1
from employees
)

select
employee_id,
hire_date,
hire_min_1,
hire_date - hire_min_1 roznica
from cte;

/***
Wyswietl dynamike zatrudnienai w calej firmie rok do roku.
(o ile mniej/wiecej zatrudniono pracownikow w stosunku do poprzedniego roku).
*/

SELECT to_char(hire_Date,'yyyy') year,

count(employee_id) count_this_year,
lag(count(employee_id)) over (order by to_char(hire_Date,'yyyy'))
count_last_year
FROM employees
GROUP BY to_char(hire_Date,'yyyy');

WITH dane as (
SELECT to_char(hire_Date,'yyyy') year,
count(employee_id) count_this_year,
lag(count(employee_id)) over (order by
to_char(hire_Date,'yyyy')) count_last_year
FROM employees
GROUP BY to_char(hire_Date,'yyyy')
)
SELECT year,
count_this_year,
count_last_year,
 count_this_year-count_last_year diff_year2year
FROM dane ;

SELECT employee_id,salary,
sum(salary) over (order by salary desc rows between 1 preceding and 1
following ) suma_kroczaca
FROM employees;

SELECT employee_id,salary,
sum(salary) over (order by salary desc rows between 1 preceding and current
row ) suma_kroczaca
FROM employees;

SELECT employee_id,salary,
sum(salary) over (order by salary desc rows between current row and 1
following ) suma_kroczaca
FROM employees;

SELECT employee_id,salary,
avg(salary) over (order by salary desc rows between 1 preceding and 1
following ) suma_kroczaca
FROM employees;

--15:00

SELECT employee_id,salary,
sum(salary) over (order by salary desc rows between unbounded preceding and
current row ) suma_kumulatywna
FROM employees;

SELECT employee_id,salary,
sum(salary) over (order by salary desc rows between current row and
unbounded following ) suma_kumulatywna
FROM employees;

SELECT employee_id,city,salary,
sum(salary) over (partition by city order by salary desc rows between
unbounded preceding and current row ) suma_kumulatywna
FROM employees
JOIN departments USING(department_id)
JOIN locations USING(location_id);

SELECT count(employee_id) liczba_pracownikow,manager_id,department_id

FROM employees
GROUP BY CUBE(department_id,manager_id)
ORDER BY department_id ;

SELECT count(employee_id) liczba_pracownikow,manager_id,department_id

FROM employees
GROUP BY GROUPING SETS(department_id,manager_id)
ORDER BY department_id ;

SELECT count(employee_id) liczba_pracownikow,null manager_id,department_id

FROM employees
GROUP BY department_id
UNION ALL
SELECT count(employee_id) liczba_pracownikow,manager_id,null
FROM employees
GROUP BY manager_id;

SELECT count(employee_id) liczba_pracownikow,manager_id,department_id

FROM employees
GROUP BY GROUPING SETS(
(department_id,manager_id),
(department_id),
(manager_id),
()
)
ORDER BY department_id,manager_id;

CREATE TABLE test1(x NUMBER);

insert into test1 values (1);

SELECT * FROM test1;

COMMIT;

insert into test1 values (1);

SELECT * FROM test1;

ROLLBACK;

--create,alter,drop,truncate zawieraja commit

insert into test1 values (2);

CREATE TABLE test2(x NUMBER);

rollback;

insert into test1 values (3);

savepoint a;

insert into test1 values (4);

SELECT * FROM test1;

ROLLBACK TO a;

SELECT * FROM test1;

COMMIT;

SELECT * FROM employees2;

UPDATE hr.employees2
SET salary=salary+100;

ROLLBACK;
UPDATE departments
SET department_name='X';
COMMIT;

ROLLBACK;

SELECT * FROM departments;

SELECT *
FROM departments AS OF TIMESTAMP to_timestamp('11-09-2023 15:00:00','dd-mm-yyyy
hh24:mi:ss');

UPDATE departments zew

SET department_name = (
SELECT department_name
FROM departments AS OF TIMESTAMP to_timestamp('11-09-
2023 15:00:00','dd-mm-yyyy hh24:mi:ss')
WHERE department_id = zew.department_id
);

COMMIT;

/*
Zmien wszystkie nazy miast na 'xyz', nastepnie odtworz dane z przed zmiany
uzywajac as of timestamp
*/

create table countries1 as (select * from countries);

update countries1 set country_name = 'xys'

select * from countries1

commit;

UPDATE countries zew

SET country_name='Polska';

COMMIT;

SELECT *
FROM countries AS OF TIMESTAMP to_timestamp('11-09-2023 15:48:00','dd-mm-yyyy
hh24:mi:ss');

UPDATE countries zew

SET country_name = (
SELECT country_name
FROM countries AS OF TIMESTAMP to_timestamp('11-09-2023
15:48:00','dd-mm-yyyy hh24:mi:ss')
WHERE country_id = zew.country_id
);
SELECT *
FROM countries ;
COMMIT;

SELECT * FROM employees2;

DELETE employees2
WHERE department_id =60;

COMMIT;

SELECT *
FROM employees2
AS OF TIMESTAMP sysdate -1/48;

SELECT *
FROM employees2
AS OF TIMESTAMP sysdate -1/48
MINUS
SELECT *
FROM employees2;

SELECT *
FROM employees2
AS OF TIMESTAMP sysdate -1/48
WHERE employee_id not in (
SELECT employee_id
FROM employees2
);

INSERT INTO employees2

SELECT *
FROM employees2
AS OF TIMESTAMP sysdate -1/48
WHERE employee_id not in (
SELECT employee_id
FROM employees2
);
COMMIT;

--11g EP
--18c EX

DELETE employees2
WHERE department_id =60;

COMMIT;

ALTER TABLE employees2 ENABLE ROW MOVEMENT ;

FLASHBACK TABLE employees2 to timestamp sysdate -1/24;

UPDATE employees
 SET salary =1
WHERE employee_id =100;
commit;

UPDATE employees
SET salary =24000
WHERE employee_id =100;
commit;

UPDATE employees
SET salary =2
WHERE employee_id =100;
commit;

SELECT employee_id,salary,versions_starttime,versions_endtime
FROM employees
VERSIONS BETWEEN TIMESTAMP to_timestamp('12-09-2023 09:10:00','dd-mm-yyyy
hh24:mi:ss')
AND systimestamp
WHERE employee_id = 100;

SELECT *
FROM employees AS OF TIMESTAMP to_timestamp('12-09-2023 09:15:45','dd-mm-yyyy
hh24:mi:ss');

SELECT employee_id,salary,versions_starttime,versions_endtime,
versions_startscn,versions_endscn
FROM employees
VERSIONS BETWEEN SCN MINVALUE AND MAXVALUE
WHERE employee_id = 100;

UPDATE employees
SET salary =3
WHERE employee_id =100;
commit;

UPDATE employees
SET salary =24000
WHERE employee_id =100;
commit;

UPDATE employees
SET salary =4
WHERE employee_id =100;
commit;

SELECT employee_id,salary,versions_starttime,versions_endtime,
versions_startscn,versions_endscn,versions_xid
FROM employees
VERSIONS BETWEEN SCN MINVALUE AND MAXVALUE
WHERE employee_id = 100;

SELECT xid, operation, start_scn,commit_scn, logon_user, undo_sql

FROM flashback_transaction_query
WHERE xid = HEXTORAW('0600030021000000');

SELECT *
FROM employees AS OF SCN '4120315';

UPDATE employees zew

SET salary = (
SELECT salary
FROM employees AS OF SCN '4120315'
WHERE employee_id = zew.employee_id
);

SELECT *
FROM employees;

COMMIT;

drop table test1;

SELECT *
FROM user_recyclebin;

FLASHBACK TABLE test1 TO BEFORE DROP;

SELECT * FROM test1;

DROP TABLE test1;

CREATE TABLE test1 AS SELECT * FROM employees;

DROP TABLE test1;

SELECT *
FROM user_recyclebin;

FLASHBACK TABLE "BIN$hitYCXr9Qn6TUdaQ/q5zdA==$0" TO BEFORE DROP;

SELECT * FROM test1;

FLASHBACK TABLE test1 TO BEFORE DROP RENAME TO test3;

SELECT * FROM test3;

DROP TABLE test1 PURGE;

DROP TABLE test2;

PURGE TABLE test2;

PURGE user_recyclebin;

SELECT *
FROM user_views;

/*
Utworz kopie tabeli departments.
Usun.
Utworz tabele o takiej samej nazwie jak 1, ale o innych kolumnach.
Usun.
Odzyskaj tabele, ktora zostala usunieta jako pierwsza.
Odzyskaj tabele, ktora zostala usunieta jako druga i zmien jej nazwe.
Ponownie usun obie tabele, ale tak aby nie trafily do kosza.
*/

create table departments_copy as select * from departments;

drop table departments_copy;

create table departments_copy (X NUMBER);

drop table departments_copy;

select * from user_recyclebin;

flashback table "BIN$wSDmV3roScqd2dUz3Yht5w==$0" to before drop;

select * from departments_copy;

select * from user_recyclebin;

flashback table "BIN$/fPI5xLrQCqWiYLYtYVQBQ==$0" to before drop rename to

departments_copy2;

drop table departments_copy purge;

drop table departments_copy2 purge;

select * from user_recyclebin;

--10:22

CREATE TABLE countries2(

country_id CHAR(2),
country_name VARCHAR2(10),
region_id INT REFERENCES regions2 (region_id)
ON DELETE CASCADE)
;

CREATE TABLE regions2(

region_id integer primary key,
region_name varchar2(500));

select * from regions2;

INSERT INTO regions2 VALUES(1,'EUROPA');

INSERT INTO countries2 VALUES('PO','Polska',1);

COMMIT;

DELETE regions2 ;

select * from countries2;

select * from regions2;
INSERT INTO regions2
select * from regions2 AS OF TIMESTAMP to_timestamp('12-09-2023 10:28:45','dd-mm-
yyyy hh24:mi:ss');

INSERT INTO countries2

select * from countries2 AS OF TIMESTAMP to_timestamp('12-09-2023 10:28:45','dd-mm-
yyyy hh24:mi:ss');

SELECT * FROM countries2;

CREATE VIEW widok AS

SELECT employee_id,first_name,last_name,salary
FROM employees;

SELECT *
FROM user_views;

SELECT *
FROM all_views;

SELECT * FROM widok;

CREATE OR REPLACE VIEW widok AS

SELECT employee_id,first_name,last_name,salary,department_id
FROM employees;

SELECT * FROM widok;

CREATE OR REPLACE VIEW widok AS

SELECT employee_id,first_name,last_name,salary/12
miesieczne_zarobki ,department_id
FROM employees;

SELECT * FROM widok;

CREATE OR REPLACE VIEW widok AS

SELECT employee_id,first_name,last_name,round(salary/12)
miesieczne_zarobki ,department_id
FROM employees;

SELECT * FROM widok;

CREATE OR REPLACE VIEW widok AS

SELECT employee_id,first_name,last_name,round(salary/12)
miesieczne_zarobki ,department_id,
department_name
FROM employees
JOIN departments USING(department_id);

SELECT * FROM widok;

/*
Utworz widok ktory bedzie zawieral sume zarobkow, liczbe pracownikow, miasta.
Uwzglednij pracownikow zatrudnionych po 01-01-2002.
Uwzglednij rowniez miasta w ktorych nikt nie pracuje
*/
SELECT *
FROM employees
JOIN departments using(department_id);

SELECT last_name,department_name
FROM employees
JOIN departments using(department_id);

SELECT last_name,department_name
FROM employees LEFT JOIN departments using(department_id);

SELECT last_name,department_name
FROM employees RIGHT JOIN departments using(department_id);

CREATE OR REPLACE VIEW widok2 AS

SELECT NVL(sum(salary),0) suma ,count(employee_id) liczba ,city
FROM employees
JOIN departments USING(department_id)
RIGHT JOIN locations USING(location_id)
WHERE hire_date>to_date('01-01-2002','dd-mm-yyyy') OR hire_date IS NULL
GROUP BY city
ORDER BY 1 DESC;

SELECT *
FROM widok2;

ALTER TABLE locations RENAME COLUMN city to city2;

SELECT *
FROM widok2;

SELECT *
FROM user_objects
WHERE status='INVALID';

ALTER TABLE locations RENAME COLUMN city2 to city;

SELECT *
FROM widok2;

SELECT *
FROM user_objects
WHERE status='INVALID';

ALTER VIEW EMP_DETAILS_VIEW COMPILE;

CREATE OR REPLACE VIEW widok AS

SELECT employee_id,first_name,last_name,salary,department_id
FROM employees;

UPDATE widok
SET salary = salary+1
WHERE employee_id=100;

SELECT *
 FROM employees
WHERE employee_id=100;

ROLLBACK;

CREATE OR REPLACE VIEW widok AS

SELECT employee_id,first_name,last_name,salary,department_id
FROM employees
WITH READ ONLY ;

CREATE MATERIALIZED VIEW zmat AS -- 11:19

SELECT employee_id,salary
FROM employees;

UPDATE EMPLOYEES
SET salary = 25000
WHERE employee_id=100;

COMMIT;

SELECT * FROM zmat WHERE employee_id=100

UNION ALL
SELECT employee_id,salary FROM employees WHERE employee_id=100;

EXECUTE dbms_mview.refresh('zmat');

SELECT * FROM zmat WHERE employee_id=100

UNION ALL
SELECT employee_id,salary FROM employees WHERE employee_id=100;

CREATE TABLE big AS SELECT * FROM employees;

BEGIN
FOR x IN 1..15 LOOP
INSERT INTO big SELECT * FROM big;
commit;
END LOOP;
END;
/

SELECT *
FROM user_tab_statistics
WHERE table_name='BIG';

SELECT COUNT(*)
FROM BIG;

EXECUTE dbms_stats.gather_table_stats('HR','BIG');

SELECT sum(salary),department_name
FROM big
JOIN departments USING(department_id)
GROUP BY department_name;

--COST 10KK 0,7S

CREATE MATERIALIZED VIEW zmat2 AS

SELECT sum(salary) SUMA,department_name
 FROM big
JOIN departments USING(department_id)
GROUP BY department_name;

SELECT *
FROM zmat2;

-- cost 3

--11:51

/*
Wyswietl srednie zarobki , roznice pomiedzy maxymalnymi, a minimalnymi zarobkami,
nazwe departamentu, nazwe regionu.
Sprawdz jaki jest koszt wykonania zapytania.
(employees,departments,locations,countries,regions)
Nastepnie napisz widok zmaterializowany ktory jest oparty o wyzej napisane
zapytanie
i sprawdz jaki jest koszt select na tym widoku.
*/

SELECT avg(salary), MAX(salary)-MIN(salary) roznica, department_name, region_name

FROM employees e
JOIN departments d using(department_id)
JOIN locations l using(location_id)
JOIN countries c using(country_id)
JOIN regions r using(region_id)
GROUP BY department_name, region_name; --0,018 s cost 12

CREATE MATERIALIZED VIEW zadaniezmat AS

SELECT ROUND(AVG(salary)) srednie, MAX(salary)-MIN(salary) roznica,
department_name, region_name
FROM employees e
JOIN departments d using(department_id)
JOIN locations l using(location_id)
JOIN countries c using(country_id)
JOIN regions r using(region_id)
GROUP BY department_name, region_name;

SELECT * FROM zadaniezmat; -- cost 3

DROP TABLE COUNTRIES2;

DROP TABLE regions2;

CREATE TABLE regions2 AS SELECT * FROM regions WHERE 1=2;

CREATE SEQUENCE regions2_region_id_seq

START WITH 1
INCREMENT BY 1;

INSERT INTO regions2

VALUES(regions2_region_id_seq.nextval,'Nazwa regionu');

SELECT * FROM regions2;

SELECT Regions2_region_id_seq.currval
FROM dual;

CREATE SEQUENCE seq1

START WITH 1
INCREMENT BY 1
nocache
;

SELECT *
FROM user_sequences;

-- 12c

CREATE TABLE regions3(

region_id NUMBER GENERATED ALWAYS AS IDENTITY,
region_name VARCHAR2(100));

SELECT *
FROM user_sequences;

INSERT INTO regions3(region_name)

VALUES('nowy region');

SELECT *
FROM regions3;

CREATE TABLE regions3(

region_id NUMBER GENERATED ALWAYS AS IDENTITY,
region_name VARCHAR2(100));

INSERT INTO regions3

VALUES(3,'nowy region');

CREATE TABLE regions4(

region_id NUMBER GENERATED BY DEFAULT AS IDENTITY,
region_name VARCHAR2(100));

INSERT INTO regions4(region_name)

VALUES('nowy region');

INSERT INTO regions4

VALUES(-1,'nowy region');

CREATE TABLE regions5(

region_id NUMBER GENERATED ALWAYS AS IDENTITY(START WITH 1000 INCREMENT BY 1 ),
region_name VARCHAR2(100));

INSERT INTO regions5(region_name)

VALUES('nowy region');

SELECT *
FROM regions5;

/*
Utworz kopie tabeli departments bez danych.
Utworz sekwencje ktora wystartuje od 10 i bedzie zwiekszala sie o 10.
Wstaw do tabeli kilka wierszy, kolumna department_id ma byc uzupelniana przez
sekwenecje.
*/