-- ZESTAW IV

-- 5. Napisz procedurę sparametryzowaną, w której zostanie wybrany
-- najlepszy student, a jego nazwisko, imię i numer albumu oraz średnia
-- zostaną przekazane do środowiska wywołującego, gdzie należy wypisać
-- je na ekranie. Wprowadź obsługę błędów, jeśli więcej niż jeden student
-- uzyska najwyższą średnią.

CREATE OR REPLACE PROCEDURE najlepszystudent IS
TYPE Stud IS RECORD (
    im student.imie%TYPE,
    nazw student.nazwisko%TYPE,
    nr student.nralbumu%TYPE,
    sr NUMBER
    );
najlepszy Stud;
BEGIN
    SELECT s.imie, s.nazwisko, s.nralbumu, AVG(o.ocena) INTO najlepszy
    FROM student s
    INNER JOIN ocena o ON o.id_student = s.id_student
    GROUP BY s.imie, s.nazwisko, s.nralbumu
    HAVING AVG(o.ocena) = (
        SELECT MAX(AVG(o.ocena))
        FROM student s
        INNER JOIN ocena o ON o.id_student = s.id_student
        GROUP BY s.imie, s.nazwisko, s.nralbumu
    );
    DBMS_OUTPUT.PUT_LINE(najlepszy.im || ' ' || najlepszy.sr);
    EXCEPTION
    WHEN TOO_MANY_ROWS THEN DBMS_OUTPUT('ERROR');
END;

BEGIN
    najlepszystudent();
END;

-- 6. Utworzyć funkcję, która dla podanego nazwiska i imienia prowadzącego
-- (parametr), zwróci liczbę przedmiotów przez niego prowadzonych.

CREATE OR REPLACE FUNCTION liczbaprzedmiotow(im VARCHAR2, nazw VARCHAR2) RETURN NUMBER IS
lprzedm NUMBER;
BEGIN
    SELECT COUNT(p.id_przedmiot) INTO lprzedm
    FROM przedmiot p
    INNER JOIN zajecia z ON z.id_przedmiot = p.id_przedmiot
    INNER JOIN wykladowca w ON w.id_wykladowca = z.id_wykladowca
    WHERE w.imie = im AND w.nazwisko = nazw;
    RETURN lprzedm;
END;

DECLARE
    lprzedm NUMBER;
BEGIN
    lprzedm := liczbaprzedmiotow('Walenty', 'xD');
    DBMS_OUTPUT.PUT_LINE('Liczba przedmiotow: ' || lprzedm);
END;

-- 7. Napisać funkcje PL/SQL, która dla podanego nr albumu studenta oraz
-- budynku i sali (parametry) zwróci liczbę przedmiotów, na które uczęszcza
-- dany student.

CREATE OR REPLACE FUNCTION liczbazajec(nralb NUMBER, bud VARCHAR2, sala VARCHAR2) RETURN NUMBER IS
lprzedm NUMBER;
BEGIN
    SELECT COUNT(p.id_przedmiot) INTO lprzedm
    FROM zajecia z
    INNER JOIN przedmiot p ON p.id_przedmiot = z.id_przedmiot
    INNER JOIN sala s ON s.id_sala = z.id_sala
    INNER JOIN budynek b ON b.id_budynek = s.id_budynek
    INNER JOIN grupa g ON g.id_grupa = z.id_grupa
    INNER JOIN student st ON st.id_grupa = g.id_grupa
    WHERE b.nazwa = bud AND s.kodsali = sala AND st.nralbumu = nralb;
    RETURN lprzedm;
END;

DECLARE
    lprzedm NUMBER;
BEGIN
    lprzedm := liczbazajec(121122, 'xD', 'xD');
    DBMS_OUTPUT.PUT_LINE('Liczba przedmiotow: ' || lprzedm);
END;

-- 8.Napisać procedurę, która zmodyfikuje typ zajęć dla podanej, jako
-- parametr grupy studenckiej w zależności od jego aktualnej zawartości.
-- Wykorzystaj klauzurę: L – W oraz W - Ć

CREATE OR REPLACE PROCEDURE modyfikuj(grupa VARCHAR2) IS
CURSOR kursor IS
    SELECT z.id_zajecia, c.nazwa
    FROM zajecia z
    INNER JOIN charakter c ON c.id_charakter = z.id_charakter
    INNER JOIN grupa g ON g.id_grupa = z.id_grupa
    WHERE g.nazwa = grupa
    FOR UPDATE;
BEGIN
    FOR ROW IN kursor LOOP
        IF ROW.nazwa = 'Laboratoria' THEN
            UPDATE zajecia SET zajecia.id_charakter = 3 WHERE CURRENT OF kursor;
        ELSIF ROW.nazwa = 'Wykład' THEN
            UPDATE zajecia SET zajecia.id_charakter = 2 WHERE CURRENT OF kursor;
        END IF;
    END LOOP;
END;

-- ZESTAW V

-- 1. Napisz procedurę sparametryzowaną, w której zostanie wybrany
-- najlepszy student, a jego nazwisko, imię i numer albumu oraz średnia
-- zostaną przekazane do środowiska wywołującego, gdzie należy wypisać
-- je na ekranie. Wprowadź obsługę błędów, jeśli więcej niż jeden student
-- uzyska najwyższą średnią.

CREATE OR REPLACE PROCEDURE najlepszystudentv2(im OUT VARCHAR2, nazw OUT VARCHAR2, nralb OUT VARCHAR2, sr OUT NUMBER) IS
BEGIN
    SELECT s.imie, s.nazwisko, s.nralbumu, AVG(o.ocena) INTO im, nazw, nralb, sr
    FROM student s
    INNER JOIN ocena o ON o.id_student = s.id_student
    GROUP BY s.imie, s.nazwisko, s.nralbumu
    HAVING AVG(o.ocena) = (
        SELECT MAX(AVG(o.ocena))
        FROM student s
        INNER JOIN ocena o ON o.id_student = s.id_student
        GROUP BY s.imie, s.nazwisko, s.nralbumu
    );
END;

DECLARE
    im student.imie%TYPE;
    nazw student.nazwisko%TYPE;
    nralb student.nralbumu%TYPE;
    sr NUMBER;
BEGIN
    najlepszystudentv2(im, nazw, nralb, sr);
    DBMS_OUTPUT.PUT_LINE(im || ' ' || sr);
END;

-- 5. Napisać procedurę PL/SQL, która dla podanego budynku, sali
-- (parametry), wypisze wszystkie prowadzone zajęcia - tytuł, nazwisko i
-- imię prowadzącego, nazwę przedmiotu, typ zajęć, nazwę grupy
-- studenckiej.

CREATE OR REPLACE PROCEDURE listazajec(bud IN VARCHAR2, sala IN VARCHAR2) IS
CURSOR kursor IS
    SELECT t.nazwa tyt, w.imie, w.nazwisko, p.nazwa przedm, c.nazwa ch, g.nazwa gr
    FROM zajecia z
    INNER JOIN wykladowca w ON w.id_wykladowca = z.id_wykladowca
    INNER JOIN przedmiot p ON p.id_przedmiot = z.id_przedmiot
    INNER JOIN grupa g ON g.id_grupa = z.id_grupa
    INNER JOIN charakter c ON c.id_charakter = z.id_charakter
    INNER JOIN sala s ON s.id_sala = z.id_sala
    INNER JOIN budynek b ON b.id_budynek = s.id_budynek
    INNER JOIN tytulnaukowy t ON t.id_tytul = w.id_tytul
    WHERE b.nazwa = bud AND s.kodsali = sala;
BEGIN
    FOR ROW IN kursor LOOP
        DBMS_OUTPUT.PUT_LINE(ROW.tyt || ' ' || ROW.imie || ' ' || ROW.nazwisko || ' ' ||
                             ROW.przedm || ' ' || ROW.ch || ' ' || ROW.gr);
    END LOOP;
END;

BEGIN
    listazajec('Wydział Fizyki Matematyki i Iinformatyki', 'F201');
END;

-- 6. Napisać procedurę, która zmieniałaby oceny z wybranego przedmiotu
-- (parametr procedury) o 10% do momentu aż ocena ta stanie się oceną
-- maksymalną lub też ocenę tę przekroczy. Nazwę przedmiotu wraz z
-- ilością zmian przekazać do środowiska wywołującego i wypisać na
-- ekranie.

CREATE OR REPLACE PROCEDURE podniesocene(przedm IN VARCHAR2, ilosc OUT NUMBER) IS
CURSOR kursor IS
    SELECT o.ocena
    FROM ocena o
    INNER JOIN zajecia z ON z.id_zajecia = o.id_zajecia
    INNER JOIN przedmiot p ON p.id_przedmiot = z.id_przedmiot
    WHERE p.nazwa = przedm
    FOR UPDATE;
BEGIN
    ilosc := 0;
    FOR ROW IN kursor LOOP
        LOOP
            EXIT WHEN ROW.ocena * 1.1 >= 5.0;
            ROW.ocena := 1.1 * ROW.ocena;
        END LOOP;
        UPDATE ocena SET ocena.ocena = ROW.ocena WHERE CURRENT OF kursor;
        ilosc := ilosc + 1;
    END LOOP;
END;

-- nie testowałem
DECLARE
    ilosc NUMBER;
BEGIN
    podniesocene('jakis przedmiot', ilosc);
    DBMS_OUTPUT.PUT_LINE(ilosc);
END;

-- 7.Napisz procedurę, która dla podanego wykładowcy (imię i nazwisko –
-- parametry procedury) wyświetli imiona, nazwiska oraz numery albumu
-- wszystkich studentów, którzy mieli zajęcia z tym wykładowcą w sali
-- (parametr). Dane mają być posortowane alfabetycznie według nazwisk
-- studentów. Utwórz tabelę HISTORIA i dodaj do niej zestaw rekordów
-- zwrócony przez zapytanie.
CREATE TABLE HISTORIA (
    id_historia NUMBER(10) NOT NULL CONSTRAINT historia_pk PRIMARY KEY,
    imie VARCHAR2(30) NOT NULL,
    nazwisko VARCHAR2(30) NOT NULL,
    nralbumu VARCHAR2(30) NOT NULL
);


CREATE OR REPLACE PROCEDURE utworzhistorie(im VARCHAR2, nazw VARCHAR2, sala VARCHAR2) IS
CURSOR kursor IS
    SELECT s.imie, s.nazwisko, s.nralbumu
    FROM zajecia z
    INNER JOIN grupa g ON g.id_grupa = s.id_grupa
    INNER JOIN wykladowca w ON w.id_wykladowca = z.id_wykladowca
    INNER JOIN sala sa ON sa.id_sala = z.id_sala
    WHERE w.imie = im AND w.nazwisko = nazw AND s.kodsali = sala;
ostatnieid NUMBER;
BEGIN
    SELECT MAX(id_historia) INTO ostatnieid FROM historia;
    FOR ROW IN kursor LOOP
        ostatnieid := ostatnieid + 1;
        DBMS_OUTPUT.PUT_LINE(ROW.imie || ' ' || ROW.nazwisko || ' ' || ROW.nralbumu);
        INSERT INTO historia(id_historia, imie, nazwisko, nralbumu) VALUES(ostatnieid, ROW.imie, ROW.nazwisko, ROW.nralbumu)l
    END LOOP;
END;

-- nie testowałem

-- ZESTAW IV

-- 1. Napisz procedurę, która obniży ocenę danego studenta (parametr) z danego
-- przedmiotu (parametr) o podaną wartość przekazaną przez parametr, domyślna
-- wartość: 0,5). Dodaj obsługę błędu – w przypadku podania danych studenta oraz
-- przedmiotów, których nie ma w bazie.

CREATE OR REPLACE PROCEDURE obnizocene(nralb IN NUMBER, przedm IN VARCHAR2, wart IN NUMBER DEFAULT 0.5) IS
CURSOR kursor IS
    SELECT o.ocena
    FROM ocena o
    INNER JOIN student s ON s.id_student = o.id_student
    INNER JOIN zajecia z ON z.id_zajecia = o.id_zajecia
    INNER JOIN przedmiot p ON p.id_przedmiot = z.id_przedmiot
    WHERE s.nralbumu = nralb AND p.nazwa = przedm
    FOR UPDATE;
r kursor%ROWTYPE;
BEGIN
    OPEN kursor;
        FETCH kursor INTO r;
        IF kursor%notfound THEN
            RAISE NO_DATA_FOUND;
        ELSE
            IF r.ocena - wart >= 2.0 THEN
                UPDATE ocena SET ocena.ocena = r.ocena - wart WHERE CURRENT OF kursor;
            END IF;
        END IF;
    CLOSE kursor;
    EXCEPTION
    WHEN NO_DATA_FOUND THEN DBMS_OUTPUT.PUT_LINE('Brak danych');
END;

BEGIN
    obnizocene(121088, 'jakis przedmiot');
END;

-- 2.Napisz procedurę w dwóch wariantach, która przeliczy stopnie Fahrenheita na
-- Celsjusza według wzoru [ºC]=([ºF]-32)*5/9. W pierwszym wariancie procedura niech
-- przyjmuje dwa parametry (Fahrenheit i Celsjusz), w drugim – jeden (temperatura).
-- Skorzystaj z parametrów IN, OUT, IN OUT. Przetestuj jej działanie w bloku
-- anonimowym.

CREATE OR REPLACE PROCEDURE oblicztemp(fahr IN NUMBER, cels OUT NUMBER) IS
BEGIN
    cels := (fahr - 32) * 5/9;
END;

DECLARE
    cels NUMBER;
BEGIN
    oblicztemp(100, cels);
    DBMS_OUTPUT.PUT_LINE(cels);
END;

CREATE OR REPLACE PROCEDURE oblicztempv2(temp IN OUT NUMBER) IS
BEGIN
    temp := (temp - 32) * 5/9;
END;

DECLARE
    temp NUMBER;
BEGIN
    temp := 100;
    oblicztempv2(temp);
    DBMS_OUTPUT.PUT_LINE(temp);
END;

-- 3.Utwórz sekwencję, ktora pozwoli na nadawanie kolejnych numerów dla wstawianych
-- ocen oraz studentów. Dodaj po dwa rekordy do tabeli student oraz oceny
CREATE SEQUENCE sekw_st
START WITH 200
INCREMENT BY 1;

CREATE SEQUENCE sekw_oc
START WITH 200
INCREMENT BY 1;

INSERT INTO student VALUES (sekw_st.NEXTVAL, 'Zuza', 'Pazera', 3, 121078, 5);

-- 4.Utwórz wyzwalacz, który przy próbie zmiany oceny sprawdzi, czy nowa ocena nie
-- jest zwiększona więcej niż 0.5. Jeśli tak wypisze starą i nową ocenę. Dodaj też
-- odpowiedni komunikat.

CREATE OR REPLACE TRIGGER zmianaoceny BEFORE UPDATE ON ocena FOR EACH ROW
BEGIN
    IF :NEW.ocena > :old.ocena + 0.5 THEN
        DBMS_OUTPUT.PUT_LINE('Stara ocena: ' || :old.ocena || ', nowa ocena: '  || :NEW.ocena);
        RAISE_APPLICATION_ERROR(-20100, 'Za duża różnica');
    END IF;
END;

-- 5. Napisz funkcję SILNIA w sposób rekurencyjny. Przetestuj jej działanie.
CREATE OR REPLACE FUNCTION silnia(wart NUMBER) RETURN NUMBER IS
BEGIN
    IF wart < 2 THEN
        RETURN 1;
    ELSE
        RETURN wart * silnia(wart-1);
    END IF;
END;

BEGIN
    DBMS_OUTPUT.PUT_LINE(silnia(5));
END;

-- 6. Utworzyć pakiet o nazwie MOJ_PAKIET oraz zaimplementować podane niżej
-- procedury i funkcje
-- - DODAJ_STUD zadaniem procedury ma być dodawanie nowego studenta do
-- tabeli student. Numer ID powinien być pobierany automatycznie ze
-- zdefiniowanej w tym celu sekwencji.
-- - ZMIEN_STUD – procedura modyfikuje dane wskazanego studenta.
-- - USUN_STUD – procedura kasuje dane wskazanego studenta.
-- - ZMIEN_ADRES – zadaniem tej procedury jest zmiana adresu wskazanego
-- studenta.
-- - TOP_N – wyświetla listę N studentów (N podawane jako parametr wejściowy
-- procedury), którzy mają najwyższe średnie. Dane o tych studentach (imię,
-- nazwisko, adres, średnia ocen) powinni zostać dodatkowo zapisani do tabeli o
-- nazwie TOP_N_STUD (tabelę tą trzeba utworzyć bezpośrednio w kodzie
-- procedury).
-- - ZMIANA – procedura zmienia miejsce i czas prowadzenia przedmiotu przez
-- konkretnego wykładowcę) nazwa przedmiotu, imię, nazwisko wykładowcy to
-- parametry procedury.
-- - WYPISZ– zadaniem procedury jest wypisanie średniej oceny dla wybranego
-- przedmiotu, którego nazwa będzie parametrem..
-- - MINMAX – zadaniem funkcji jest zwrócenie wartości (w zależności od
-- podanego parametru) maksymalnej, minimalnej, średniej dla danej grupy
-- (parametr). Funkcja powinna przyjmować tylko jeden z dwóch parametrów:
-- MAX, MIN, Podanie innego parametru powinno wygenerować stosowne
-- ostrzeżenie.

CREATE SEQUENCE sekw_stud
START WITH 200
INCREMENT BY 1;

CREATE OR REPLACE PACKAGE moj_pakiet AS
    PROCEDURE dodaj_stud(im VARCHAR2, nazw VARCHAR2, idadr NUMBER, nralb NUMBER, idgr NUMBER);
    PROCEDURE zmien_stud(im VARCHAR2, nazw VARCHAR2, idadr NUMBER, nralb NUMBER, idgr NUMBER, idst NUMBER);
    PROCEDURE usun_stud(idst NUMBER);
    PROCEDURE zmien_adres(idst NUMBER, ul VARCHAR2, nrbud NUMBER, nrlok NUMBER, kod VARCHAR2, miast VARCHAR2);
    PROCEDURE top_n(n NUMBER);
    PROCEDURE wypisz(przedm NUMBER);
    PROCEDURE minmax(gr NUMBER, val VARCHAR2);
END moj_pakiet;

CREATE OR REPLACE PACKAGE BODY moj_pakiet AS
    PROCEDURE dodaj_stud(im VARCHAR2, nazw VARCHAR2, idadr NUMBER, nralb NUMBER, idgr NUMBER) IS
        BEGIN
            -- nie robię walidacji
            INSERT INTO student VALUES (sekw_stud.NEXTVAL, im, nazw, idadr, nralb, idgr);
        END;

    PROCEDURE zmien_stud(im VARCHAR2, nazw VARCHAR2, idadr NUMBER, nralb NUMBER, idgr NUMBER, idst NUMBER) IS
        BEGIN
            UPDATE student
            SET imie = im, nazwisko = nazw, id_adres = idadr, nralbumu = nralb, id_grupa = idgr
            WHERE id_student = idst;
        END;

    PROCEDURE usun_stud(idst NUMBER) IS
        BEGIN
            DELETE FROM student WHERE student.id_student = idst;
        END;

    PROCEDURE zmien_adres(idst NUMBER, ul VARCHAR2, nrbud NUMBER, nrlok NUMBER, kod VARCHAR2, miast VARCHAR2) IS
        BEGIN
            UPDATE adres SET ulica = ul, nrbudynku = nrbud, nrlokalu = nrlok, kodpocztowy = kod, miasto = miast
            WHERE id_adres = (SELECT id_adres FROM student WHERE id_student = idst);
        END;
    PROCEDURE top_n(n NUMBER) IS
        CURSOR kursor IS
            SELECT s.nazwisko, a.miasto, AVG(o.ocena) sr
            FROM student s
            INNER JOIN ocena o ON o.id_student = s.id_student
            INNER JOIN adres a ON a.id_adres = s.id_adres
            GROUP BY s.nazwisko, a.miasto
            ORDER BY AVG(o.ocena) DESC
            FETCH FIRST n ROWS ONLY;
        i NUMBER := 1;
        BEGIN
            EXECUTE IMMEDIATE 'CREATE TABLE top_n_stud (
                id_t NUMBER(10) NOT NULL CONSTRAINT pk_id PRIMARY KEY,
                nazwisko VARCHAR2(30) NOT NULL,
                miasto VARCHAR2(30) NOT NULL,
                srednia NUMBER(10) NOT NULL
                )';
            FOR ROW IN kursor LOOP
                INSERT INTO top_n_stud VALUES (i, ROW.nazwisko, ROW.miasto, ROW.sr);
                i := i + 1;
            END LOOP;
        END;

    PROCEDURE wypisz(przedm NUMBER) IS
        sr NUMBER;
        BEGIN
            SELECT AVG(o.ocena) INTO sr
            FROM ocena o
            INNER JOIN zajecia z ON z.id_zajecia = o.id_zajecia
            INNER JOIN przedmiot p ON p.id_przedmiot = z.id_przedmiot
            WHERE p.nazwa = przedm;
            DBMS_OUTPUT.PUT_LINE(sr);
        END;

    PROCEDURE minmax(gr NUMBER, val VARCHAR2) IS
        ret NUMBER;
        bledny_rodzaj EXCEPTION;
        BEGIN
            IF val = 'MAX' THEN
                SELECT AVG(o.ocena) INTO ret
                FROM ocena o
                INNER JOIN student s ON s.id_student = o.id_student
                INNER JOIN grupa g ON g.id_grupa = s.id_grupa
                WHERE g.nazwa = gr
                HAVING AVG(o.ocena) = (
                    SELECT MAX(AVG(o.ocena))
                    FROM ocena o
                    INNER JOIN student s ON s.id_student = o.id_student
                    INNER JOIN grupa g ON g.id_grupa = s.id_grupa
                    WHERE g.nazwa = gr
                    );
                DBMS_OUTPUT.PUT_LINE(ret);
            ELSIF val = 'MIN' THEN
                                SELECT AVG(o.ocena) INTO ret
                FROM ocena o
                INNER JOIN student s ON s.id_student = o.id_student
                INNER JOIN grupa g ON g.id_grupa = s.id_grupa
                WHERE g.nazwa = gr
                HAVING AVG(o.ocena) = (
                    SELECT MIN(AVG(o.ocena))
                    FROM ocena o
                    INNER JOIN student s ON s.id_student = o.id_student
                    INNER JOIN grupa g ON g.id_grupa = s.id_grupa
                    WHERE g.nazwa = gr
                    );
                DBMS_OUTPUT.PUT_LINE(ret);
            ELSE
                RAISE bledny_rodzaj;
            END IF;
            EXCEPTION
                WHEN bledny_rodzaj THEN DBMS_OUTPUT.PUT_LINE('Prosze wybrac min albo max');
        END;
END moj_pakiet;

-- coś nie działa, nie wiem co

-- ZESTAW VII

-- 1.Uruchom następujący blok anonimowy:
-- BEGIN
-- execute immediate
-- '
-- begin
-- dbms_output.put_line (' ' kierunek informatyka' ' );
-- end;
-- ';
-- END;

BEGIN
    EXECUTE IMMEDIATE  'BEGIN
        DBMS_OUTPUT.PUT_LINE(''kierunek informatyka'');
    end;';
END;

-- 2.Napisz blok anonimowy warunkowo usuwający sekwencję – w pętli FOR sprawdź, czy
-- sekwencja istnieje, a następnie twórz i uruchom dynamiczną instrukcję DDL DROP
-- SEQUNCE. Wykonaj zadanie z użyciem NDS oraz pakietu DBMS_SQL
CREATE SEQUENCE test_sekw
START WITH 150
INCREMENT BY 1
MINVALUE 100
MAXVALUE 200;

SELECT * FROM user_objects WHERE object_name = 'TEST_SEKW';


BEGIN
    FOR i IN (SELECT NULL FROM user_objects WHERE object_name = 'TEST_SEKW') LOOP
        EXECUTE IMMEDIATE 'DROP SEQUENCE test_sekw';
    END LOOP;
END;

-- 3.Utworzyć procedurę przyjmującą jako parametry nazwę tabeli i opcjonalnie nazwę kolumny
-- gdy podana jest tylko nazwa tabeli, procedura ma dodać komentarz do tabeli zawierający
-- informację o ilości rekordów w tabeli w wypadku gdy podana jest też nazwa kolumny, należy
-- dodać komentarz na odpowiedniej kolumnie z informacją na temat ilości różnych wartości tej
-- kolumny
CREATE OR REPLACE PROCEDURE dodajkomentarz(tab VARCHAR2, kol VARCHAR2 DEFAULT NULL) IS
    lrekordow NUMBER;
    lwartosci NUMBER;
    BEGIN
        EXECUTE IMMEDIATE 'SELECT COUNT(*) FROM ' || tab INTO lrekordow;
        EXECUTE IMMEDIATE 'COMMENT ON TABLE ' || tab || ' IS ''liczba rekordow: ' || lrekordow || '''';
        IF kol IS NOT NULL THEN
            EXECUTE IMMEDIATE 'SELECT COUNT(DISTINCT '|| kol || ') FROM ' || tab INTO lwartosci;
            EXECUTE IMMEDIATE 'COMMENT ON COLUMN ' || tab || '.' || kol || ' IS ''liczba wartosci ' || lwartosci || '''';
        END IF;
    END;

BEGIN
    dodajkomentarz('STUDENT', 'IMIE');
END;

-- 4.Utworzyć procedurę wypisującą na ekran ilość studentów spełniających określone kryteria -
-- urodzonych w zadanym przedziale czasu -których imię, nazwisko pasuje do podanego wzorca
-- klauzula where zapytania powinna zawierać tylko warunki dla tych parametrów (kryteriów),
-- które nie są puste.
CREATE OR REPLACE PROCEDURE ilstudentow(dataod DATE, datado DATE, wzorzecim VARCHAR2, wzorzecnazw VARCHAR2) IS
    lstud NUMBER;
BEGIN
    SELECT COUNT(s.id_student) INTO lstud
    FROM student s
    WHERE s.dataurodzenia >= dataod AND s.dataurodzenia <= datado AND s.imie LIKE wzorzecim AND s.nazwisko LIKE wzorzecnazw;
    DBMS_OUTPUT.PUT_LINE(lstud);
END;

-- 5. nie robię
-- 6. nie robię

-- 7. Napisać procedurę dodającą do podanej jako parametr tabeli pole ostatnia_modyfikacja oraz
-- trigger uzupełniający to pole przy wykonaniu update na rekordzie.

CREATE OR REPLACE PROCEDURE dodajtrigger(tab VARCHAR2) IS
BEGIN
    EXECUTE IMMEDIATE 'ALTER TABLE ' || tab || ' ADD ostatnia_modyfikacja DATE';
    EXECUTE IMMEDIATE 'CREATE OR REPLACE TRIGGER ' || tab || '_trigg AFTER UPDATE ON ' || tab ||
                      ' FOR EACH ROW BEGIN ' ||
                        'UPDATE ' || tab || ' SET ostatnia_modyfikacja = sysdate;' ||
                      ' END;';
END;

BEGIN
    dodajtrigger('student');
END;

-- nie testowałem

-- 9. Usuń z tabeli student wybrany rekord oraz dodaj nowy rekord korzystając z pakietu
-- DBMS_SQL
CREATE OR REPLACE PROCEDURE usunstudenta(idst NUMBER) IS
    kursor INTEGER := DBMS_SQL.OPEN_CURSOR;
    ret INTEGER;
    stmt VARCHAR2(255);
BEGIN
    stmt := 'DELETE FROM student WHERE id_student = :idst';
    DBMS_SQL.PARSE(kursor, stmt, DBMS_SQL.NATIVE);
    DBMS_SQL.BIND_VARIABLE(kursor, ':idst', idst);
    ret := DBMS_SQL.EXECUTE(kursor);
    DBMS_SQL.CLOSE_CURSOR(kursor);
END;

CREATE OR REPLACE PROCEDURE dodajstudenta(im VARCHAR2, nazw VARCHAR2, idadr NUMBER, nralb NUMBER, idgr NUMBER) IS
    kursor INTEGER := DBMS_SQL.OPEN_CURSOR;
    stmt VARCHAR2(255);
    ret INTEGER;
BEGIN
    stmt := 'INSERT INTO student VALUES (:id, :im, :nazw, :idadr, :nralb, :idgr, null)';
    DBMS_SQL.PARSE(kursor, stmt, DBMS_SQL.NATIVE);
    DBMS_SQL.BIND_VARIABLE(kursor, ':id', sekw_st.NEXTVAL);
    DBMS_SQL.BIND_VARIABLE(kursor, ':im', im);
    DBMS_SQL.BIND_VARIABLE(kursor, ':nazw', nazw);
    DBMS_SQL.BIND_VARIABLE(kursor, ':idadr', idadr);
    DBMS_SQL.BIND_VARIABLE(kursor, ':nralb', nralb);
    DBMS_SQL.BIND_VARIABLE(kursor, ':idgr', idgr);
    ret := DBMS_SQL.EXECUTE(kursor);
    DBMS_SQL.CLOSE_CURSOR(kursor);
END;

BEGIN
    usunstudenta(200);
    dodajstudenta('Tomek', 'Pazera', 1, 123132, 13);
END;

-- KOLOKWIUM II GRUPA 1

-- +---------------+----------------+----------------+-----------+----------------+
-- | PRZEDMIOTY    | OCENY          | NAUCZYCIELE    | UCZNIOWIE | KLASY          |
-- +---------------+----------------+----------------+-----------+----------------+
-- | id_przedmiotu | id_oceny       | id_nauczyciela | id_ucznia | id_klasy       |
-- | nazwa         | id_przedmiotu  | nazwisko       | nazwisko  | nazwa          |
-- |               | id_ucznia      | imie           | imię      | id_nauczyciela |
-- |               | id_nauczyciela | id_przedmiotu  | data_ur   |                |
-- |               | ocena          |                | id_klasy  |                |
-- |               | data           |                |           |                |
-- +---------------+----------------+----------------+-----------+----------------+

-- 1.Napisz procedurę (imię i nazwisko, data_ur parametry) wprowadzającą do tabeli KLASY rekord rejestrujący utworzenie
-- nowej klasy Vk. Do utworzonej klasy Vk należy wprowadzić ucznia. Aby można było zarejestrować nowego ucznia należy
-- sprawdzić, czy uczeń o podanym nazwisku i imieniu znajduje się już w bazie danych. Jeśli tak to należy wyprowadzić
-- komunikat informujący o tym fakcie, jeśli nie należy wprowadzić nowego ucznia. Zaimplementuj obsługę błędów.
CREATE OR REPLACE PROCEDURE dodajklase(im IN VARCHAR2, nazw IN VARCHAR2, data IN DATE) IS
lastid NUMBER;
studentexist NUMBER;
lastidst NUMBER;
uczenistnieje EXCEPTION;
BEGIN
    SELECT MAX(id_klasy) INTO lastid FROM klasy;
    lastid := lastid + 1;
    -- nie ma info o nauczycielu
    INSERT INTO klasy(id_klasy, nazwa, id_nauczyciela) VALUES (lastid, 'Vk', 1);
    -- sprawdzamy czy rekord istnieje
    SELECT COUNT(*) INTO studentexist FROM uczniowie u WHERE u.nazwisko = nazw AND u.imie = im AND u.data_ur = data GROUP BY u.id_ucznia;
    IF studentexist = 0 THEN
        SELECT MAX(id_student) INTO lastidst FROM uczniowie;
        INSERT INTO uczniowie VALUES (lastidst+1, nazw, im, data, lastid);
    ELSE
        RAISE uczenistnieje;
    END IF;
    EXCEPTION
    WHEN uczenistnieje THEN DBMS_OUTPUT.PUT_LINE('uczen istnieje');
    WHEN OTHERS THEN DBMS_OUTPUT.PUT_LINE('Error');
END;

-- 2.Napisz funkcję, która zwróci najniższą średnią ocen z danego przedmiotu. Funkcja, jako parametr wyjściowy
-- powinna zwrócić nazwę przedmiotu oraz nazwisko i imię prowadzącego.
CREATE OR REPLACE FUNCTION najnizszasrednia(przedm IN OUT VARCHAR2, nazw OUT VARCHAR2, im OUT VARCHAR2) RETURN NUMBER IS
ret NUMBER;
BEGIN
    SELECT AVG(o.ocena), n.imie, n.nazwisko INTO ret, im, nazw
    FROM oceny o
    INNER JOIN przedmioty p ON p.id_przedmiotu = o.id_przedmiotu
    WHERE p.nazwa = przedm
    GROUP BY n.imie, n.nazwisko
    HAVING AVG(o.ocena) = (
        SELECT MIN(AVG(o.ocena)), n.imie, n.nazwisko
        FROM oceny o
        INNER JOIN przedmioty p ON p.id_przedmiotu = o.id_przedmiotu
        WHERE p.nazwa = przedm
        GROUP BY n.imie, n.nazwisko
        );
    RETURN ret;
END;

DECLARE
    im VARCHAR2;
    nazw VARCHAR2;
    przedm VARCHAR2;
    sr NUMBER;
BEGIN
    przedm := 'Matematyka';
    sr = najnizszasrednia(przedm, im, nazw);
END;

-- 3.Napisz procedurę, której zadaniem jest obliczenie i wyprowadzenie na zewnątrz poprzez parametry wyjściowe
-- średniej ocen dla każdej z istniejących klas z podaniem imienia i nazwiska wychowawcy klasy.

-- JAK NIBY MAM ZBIÓR REKORDÓW ZWRÓCIĆ W PARAMETRZE WYJŚCIOWYM??!?!??!?!?!?
CREATE OR REPLACE PROCEDURE srednieklas(sre NUMBER, przedm VARCHAR2, im VARCHAR2, nazw VARCHAR2) IS
CURSOR kursor IS
    SELECT AVG(o.ocena) sr, p.nazwa, n.imie, n.nazwisko INTO sre, przedm, im, nazw
    FROM ocena
    INNER JOIN przedmioty p ON p.id_przedmiot = o.id_przedmiot
    INNER JOIN nauczyciele n ON n.id_przedmiot = p.id_przedmiot
    GROUP BY p.nazwa, n.nazwisko, n.imie;
r kursor%ROWTYPE;
BEGIN
    FOR r IN kursor LOOP
        DBMS_OUTPUT.PUT_LINE(r.nazwa || ' ' || r.imie || ' ' || r.nazwisko || ' ' || r.sr);
    END LOOP;
END;

-- 4.Napisz procedurę wyzwalaną, która przed wykonaniem operacji UPDATE i INSERT dla każdego wiersza tabeli UCZNIOWIE
-- doda do tabeli TEST informację w postaci ciągu znaków: ‘operacja B C’, gdzie operacja to nazwa wykonywanej operacji,
-- B, C to wartości poszczególnych atrybutów przed wykonaniem operacji. Tabela TEST istnieje i ma odpowiednią strukturę
CREATE OR REPLACE TRIGGER jakistrigger BEFORE UPDATE OR INSERT ON uczniowie
FOR EACH ROW
BEGIN
    IF UPDATING THEN
        INSERT INTO test VALUES ('UPDATE ' || :OLD.imie || ' ' || :OLD.nazwisko || ' ' || :OLD.data_ur || ' TO ' || :NEW.imie || ' ' || :NEW.nazwisko || ' ' || :NEW.data_ur);
    ELSIF INSERTING THEN
        INSERT INTO test VALUES ('INSERT ' || :OLD.imie || ' ' || :OLD.nazwisko || ' ' || :OLD.data_ur || ' TO ' || :NEW.imie || ' ' || :NEW.nazwisko || ' ' || :NEW.data_ur);
    END IF;
END;

-- 5. Utwórz z pakiet (sekcja specyfikacji i ciała) składający się z procedur i funkcji, które znajdują się w tym zestawie.
CREATE OR REPLACE PACKAGE pakiecik AS
    PROCEDURE dodajklase(im IN VARCHAR2, nazw IN VARCHAR2, data IN DATE);
    FUNCTION najnizszasrednia(przedm IN OUT VARCHAR2, nazw OUT VARCHAR2, im OUT VARCHAR2) RETURN NUMBER;
    PROCEDURE srednieklas(sre NUMBER, przedm VARCHAR2, im VARCHAR2, nazw VARCHAR2);
END pakiecik;

CREATE OR REPLACE PACKAGE BODY pakiecik AS
    -- TUTAJ CIAŁO FUNKCJI
END pakiecik;

-- Omów parametry wyzwalaczy
-- *FOR EACH ROW - wyzwalacz będzie uruchamiany dla każdego rekordu przetworzonego przez polecenie
-- *AFTER/BEFORE/INSTEAD OF - parametry mówiące kiedy ma wykonać się ciało wyzwalacza - przed, po, zamiast polecenia na
-- *danej tabeli
-- -- do wartości odwołujemy się za pomocą :OLD.atrybut (przed wykonaniem polecenia, dla insert wartośc null) oraz
   -- :NEW.atrybut (po wykonaniu polecenia, dla delete wartość null)
-- *INSERTING/DELETING/UPDATING - zwraca prawdę jeżeli zdarzenie uruchamiające wyzwalacz było odpowiednio INSERT/DELETE/UPDATE
-- *WHEN (po FOR EACH ROW) - warunek jaki musi być spełniony dla konkretnego rekordu (np. OLD.atrybut IS NULL - pomijamy :)

-- KOLOKWIUM II GRUPA 2
-- +------------+------------+-----------+-------------+-------------+-----------+--------------+
-- | cz_nap     | naprawy    | samochody | mechanicy   | klienci     | magazyn   | specjalnosci |
-- +------------+------------+-----------+-------------+-------------+-----------+--------------+
-- | id_cznap   | id_naprawy | id_sam    | id_mech     | id_kli      | id_czesci | id_spec      |
-- | id_czesci  | id_sam     | marka     | nazwisko    | nazwisko    | nazwa     | nazwa        |
-- | id_naprawy | id_kli     | model     | imię        | imię        | cena      |              |
-- |            | id_mech    | nr_rej    | data_ur     | nr_dowodu   | ilosc     |              |
-- |            | cena       |           | data_zatrud | miejscowosc |           |              |
-- |            | data       |           | id_spec     |             |           |              |
-- +------------+------------+-----------+-------------+-------------+-----------+--------------+

-- 1.Napisz procedurę (imię i nazwisko, data_ur parametry) wprowadzającą do tabeli NAPRAWY rekord rejestrujący nową
-- usługę. Aby można było zarejestrować nową usługę należy sprawdzić, czy klient o podanym nazwisku i imieniu
-- (parametry procedury) znajduje się już w bazie danych. Jeśli nie należy wprowadzić nowego klienta do tabeli
-- kLIENCI. Zaimplementuj obsługę błędów.

-- !??@!??!?!??@?!?D?S??@!?@?? stara chyba tego nie czytała nawet :)

-- 2.Napisz funkcję obliczającą, który z mechaników (nazwisko i imię mechanika - parametry wyjściowe) miał największą
-- ilość napraw. Funkcja powinna zwrócić liczbę samochodów, które zostały przez niego naprawione bez powtórzeń.
CREATE OR REPLACE FUNCTION najwiecejnapraw(nazw OUT VARCHAR2, im OUT VARCHAR2) RETURN NUMBER IS
    maxilosc NUMBER := 0;
BEGIN
    SELECT COUNT(n.id_naprawy), m.nazwisko, m.imie INTO maxilosc, nazw, im
    FROM naprawy n
    INNER JOIN mechanicy m ON m.id_mech = n.id_mech
    GROUP BY m.nazwisko, m.imie
    HAVING COUNT(n.id_naprawy) = (
        SELECT MAX(COUNT(n.id_naprawy))
        FROM naprawy n
        INNER JOIN mechanicy m ON m.id_mech = n.id_mech
        GROUP BY m.nazwisko, m.imie
        );
    RETURN maxilosc;
END;

-- 3.Napisz procedurę, której zadaniem jest obliczenie i wypisanie ceny wszystkich napraw, które zostały zlecone przez
-- poszczególnych klientów. Procedura ma zwracać sumaryczną cenę  wszystkich napraw.
CREATE OR REPLACE PROCEDURE cenynapraw(sumarycznasuma OUT NUMBER) IS
CURSOR kursor IS
    SELECT n.id_naprawy, k.imie, k.nazwisko, n.cena
    FROM naprawy n
    INNER JOIN klienci k ON k.id_kli = n.id_kli;
r kursor%ROWTYPE;
BEGIN
    sumarycznasuma := 0;
    FOR r IN kursor LOOP
        sumarycznasuma := sumarycznasuma + r.cena;
        DMBS_OUTPUT.PUT_LINE(n.id_naprawy || ' ' || k.imie || ' ' || k.nazwisko || ' ' || n.cena);
    END LOOP;
END;

-- 4.Napisz procedurę wyzwalaną dla tabeli NAPRAWY wstawiającą do pola klucz głównego kolejną wartość pobraną z
-- sekwencji BETA, którą trzeba utworzyć.
CREATE SEQUENCE beta
START WITH 200
INCREMENT BY 1;

CREATE OR REPLACE TRIGGER wstawklucz BEFORE INSERT ON naprawy
    FOR EACH ROW
--     WHEN (NEW.id_naprawy IS NULL)
    BEGIN
        :NEW.id_naprawy := beta.NEXTVAL;
    END;

-- 5. Utwórz z pakiet (sekcja specyfikacji i ciała) składający się z procedur i funkcji, które znajdują się w
-- tym zestawie.
CREATE OR REPLACE PACKAGE pakiecik AS
    FUNCTION najwiecejnapraw(nazw OUT VARCHAR2, im OUT VARCHAR2) RETURN NUMBER;
    PROCEDURE cenynapraw(sumarycznasuma OUT NUMBER);
END pakiecik;

CREATE OR REPLACE PACKAGE BODY pakiecik AS
    -- ciała funkcji i procedur
END pakiecik;

-- 6. Omów własności aktywnych baz danych
-- • Modele aktywności – zależności czasowe i przyczynowo-skutkowe między zdarzeniami i akcjami
-- • Zdarzenia elementarne – zbiór typów zdarzeń, które mogą być podstawą definiowania aktywnych reguł
-- • Operatory zdarzeniowe – zbiór operatorów umożliwiających specyfikację złożonych wyrażeń zdarzeniowych
-- • Kontekst definicji aktywnych reguł – pojedyncza dana, zbiór danych, baza danych

-- KOLOKWIUM II Grupa 3
-- +------------+------------+-----------+-------------+-------------+-----------+--------------+
-- | cz_nap     | naprawy    | samochody | mechanicy   | klienci     | magazyn   | specjalnosci |
-- +------------+------------+-----------+-------------+-------------+-----------+--------------+
-- | id_cznap   | id_naprawy | id_sam    | id_mech     | id_kli      | id_czesci | id_spec      |
-- | id_czesci  | id_sam     | marka     | nazwisko    | nazwisko    | nazwa     | nazwa        |
-- | id_naprawy | id_kli     | model     | imię        | imię        | cena      |              |
-- |            | id_mech    | nr_rej    | data_ur     | nr_dowodu   | ilosc     |              |
-- |            | cena       |           | data_zatrud | miejscowosc |           |              |
-- |            | data       |           | id_spec     |             |           |              |
-- +------------+------------+-----------+-------------+-------------+-----------+--------------+
-- 1. Napisz procedurę wprowadzającą do tabeli magazyn rekordy rejestrujące nowe części. Dotyczy ono tych części,
-- których brakuje w magazynie, a potrzebne są do naprawy samochodu o id_naprawy (parametr). Wykorzystaj obsługę błędów
CREATE OR REPLACE PROCEDURE dodajnowaczesc(samochod NUMBER, nazwa_czesci IN VARCHAR2, cena IN NUMBER) IS
czyczescwmagazynie NUMBER;
lastidmagazyn NUMBER;
czescwmagazynie EXCEPTION ;
BEGIN
    -- sprawdzam czy czesc jest w magazynie
    SELECT COUNT(m.id_czesci) INTO czyczescwmagazynie
    FROM naprawy n
    INNER JOIN samochody s ON s.id_sam = n.id_sam
    INNER JOIN cz_nap c ON c.id_naprawy = n.id_naprawy
    INNER JOIN magazyn m ON m.id_czesci = c.id_czesci
    WHERE s.id_sam = samochod;

    IF czyczescwmagazynie = 0 THEN
        SELECT MAX(id_czesci) INTO lastidmagazyn FROM magazyn;
        INSERT INTO magazyn VALUES (lastidmagazyn + 1, nazwa_czesci, cena, 0);
    ELSE
        RAISE czescwmagazynie;
    END IF;

    EXCEPTION
        WHEN czescwmagazynie THEN DBMS_OUTPUT.PUT_LINE('Czesc jest juz w magazynie');
        WHEN OTHERS THEN DBMS_OUTPUT.PUT_LINE('ERROR');
END;

-- 2. Napisz funkcję, która obliczy, koszt wszystkich napraw, jakie miał klient o nazwisku i imieniu podanym jako
-- parametry wejściowe. Funkcja powinna zwrócić jako parametr wyjściowy całkowity koszt wszystkich napraw
CREATE OR REPLACE FUNCTION sumanapraw(im IN VARCHAR2, nazw IN VARCHAR2) RETURN NUMBER IS
suma NUMBER := 0;
CURSOR kursor IS
    SELECT n.cena
    FROM naprawy n
    INNER JOIN klienci k ON k.id_kli = n.id_kli
    WHERE k.imie = im AND k.nazwisko = nazw;
r kursor%ROWTYPE;
BEGIN
    FOR r IN kursor LOOP
        suma := suma + r.cena;
    END LOOP;
    RETURN suma;
END;

-- 3. Napisz procedurę, której zadaniem jest dla podanego nazwiska i imienia mechanika (parametry) zapisanie informacji
-- o wszystkich samochodach, które zostały przez niego naprawione. Markę, model i numer rejestracyjny samochodu należy
-- wstawić do tabeli historia, przy założeniu, że tabela o tej strukturze istnieje w bazie danych.
-- Zaimplementuj obsługę błędów:
-- a) braku mechanika o podanym nazwisku;
-- b) braku napraw przez niego wykonanych;
-- c) pozostałych błędów.
CREATE OR REPLACE PROCEDURE dodajlog(im IN VARCHAR2, nazw IN VARCHAR2) IS
CURSOR kursor IS
    SELECT s.marka, s.model, s.nr_rej
    FROM naprawy n
    INNER JOIN samochody s ON s.id_sam = n.id_sam
    INNER JOIN mechanicy m ON m.id_kli = m.id_kli
    WHERE m.imie = im AND m.nazwisko = nazw;
r kursor%ROWTYPE;
mechanik NUMBER;
brakmechanika EXCEPTION;
braknapraw EXCEPTION;
i NUMBER := 0;
BEGIN
    SELECT id_mech FROM mechanik m WHERE m.imie = im AND m.nazwisko = nazw;
    IF id_mech IS NULL THEN
        RAISE brakmechanika;
    END IF;
    FOR r IN kursor LOOP
        i := i + 1;
        INSERT INTO historia VALUES(r.marka, r.model, r.nr_rej);
    END LOOP;
    IF i = 0 THEN
        RAISE braknapraw;
    END IF;
    EXCEPTION
    WHEN brakmechanika THEN DBMS_OUTPUT.PUT_LINE('brak mechanika');
    WHEN braknapraw THEN DBMS_OUTPUT.PUT_LINE('brak napraw');
    WHEN OTHERS THEN DBMS_OUTPUT.PUT_LINE('ERROR');
END;

-- 4. Napisz procedurę wyzwalaną, która ma utrzymywać stały budżetu zakładu. Zmiany, które mają wpływ na budżet
-- zakładu są związane ze zwalnianiem i zatrudnianiem mechaników oraz zmianą ich zarobków.
CREATE OR REPLACE TRIGGER stalybudzet BEFORE INSERT OR DELETE ON mechanicy
    FOR EACH ROW
    DECLARE
        sumazarobkow NUMBER := 0;
        liczbazatrudnionych NUMBER := 0;
        nowapensja NUMBER := 0;
        CURSOR kursor IS
            SELECT pensja, id_mech
            FROM mechanicy;
        r kursor%ROWTYPE;
    BEGIN
        -- CO? zakładam że wszyscy zarabiają tyle samo cały czas i że naprawy nie mają wpływu na budżet
        SELECT SUM(pensja), COUNT(id_mech) INTO sumazarobkow, liczbazatrudnionych FROM mechanicy;
        IF INSERTING THEN
            nowapensja := sumazarobkow/(liczbazatrudnionych+1);
        ELSIF DELETING THEN
            nowapensja := sumazarobkow/(liczbazatrudnionych-1);
        END IF;
        FOR r IN kursor LOOP
            UPDATE mechanicy SET pensja = nowapensja WHERE CURRENT OF kursor;
        END LOOP;
    END;

-- 5. Utwórz z pakiet (sekcja specyfikacji i ciała) składający się z procedur i funkcji, które znajdują się w
-- tym zestawie.
CREATE OR REPLACE PACKAGE pakiecik AS
    PROCEDURE dodajnowaczesc(samochod NUMBER, nazwa_czesci IN VARCHAR2, cena IN NUMBER);
    FUNCTION sumanapraw(im IN VARCHAR2, nazw IN VARCHAR2) RETURN NUMBER;
    PROCEDURE dodajlog(im IN VARCHAR2, nazw IN VARCHAR2);
END pakiecik;

CREATE OR REPLACE PACKAGE BODY pakiecik AS
    -- ciała funkcji
END pakiecik;

-- 6. Jakie wymagania powinien spełniać zbiór potencjalnie powiązanych reguł
-- • własność stopu – przetwarzanie akcji reguł uaktywnionych przez pojedyncze zdarzenie zostanie zakończone w
-- skończonym czasie
-- • determinizm stanu – kolejność wykonania akcji reguł uaktywnionych tym samym zdarzeniem nie ma wpływu na końcowy
-- stan bazy danych

-- KOLOKWIUM II Grupa 6
-- +------------+------------+--------------+--------------+------------+--------------+
-- | obsługa    | sale       | rozprawy     | pozwani      | typ_sprawy | specjalnosci |
-- +------------+------------+--------------+--------------+------------+--------------+
-- | id_obsługi | id_sali    | id_rozprawy  | id_pozwanego | id_typu    | id_spec      |
-- | nazwisko   | nazwa      | id_pozwanego | nazwisko     | nazwa      | nazwa        |
-- | imie       | poziom_zab | id_typu      | imię         |            |              |
-- | id_spec    |            | id_obsługi   | data_ur      |            |              |
-- |            |            | data         | pesel        |            |              |
-- |            |            | godzina      | kod_pocztowy |            |              |
-- |            |            | id_sali      | miejscowość  |            |              |
-- |            |            |              | ulica        |            |              |
-- +------------+------------+--------------+--------------+------------+--------------+

-- 1. Napisz procedurę  wprowadzającą do tabeli ROZPRAWY rekord rejestrujący nową rozprawę. Aby można było
-- zarejestrować nową rozprawę należy sprawdzić, czy pozwany o podanym nazwisku i imieniu (parametry procedury)
-- znajduje się już w bazie danych. Jeśli nie należy wprowadzić nowego pozwanego do tabeli POZWANI.
-- Zaimplementuj obsługę błędów.
CREATE OR REPLACE PROCEDURE nowarozprawa(idtyp IN NUMBER, idobs IN NUMBER, data IN DATE,
                                        godz IN VARCHAR2, sala IN NUMBER, nazw IN VARCHAR2, im IN VARCHAR2,
                                        ur IN DATE, pesel IN NUMBER, kod IN NUMBER, miejsc IN VARCHAR2, ul IN VARCHAR2) IS
czypozwwbazie NUMBER;
lastidroz NUMBER;
idpoz NUMBER;
BEGIN
    SELECT COUNT(id_pozwanego) INTO czypozwwbazie FROM pozwani WHERE imie = im AND nazwisko = nazw;
    IF czypozwwbazie = 0 THEN
        SELECT MAX(id_pozwanego) INTO idpoz FROM pozwani;
        idpoz := idpoz + 1;
        INSERT INTO pozwani VALUES(idpoz, nazw, im, ur, pesel, kod, miejsc, ul);
    ELSE
        SELECT id_pozwanego INTO idpoz FROM pozwani WHERE imie = im AND nazwisko = nazw;
    END IF;
    SELECT MAX(id_rozprawy) INTO lastidroz FROM rozprawy;
    INSERT INTO rozprawy VALUES (lastidroz+1, idpoz, idtyp, idobs, data, godz, sala);
    EXCEPTION
        WHEN OTHERS THEN DMBS_OUTPUT.PUT_LINE('Error');
END;

-- 2. Napisz funkcję, która wyświetli wszystkie rozprawy (nazwisko i imię pozwanego, adwokata oraz termin rozprawy),
-- które odbyły się w zadanym okresie (parametry od i do) oraz obliczy i zwróci ich liczbę. Rozprawy nie mogą się
-- powtarzać i muszą być wyświetlone w porządku odwróconym w stosunku do daty rozprawy.
CREATE OR REPLACE FUNCTION liczbarozpraw(od DATE, DO DATE) RETURN NUMBER IS
liczba NUMBER := 0;
CURSOR kursor IS
    SELECT DISTINCT p.imie, p.nazwisko, r.data, a.imie, a.nazwisko
    FROM rozprawy r
    INNER JOIN pozwani p ON p.id_pozwanego = r.id_pozwanego
    INNER JOIN adwokaci a ON a.id_adwokata = r.id_adwokata
    WHERE r.data >= od AND r.data <= DO
    ORDER BY r.data DESC;
r kursor%ROWTYPE;
BEGIN
    FOR r IN kursor LOOP
        liczba := liczba + 1;
        DBMS_OUTPUT.PUT_LINE('wypisz kolumny');
    END LOOP;
    RETURN liczba;
END;

-- 3. Napisz procedurę, której zadaniem jest wypisanie dla podanego nazwiska i imienia pozwanego (parametry)
-- informacji o rozprawach, które go dotyczyły. Są to: nazwisko i imię sędziego, typ rozprawy, sala, data godzina.
-- Informacje te należy wpisać do tabeli historia, której struktura istnieje w bazie danych.
-- Zaimplementuj obsługę błędów:
-- a) braku pozwanego o podanym nazwisku;
-- b) braku rozpraw z jego udziałem;
-- c) pozostałych błędów. Skorzystaj z wyjątków predefiniowanych
CREATE OR REPLACE PROCEDURE udzialwrozprawach(im IN VARCHAR2, nazw IN VARCHAR2) IS
CURSOR kursor IS
    SELECT s.imie, s.nazwisko, t.nazwa, sa.nazwa, r.data
    FROM rozprawy r
    INNER JOIN sale sa ON sa.id_sali = r.id_sali
    INNER JOIN sedzia s ON s.id_sedzi = r.id_sedzi
    INNER JOIN typ_rozpr t ON t.id_typ = r.id_typ
    INNER JOIN pozwani p ON p.id_pozw = r.id_pozw
    WHERE p.imie = im AND p.nazwisko = nazw;
liczba NUMBER := 0;
czypozwwbazie NUMBER;
brakpozw EXCEPTION;
brakrozpraw EXCEPTION;
r kursor%ROWTYPE;
BEGIN
    SELECT COUNT(id_pozwany) INTO czypozwwbazie FROM pozwani p WHERE p.imie = im AND p.nazwisko = nazw;
    IF czypozwwbazie = 0 THEN
        RAISE brakpozw;
    ELSE
        FOR r IN kursor LOOP
            liczba := liczba + 1;
            DBMS_OUTPUT.PUT_LINE('wypisz wszystko');
        END LOOP;
        IF liczba = 0 THEN
            RAISE brakrozpraw;
        END IF;
    END IF;
    EXCEPTION
        WHEN brakpozw THEN DBMS_OUTPUT.PUT_LINE('brak pozwanego');
        WHEN brakrozpraw THEN DBMS_OUTPUT.PUT_LINE('brak rozpraw');
        WHEN DATA_NOT_FOUND THEN DBMS_OUTPUT.PUT_LINE('xd');
        WHEN OTHERS THEN DBMS_OUTPUT.PUT_LINE('xd');
END;

-- 4. Napisz procedurę wyzwalaną, która ma trzymywać liczbę rozpraw w ciągu każdego dnia nieprzekraczającą pewnej
-- stałej. Zmiany, które mają wpływ na liczbę rozpraw to dodanie nowej rozprawy lub wykreślenie jej z porządku
-- na dany dzień.

-- nie bardzo rozumiem, robię tak, że sprawdzam liczbę rozpraw danego dnia i jeżeli jest mniejsza od stałej to dodaje, jak nie to olewam
CREATE OR REPLACE TRIGGER sprawdzczymoznadodacrozprawetrigger INSTEAD OF INSERT ON rozprawy FOR EACH ROW
    DECLARE
        lrozpraw NUMBER := 0;
        MAX_L_ROZPRAW CONSTANT NUMBER := 10;
        zaduzo EXCEPTION;
    BEGIN
        SELECT COUNT(r.id_rozpr) INTO lrozpraw FROM rozprawy WHERE data = SYSDATE;
        IF lrozpraw >= MAX_L_ROZPRAW THEN
            INSERT INTO rozprawy VALUES (:NEW:kolumna, :NEW:kolumna2);
        ELSE
            RAISE zaduzo;
        END IF;
        EXCEPTION
        WHEN zaduzo THEN DBMS_OUTPUT.PUT_LINE('xd');
    END;

-- KOLOKWIUM II Grupa 4
-- +---------+-------------+-------------+------------------+-----------------+---------------+
-- | gatunek | wydawnictwo | ksiazki     | autorzy          | wypozyczenia    | czytelnicy    |
-- +---------+-------------+-------------+------------------+-----------------+---------------+
-- | id_gat  | id_wyd      | id_ksiazki  | id_autora        | id_wypozyczenia | id_czytelnika |
-- | nazwa   | nazwa       | id_autora   | nazwisko         | id_czytelnika   | nazwisko      |
-- |         |             | tytul       | imię             | id_ksiazki      | imię          |
-- |         |             | id_gatunku  | kraj_pochodzenia | data_wyp        | data_ur       |
-- |         |             | ilosc_stron |                  | data_zwr        | pesel         |
-- |         |             | ISBN        |                  |                 | kod_pocztowy  |
-- |         |             | cena        |                  |                 | miejscowość   |
-- |         |             | id_wyd      |                  |                 | ulica         |
-- |         |             | data_wyd    |                  |                 | kara          |
-- +---------+-------------+-------------+------------------+-----------------+---------------+

-- 1. Napisz procedurę  wprowadzającą do tabeli WYPOŻYCZENIA rekord rejestrujący nowe wypożyczenie. Aby można było
-- zarejestrować nowe wypożyczenie należy sprawdzić, czy czytelnik o podanym nazwisku i imieniu (parametry procedury)
-- znajduje się już w bazie danych. Jeśli nie należy wprowadzić nowego czytelnika do tabeli CZYTELNICY.
-- Zaimplementuj obsługę błędów.
CREATE OR REPLACE PROCEDURE dodajwypozyczenie(im IN VARCHAR2, nazw IN VARCHAR2, idks NUMBER, dwyp DATE, dzwr DATE,
                                                dur DATE, pesel NUMBER, kod VARCHAR2, miejsc VARCHAR2, ul VARCHAR2, kara NUMBER) IS
czywbazie NUMBER;
idczyt NUMBER;
idwyp NUMBER;
BEGIN
    SELECT COUNT(c.id_czytelnika) INTO czywbazie FROM czytelnicy WHERE imie = im AND nazwisko = nazw;
    IF czywbazie = 0 THEN
        SELECT MAX(id_czytelnika) INTO idczyt FROM czytelnicy;
        idczyt := idczyt + 1;
        INSERT INTO czytelnicy VALUES (idczyt, nazw, im, dur, pesel, kod, miejsc, ul, kara);
    ELSE
        SELECT id_czytelnika INTO idczyt FROM czytelnicy;
    END IF;
    SELECT MAX(id_wypozyczenia) INTO idwyp FROM wypozyczenia;
    INSERT INTO wypozyczenia VALUES(idwyp + 1, idczyt, idks, dwyp, dzwr);
    EXCEPTION
        WHEN OTHERS THEN DBMS_OUTPUT.PUT_LINE('xd');
END;

-- 2. Napisz funkcję, która pobierze i wyświetli wszystkie książki, które były w stanie wypożyczenia w zadanym okresie
-- (parametry od i do) . Książki nie mogą się powtarzać i muszą być wyświetlone w porządku odwróconym w stosunku do
-- roku wydania. Funkcja ma zwrócić liczbę wypożyczonych książek, które zostały wydane po roku 2015.
CREATE OR REPLACE FUNCTION liczbawypozyczonychksiazek(od DATE, DO DATE) RETURN NUMBER IS
liczba NUMBER := 0;
CURSOR kursor IS
    SELECT DISTINCT k.tytul, k.data_wyd
    FROM ksiazki k
    INNER JOIN wypozyczenia w ON w.id_ksiazki = k.id_ksiazki
    WHERE k.data_wyp >= od AND k.data_wyp <= DO
    ORDER BY k.data_wyd DESC;
r kursor%ROWTYPE;
BEGIN
    FOR r IN kursor LOOP
        IF YEAR(r.data_wyd) > 2015 THEN
            liczba := liczba + 1;
        END IF;
        DBMS_OUTPUT.PUT_LINE('xd');
    END LOOP;
    RETURN liczba;
END;

-- 3. Napisz procedurę, która dla podanego gatunku literackiego (parametr) wyświetli autora, tytuł, oraz nazwę gatunku
-- wszystkich książek wydanych  w ciągu ostatniego roku. Dane mają być posortowane alfabetycznie według nazwisk i imion
-- autorów. Procedura jako parametr wyjściowy ma zwracać liczbę książek z podanego gatunku, która znajduje się w
-- bibliotece.
CREATE OR REPLACE PROCEDURE wyswietlinformacjeoksiazce(gat IN VARCHAR2, liczba OUT NUMBER) IS
CURSOR kursor IS
    SELECT a.nazwisko, a.imie, k.tytul, g.nazwa
    FROM ksiazki k
    INNER JOIN autorzy a ON a.id_autora = k.id_autora
    INNER JOIN gatunek g ON g.id_gat = k.id_gat
    WHERE g.nazwa = gat AND YEAR(k.data_wyd) = YEAR(SYSDATE)
    ORDER BY a.nazwisko, a.imie;
r kursor%ROWTYPE;
BEGIN
    liczba := 0;
    FOR r IN kursor LOOP
        liczba := liczba + 1;
        DBMS_OUTPUT.PUT_LINE('xd');
    END LOOP;
END;

-- 4. Napisz procedurę wyzwalaną, która ma utrzymywać stałą liczbę wypożyczonych książek. Zmiany, które mają wpływ
-- na liczbę wypożyczonych książek są związane z pożyczaniem i oddawaniem książki lub zakupem nowej.
-- NIE ROZUMIEM

-- KOLOKWIUM II Grupa 5
-- +-------------+--------------+-----------------+-------------+--------------+
-- | gabinety    | pacjencji    | lekarze         | wizyty      | specjalnosci |
-- +-------------+--------------+-----------------+-------------+--------------+
-- | id_gabinetu | id_pacjenta  | id_lekarza      | id_wizyty   | id_spec      |
-- | nazwa       | nazwisko     | nazwisko        | id_pacjenta | nazwa        |
-- |             | imię         | imię            | id_lekarza  |              |
-- |             | data_ur      | id_specjalnosci | id_gabinetu |              |
-- |             | pesel        |                 | data        |              |
-- |             | kod_pocztowy |                 | godzina     |              |
-- |             | miejscowość  |                 |             |              |
-- |             | ulica        |                 |             |              |
-- +-------------+--------------+-----------------+-------------+--------------+

-- 1. Napisz procedurę  wprowadzającą do tabeli WIZYTY rekord rejestrujący nową wizytę. Aby można było zarejestrować
-- nową wizytę należy sprawdzić, czy pacjent o podanym nazwisku i imieniu (parametry procedury) znajduje się już w
-- bazie danych. Jeśli nie należy wprowadzić nowego pacjenta do tabeli PACJENCI. Zaimplementuj obsługę błędów.
-- PRAKTYCZNIE TO SAMO CO W INNYCH GRUPACH

-- 2. Napisz funkcję, która pobierze i wyświetli wszystkich pacjentów, którzy mieli wizyty w zadanym okresie
-- (parametry od i do). Należy wypisać nazwisko i imię pacjenta, datę wizyty oraz nazwisko i imię lekarza.
-- Funkcja ma zwrócić liczbę wizyt, pacjenta, który tych wizyt miał najwięcej.
-- TO TEŻ JUŻ BYŁO

-- 3. Napisz procedurę, która wyprowadzi jako parametry wyjściowe nazwisko i imię lekarza, który przyjął największą
-- liczbę pacjentów. Wewnątrz procedury należy wypisać nazwiska i imiona wszystkich lekarzy wraz z ilością przyjętych
-- przez nich pacjentów. Dane mają być posortowane alfabetycznie według nazwisk i imion lekarzy.
CREATE OR REPLACE PROCEDURE najlepszylekarzorazwypiszwszystkichlekarzyprocedura(im OUT VARCHAR2, nazw OUT VARCHAR2, maxlwizyt OUT VARCHAR2) IS
CURSOR kursor IS
    SELECT l.imie, l.nazwisko, COUNT(w.id_wizyty) lwizyt
    FROM lekarze l
    INNER JOIN wizyty w ON w.id_lekarza = l.id_lekarza
    ORDER BY l.nazwisko, l.imie;
r kursor%ROWTYPE;
BEGIN
    maxlwizyt := 0;
    FOR r IN kursor LOOP
        IF r.lwizyt > maxlwizyt THEN
            maxlwizyt := r.lwizyt;
            im := r.imie;
            nazw := r.nazwisko;
        END IF;
        DBMS_OUTPUT.PUT_LINE(r.imie || ' ' || r.nazwisko || ' ' || r.lwizyt);
    END LOOP;
END;


-- 4. Napisz procedurę wyzwalaną, która przed wykonaniem operacji DELETE i INSERT dla każdego wiersza tabeli WIZYTY
-- doda do tabeli TEST informację w postaci ciągu znaków: „A operacja B” , gdzie operacja to nazwa wykonywanej
-- operacji, A, B to wartości poszczególnych atrybutów przed wykonaniem operacji i po jej wykonaniu.
-- Tabela TEST istnieje i ma odpowiednią strukturę
CREATE OR REPLACE TRIGGER dodajdotablicytestinformacjeooperacjitrigger BEFORE DELETE OR INSERT ON wizyty FOR EACH ROW
    BEGIN
        IF DELETING THEN
            INSERT INTO test VALUES (:OLD.id_wizyty || ' ' || :OLD.id_pacjenta || '... DELETE ' || :NEW.id_wizyty || ' ' || :NEW.id_pacjent || '...');
        ELSIF INSERTING THEN
            INSERT INTO test VALUES (:OLD.id_wizyty || ' ' || :OLD.id_pacjenta || '... INSERT ' || :NEW.id_wizyty || ' ' || :NEW.id_pacjent || '...');
        END IF;
    END;

-- 6. Omów wyzwalacze INSTEAD OF oraz dla wielu zdarzeń.
-- INSTEAD OF:
-- • Definiowany tylko dla perspektyw
-- • Wykonywany zamiast polecenia, które uruchomiło
-- wyzwalacz
-- • Stosowany najczęściej dla perspektyw złożonych
-- celem zapewnienia ich modyfikowalności
-- • Nie można bezpośrednio odwoływać się do
-- atrybutów perspektywy

-- DLA WIELU ZDARZEŃ:
-- AFTER/BEFORE/INSTEAD OF INSERT OR BEFORE OR DELETE
-- • Uruchamiany przez kilka zdarzeń
-- • Aby selekcjonować kod, który ma być wykonany w przypadku
-- wystąpienia określonego zdarzenia używa się zmiennych logicznych
-- INSERTING, DELETING i UPDATING, które przyjmują wartość
-- prawdy jeśli zdarzeniem uruchamiającym wyzwalacz jest odpowiednio
-- zdarzenie INSERT, DELETE bądź UPDATE


-- KOLOKWIUM III Rózne zadania
-- Korzystając z pakietu DBMS_SQL napisz procedurę usuwającą tabelę o podanej nazwie będącej parametrem procedury.
CREATE OR REPLACE PROCEDURE usuntabele(tabela VARCHAR2) IS
    kursor INTEGER := DBMS_SQL.OPEN_CURSOR;
    ret INTEGER;
    stmt VARCHAR2(255);
BEGIN
    stmt := 'DROP TABLE :tab';
    DBMS_SQL.PARSE(kursor, stmt, DBMS_SQL.NATIVE);
    DBMS_SQL.BIND_VARIABLE(kursor, ':tab', tabela);
    ret := DBMS_SQL.EXECUTE(kursor);
    DBMS_SQL.CLOSE_CURSOR(kursor);
END;

-- Utworzyć procedurę przyjmującą jako parametry nazwę tabeli i nazwę kolumny. Zapisz w tabeli TEST
-- (tabela istnieje i jest jednokolumnowa) korzystając z dynamicznego SQL ilości rekordów w tabeli podanej
-- jako parametr oraz liczbę różnych wartości kolumny podanej jako parametr.
CREATE OR REPLACE PROCEDURE liczbarekordowiroznychwartosci(tab VARCHAR2, kol VARCHAR2) IS
    lrekordow INTEGER;
    lwartosci INTEGER;
    BEGIN
        EXECUTE IMMEDIATE 'SELECT COUNT(*) FROM ' || tab INTO lrekordow;
        EXECUTE IMMEDIATE 'SELECT COUNT(DISTINCT '|| kol || ') FROM ' || tab INTO lwartosci;
        EXECUTE IMMEDIATE 'INSERT INTO test VALUES(''liczba rekordow: ' || lrekordow || ' liczba wartosci: ' || lwartosci || ''')';
    END;


-- Korzystając z pakietu DBMS_SQL napisz procedurę uaktualniając rekord z nazwiskiem KOWALSKA na
-- KOWALSA_NOWY z tabeli o podanej nazwie będącej parametrem procedury.
CREATE OR REPLACE PROCEDURE zmiennazwisko(tab VARCHAR2) IS
    kursor INTEGER := DBMS_SQL.OPEN_CURSOR;
    stmt VARCHAR2(255);
    ret INTEGER;
BEGIN
    stmt := 'UPDATE :tab SET nazwisko=''KOWALSA NOWY'' WHERE nazwisko=''KOWALSKA''';
    DBMS_SQL.PARSE(kursor, stmt, DBMS_SQL.NATIVE);
    DBMS_SQL.BIND_VARIABLE(kursor, ':tab', tab);
    ret := DBMS_SQL.EXECUTE(kursor);
    DBMS_SQL.CLOSE_CURSOR(kursor);
END;

-- Utworzyć procedurę przyjmującą jako parametry nazwę tabeli i nazwę kolumny typu NUMBER. Korzystając z
-- dynamicznego SQL policz sumę wartości z kolumny będącej parametrem wywołania oraz liczbę różnych wartości tej
-- kolumny Wynik zapisz w tabeli jednokolumnowej w postaci np.: SUMA = 34, liczba różnych = 5
CREATE TABLE tabelka (
    kolumna VARCHAR2(255) NOT NULL
);
CREATE OR REPLACE PROCEDURE sumawartoscikolumny(tab VARCHAR2, kol VARCHAR2) IS
    suma INTEGER;
    lwartosci INTEGER;
    BEGIN
        EXECUTE IMMEDIATE 'SELECT SUM('|| tab || ',' || kol ||') FROM ' || tab INTO suma;
        EXECUTE IMMEDIATE 'SELECT COUNT(DISTINCT '|| kol || ') FROM ' || tab INTO lwartosci;
        EXECUTE IMMEDIATE 'INSERT INTO tabelka VALUES(''SUMA: ' || suma || ', liczba roznych: ' || lwartosci || ''')';
    END;

-- Korzystając z pakietu DBMS_SQL napisz procedurę usuwającą rekord z tabeli o podanej nazwie będącej parametrem
-- procedury
CREATE OR REPLACE PROCEDURE proceduradousuwaniarekorduzkonkretnejtabeli(tab VARCHAR2, id NUMBER) IS
kursor INTEGER := DBMS_SQL.OPEN_CURSOR;
stmt VARCHAR2(255);
ret INTEGER;
BEGIN
    stmt := 'DELETE FROM :tab WHERE id = :id';
    DBMS_SQL.PARSE(kursor, stmt, DBMS_SQL.NATIVE);
    DBMS_SQL.BIND_VARIABLE(kursor, ':tab', tab);
    DBMS_SQL.BIND_VARIABLE(kursor, ':id', id);
    ret := DBMS_SQL.EXECUTE(kursor);
    DBMS_SQL.CLOSE_CURSOR(kursor);
END;

-- Utworzyć procedurę wypisującą na ekran ilość studentów urodzonych w roku 1990, których imię, nazwisko
-- pasuje do podanego wzorca.
CREATE OR REPLACE PROCEDURE iloscstudentowurodzonychwroku1990(im VARCHAR2, nazw VARCHAR2) IS
liczba NUMBER;
BEGIN
    EXECUTE IMMEDIATE 'SELECT COUNT(*) FROM tabela WHERE imie LIKE ' || im || ' AND nazwisko LIKE ' || nazw INTO liczba;
    DBMS_SQL.PUT_LINE(liczba);
END;

-- Omów funkcje i procedury pakietu DBMS_SQL
-- • Służy do wykonywania dynamicznych zapytań SQL
-- • Bardziej złożony niż NDS, jednak niezbędny w
-- szczególnych przypadkach np. gdy lista SELECT jest
-- nieznana (nieznany zbiór kolumn)
-- Procedury pakietu:
-- • DESCRIBE_COLUMNS
-- • DESCRIBE_COLUMNS2
-- • OPEN_CURSOR – otwiera nowy kursor i zwraca jego ID (numer)
-- DBMS_SQL.OPEN_CURSOR RETURN INTEGER;
-- • CLOSE_CURSOR – zamyka kursor
-- • EXECUTE – wykonuje kursor (podany przez ID) i zwraca liczbę
-- przetworzonych wierszy
-- • EXECUTE_AND_FETCH – uruchamia instrukcję powiązana z
-- otwartym kursorem DBMS_SQL i pobiera z niego wiersze
-- • IS_OPEN – sprawdza, czy podany kursor jest otwarty
-- • DEFINE_COLUMN – definiuje kolumny, które mają być
-- pobrane z kursora
-- • PARSE – dokonanie analizy i weryfikacji zapytania SQL
-- • BIND_VARIABLE – wiąże podane wartości ze zmiennymi w kursorze
-- • FETCH_ROWS – pobiera wiersze z kursora o danym ID