-- 1. Zdefiniuj typ obiektowy reprezentujący KSIAZKE. Każda książka
-- powinien mieć autora, tytuł, liczbę stron oraz datę wydania i cenę, liczbę
-- wypożyczeń. Utwórz tablicę obiektową i KSIAZKI przechowują obiekty
-- tego typu. Wprowadź kilka przykładowych obiektów, obejrzyj zawartość
-- tabeli w postaci obiektowej i w postaci relacyjnej

CREATE OR REPLACE TYPE ksiazka AS OBJECT
(
    autor        VARCHAR2(30),
    tytul        VARCHAR2(30),
    lstron       NUMBER(10),
    data_wydania DATE,
    cena         FLOAT
);

CREATE TABLE ksiazki OF ksiazka;
INSERT INTO ksiazki VALUES (NEW ksiazka('Tolkien', 'Wladca Pierscieni Dwie wieze', 500, DATE '1970-01-01', 500));
INSERT INTO ksiazki VALUES (NEW ksiazka('Tolkien', 'Wladca Pierscieni Powrot krola', 500, DATE '1971-01-01', 600));
SELECT VALUE(k) FROM ksiazki k;
SELECT * FROM ksiazki;


-- 2. Utwórz tabelę BIBLIOTEKI zawierającą nazwę biblioteki, adres oraz
-- atrybut obiektowy KSIAZKA. Wprowadź do tabeli przykładowe dane
-- i wyświetl jej zawartość.


CREATE TABLE biblioteki (
    nazwa VARCHAR2(30),
    adres VARCHAR2(50),
    ksiazka ksiazka
);
INSERT INTO biblioteki VALUES ('Jakas tam nazwa', 'Lea 240', NEW ksiazka('Tolkien', 'Wladca Pierscieni Powrot krola', 500, DATE '1971-01-01', 600));
INSERT INTO biblioteki VALUES ('Jakas tam nazwa 2', 'Lea 236', NEW ksiazka('Tolkien', 'Wladca Pierscieni Powrot krola', 500, DATE '1971-01-01', 600));
SELECT nazwa, adres FROM biblioteki;
SELECT b.nazwa, b.ksiazka.tytul FROM biblioteki b;

-- 3. Wartość książki maleje o 5% z każdym rokiem. Dodaj do typu obiektowego
-- KSIAZKA metodę wyliczającą na podstawie daty wydania
-- i ceny aktualną wartość książki (wykorzystaj polecenie ALTER i
-- zaimplementuj ciało). Wykonaj zapytanie do tabeli, które aktywuje tę
-- metodę.


ALTER TYPE ksiazka REPLACE AS OBJECT
(
    autor        VARCHAR2(30),
    tytul        VARCHAR2(30),
    lstron       NUMBER(10),
    data_wydania DATE,
    cena         FLOAT,
    MEMBER FUNCTION cenaksiazki RETURN NUMBER
);

CREATE OR REPLACE TYPE BODY ksiazka IS
    MEMBER FUNCTION cenaksiazki RETURN NUMBER IS
        lata NUMBER(2);
        wynik NUMBER(10,2) := 0;
    BEGIN
        lata := EXTRACT(YEAR FROM CURRENT_TIMESTAMP) - EXTRACT(YEAR FROM data_wydania);
        wynik := cena;
        FOR i IN 0..lata LOOP
            wynik := wynik * 0.95;
        END LOOP;
        RETURN wynik;
    END cenaksiazki;
END;

SELECT p.tytul, p.cenaksiazki() FROM ksiazki p;

-- 4. Dodaj do typu KSIAZKA metodę odwzorowującą, która pozwoli na
-- porównywanie książek na podstawie lat od daty ich wydania raz
-- zniszczenia (decyduje ilość wypożyczeń). Przyjmujemy, że 10
-- wypożyczeń to jeden rok jeśli chodzi o lata, które upłynęły od daty wydania
-- książki

ALTER TYPE ksiazka ADD MAP MEMBER FUNCTION odwzoruj RETURN NUMBER CASCADE INCLUDING TABLE DATA;

CREATE OR REPLACE TYPE BODY ksiazka IS
    MEMBER FUNCTION cenaksiazki RETURN NUMBER IS
        lata NUMBER(2);
        wynik NUMBER(10,2) := 0;
    BEGIN
        lata := EXTRACT(YEAR FROM CURRENT_TIMESTAMP) - EXTRACT(YEAR FROM data_wydania);
        wynik := cena;
        FOR i IN 0..lata LOOP
            wynik := wynik * 0.95;
        END LOOP;
        RETURN wynik;
    END cenaksiazki;
    MAP MEMBER FUNCTION odwzoruj RETURN NUMBER IS
        liczbalat NUMBER(10);
    BEGIN
        RETURN (EXTRACT(YEAR FROM CURRENT_TIMESTAMP) - EXTRACT(YEAR FROM data_wydania))*10;
    END;
END;

SELECT p.tytul, p.cenaksiazki(), p.odwzoruj() FROM ksiazki p;


-- 5. Utwórz typ CZYTELNIK zawierający nazwisko i imię czytelnika. Dodaj
-- do typu KSIAZKA referencje do CZYTELNIKA. Utwórz tabelę obiektową
-- CZYTELNICY i wypełnij obie tabele danymi.



DROP TYPE czytelnik FORCE;
CREATE OR REPLACE TYPE czytelnik AS OBJECT
(
    imie VARCHAR2(20),
    nazwisko VARCHAR2(20)
);

DROP TYPE ksiazka FORCE;

CREATE OR REPLACE TYPE ksiazka AS OBJECT
(
    autor        VARCHAR2(30),
    tytul        VARCHAR2(30),
    lstron       NUMBER(10),
    data_wydania DATE,
    cena         FLOAT,
    czyt         REF CZYTELNIK,
    MEMBER FUNCTION cenaksiazki RETURN NUMBER,
    MAP MEMBER FUNCTION odwzoruj RETURN NUMBER
);

DROP TABLE  czytelnicy;
CREATE TABLE czytelnicy OF czytelnik;
INSERT INTO czytelnicy VALUES(NEW czytelnik('Tomek', 'Pazera'));
INSERT INTO czytelnicy VALUES(NEW czytelnik('Zuza', 'Pazera'));
INSERT INTO czytelnicy VALUES(NEW czytelnik('Paulina', 'Pazera'));

SELECT r.imie FROM czytelnicy r;

DROP TABLE ksiazki;
CREATE TABLE ksiazki OF ksiazka;
INSERT INTO ksiazki VALUES(NEW ksiazka('Tolkien', 'Wladca Pierscieni Powrot krola', 500, DATE '1971-01-01', 600, (SELECT REF(c) FROM czytelnicy c WHERE c.imie = 'Tomek')));
INSERT INTO ksiazki VALUES(NEW ksiazka('Tolkien', 'Wladca Pierscieni Powrot krola', 500, DATE '1971-01-01', 600, (SELECT REF(c) FROM czytelnicy c WHERE c.imie = 'Zuza')));

SELECT r.czyt.imie FROM ksiazki r;

-- 6. Wypisz autora i tytuł książki oraz nazwiska i imiona czytelników
-- korzystając z nawigacji poprzez referencję.
SELECT o.autor, o.tytul, o.czyt.imie, o.czyt.nazwisko FROM ksiazki o;
SELECT o.autor, o.tytul, DEREF(o.czyt) FROM ksiazki o;


-- 7. Usuń z tabeli CZYTELNICY jeden obiekt. Wyszukaj w tabeli KSIAZKI ,
-- te książki, które nie mają przypisanego czytelnika (wiszące referencje) i
-- przypisz tym referencjom NULL. Wykorzystaj pojedyncze polecenie
-- DELETE i UPDATE.
SELECT * FROM czytelnicy;
DELETE FROM czytelnicy WHERE imie = 'Zuza';
SELECT * FROM ksiazki k WHERE czyt IS NULL;
UPDATE ksiazki SET czyt = NULL WHERE czyt IS dangling;

-- 8. Wykonaj kilka eksperymentów na tablicach o zmiennym rozmiarze.
-- Przykładowo: stwórz typ kolekcji zawierający informacje o przedmiotach
-- nauczanych na studiach (łańcuchy znaków). Napisz program w PL/SQL,
-- który tworzy kolekcję, wstawia do kolekcji przykładowe przedmioty,
-- rozszerza kolekcję, wyświetla zawartość kolekcji, usuwa elementy z końca
-- kolekcji, wyświetla informacje o długości kolekcji i o limicie na liczbę
-- elementów.

DROP TYPE przedmiot FORCE;

CREATE OR REPLACE TYPE przedm AS OBJECT
(
  nazwa VARCHAR2(30)
);

CREATE OR REPLACE TYPE tab_przedmioty IS VARRAY(5) OF przedm;

SET SERVEROUTPUT ON;

DECLARE
   names tab_przedmioty;
   total INTEGER;
   ostatni INTEGER;
BEGIN
   names := tab_przedmioty(NEW przedm('Matematyka'), NEW przedm('Polski'));
   total := names.COUNT;
   DBMS_OUTPUT.put_line('Liczba przedmiotow: '|| total);
   FOR i IN 1 .. total LOOP
      DBMS_OUTPUT.put_line('Przedmiot: ' || names(i).nazwa);
      NULL;
   END LOOP;

   names.extend;
   DBMS_OUTPUT.put_line('Ostatni: ' || names.LAST);
   DBMS_OUTPUT.put_line('Usuwamy ostatni rekord');
   names.TRIM;
   DBMS_OUTPUT.put_line('Dodajemy nowy rekord');
   names.extend;
   ostatni := names.LAST;
   names(ostatni) := NEW przedm('Angielski');
   total := names.COUNT;
   DBMS_OUTPUT.put_line('Liczba przedmiotow: '|| total);
   FOR i IN 1 .. total LOOP
      DBMS_OUTPUT.put_line('Przedmiot: ' || names(i).nazwa);
      NULL;
   END LOOP;

   DBMS_OUTPUT.put_line('Limit: '|| names.limit);

END;

-- 9. Utwórz typ tablicy o zmiennym rozmiarze przechowujący maksymalnie 30
-- liczb, który będzie reprezentował listę ocen studenta. Utwórz typ
-- obiektowy Student, który posiada atrybuty: indeks (typ liczbowy),
-- nazwisko (typ łańcuchowy) oraz oceny (typu wcześniej zdefiniowanej
-- kolekcji). Utwórz tabelę obiektową STUDENCI przechowującą obiekty
-- typu STUDENT. Wstaw za pomocą polecenia INSERT kilku studentów,
-- razem z ocenami, do tabeli. Odczytaj tabelę za pomocą polecenia SELECT.
-- Zmień listę ocen jednego ze studentów za pomocą polecenia UPDATE.


CREATE OR REPLACE TYPE OCENY IS VARRAY(30) OF INTEGER;
CREATE OR REPLACE TYPE STUDENTOBJ AS OBJECT
(
  indeks INTEGER,
  nazwisko VARCHAR2(30),
  ocenki OCENY
);
CREATE TABLE STUDENTTAB OF STUDENTOBJ;
INSERT INTO STUDENTTAB VALUES(NEW STUDENTOBJ(1, 'Pazera', oceny(5,4,3,2)));
INSERT INTO STUDENTTAB VALUES(NEW STUDENTOBJ(1, 'Peron', oceny(2,2,2,2)));
INSERT INTO STUDENTTAB VALUES(NEW STUDENTOBJ(1, 'Rybicki', oceny(3,2,3,2)));

SELECT * FROM STUDENTTAB;
UPDATE STUDENTTAB SET ocenki = oceny(3,3,3,3) WHERE nazwisko = 'Rybicki';

-- 10. Wykonaj kilka eksperymentów na zagnieżdżonych tabelach. Przykładowo:
-- stwórz typ kolekcji reprezentujący listę tytułów książek. Napisz program w
-- PL/SQL, który tworzy kolekcję, rozszerza kolekcję i wstawia kilka książek,
-- usuwa jakieś elementy ze środka oraz wyświetla wszystkie książki z
-- kolekcji na konsoli z wykorzystaniem pętli FOR i metod EXISTS, FIRST
-- i LAST oraz z pętli WHILE i metod FIRST i NEXT.
CREATE OR REPLACE TYPE tytulyksiazek AS TABLE OF CHARACTER VARYING (50);

DECLARE
  tytuly tytulyksiazek;
  total INTEGER;
  ostatni INTEGER;
BEGIN
  tytuly := tytulyksiazek('Powrot krola', 'Dwie wieze');
  total := tytuly.COUNT;
  DBMS_OUTPUT.put_line('Liczba ksiazek: ' || total);
  FOR i IN 1..total LOOP
    DBMS_OUTPUT.put_line('Tytul: ' || tytuly(i));
  END LOOP;

  tytuly.extend;
  ostatni := tytuly.LAST;
  tytuly(ostatni) := 'Druzyna pierscienia';

  total := tytuly.COUNT;
  DBMS_OUTPUT.put_line('Liczba ksiazek: ' || total);
  FOR i IN 1..total LOOP
    DBMS_OUTPUT.put_line('Tytul: ' || tytuly(i));
  END LOOP;

  tytuly.DELETE(2);
  total := tytuly.COUNT;
  DBMS_OUTPUT.put_line('Liczba ksiazek: ' || total);
END;

-- 11. Utwórz typ zagnieżdżonej tabeli przechowującej listę tytułów
-- wypożyczonych filmów. Utwórz typ obiektowy reprezentujący klienta
-- wypożyczalni o atrybutach: nazwisko (typu łańcuchowego) oraz filmy
-- (typu wcześniej zdefiniowanej kolekcji). Utwórz tabelę obiektową
-- KLIENCI przechowującą obiekty typu KLIENT. Wstaw przynajmniej
-- dwóch klientów z wypożyczonymi filmami. Wykorzystując operator
-- TABLE i polecenia INSERT, UPDATE i DELETE, wstaw, zmień i usuń
-- jakieś filmy z tabeli zagnieżdżonej skojarzonej z jednym z klientów.

CREATE OR REPLACE TYPE wypozyczonefilmy AS  TABLE OF VARCHAR2(30);
CREATE OR REPLACE TYPE klient AS OBJECT (
    nazw,
    filmy wypozyczonefilmy
                                        );

CREATE TABLE KLIENCI OF klient;
INSERT INTO KLIENCI VALUES ('paz',  NEW wypozyczonefilmy('test1, test2'))

CREATE OR REPLACE TYPE wypozyczonefilmy AS TABLE OF VARCHAR2(255);

CREATE OR REPLACE TYPE klient AS OBJECT (
    nazwisko VARCHAR2(30),
    filmy wypozyczonefilmy
);

CREATE TABLE klienci OF klient NESTED TABLE filmy STORE AS filmytable;

INSERT INTO klienci VALUES(NEW klient('Pazera', NEW wypozyczonefilmy('film 1', 'film 2')));
INSERT INTO klienci VALUES(NEW klient('Sekuła', NEW wypozyczonefilmy('film 3', 'film 4')));

SELECT VALUE(x) FROM TABLE(SELECT filmy FROM klienci WHERE nazwisko = 'Pazera') x;
INSERT INTO TABLE(SELECT filmy FROM klienci WHERE nazwisko = 'Pazera') VALUES('film 10');
UPDATE TABLE(SELECT filmy FROM klienci WHERE nazwisko = 'Pazera') x SET VALUE(x) = 'film 2' WHERE VALUE(x) = 'film2 ';
DELETE FROM TABLE(SELECT filmy FROM klienci WHERE nazwisko = 'Pazera') x WHERE VALUE(x) = 'film 1';

-- 12. Napisz zapytanie, które wypisze tabelę składającą się z dwóch kolumn:
-- nazwisko klienta i wypożyczony film. Wykorzystaj połączenie tabeli
-- obiektowej z zagnieżdżoną tabelą.
SELECT nazwisko, VALUE(x) FROM klienci CROSS JOIN TABLE(filmy) x;

-- KOLOKWIUM III GRUPA 1

-- 3. Zdefiniuj typ obiektowy reprezentujący SAMOCHODY. Każdy samochód powinien mieć markę, model, datę produkcji i
-- cenę. Stwórz tablicę obiektową i wprowadź dwa przykładowe obiekty. Wypisz zawartość tablicy w postaci obiektowej
-- i relacyjnej.

CREATE OR REPLACE TYPE samochod AS OBJECT(
    marka VARCHAR2(30),
    model_sam VARCHAR(30),
    rok_prod NUMBER(4,0),
    cena NUMBER(15,2)
);

CREATE TABLE samochody OF samochod;
INSERT INTO samochody VALUES(NEW samochod('Fiat', 'Punto', 1996, 3000.50));
INSERT INTO samochody VALUES(NEW samochod('Opel', 'Astra', 1997, 7000.50));

SELECT * FROM samochody;
SELECT VALUE(x) FROM samochody x;

-- 4. Utwórz tablicę WLASCICIELE zawierającą imiona i nazwiska właścicieli oraz atrybut obiektowy SAMOCHOD. Dodaj
-- funkcję obliczającą wiek samochodu oraz procedurę obniżającą cenę samochodu, która maleje z każdym rokiem o 10%.
-- Zaproponuj przykład wykorzystana metody constructor.
CREATE TABLE lasciciele (
    imie
    nazwisko
    sam samochod;
)

ALTER TYPE samochod REPLACE AS OBJECT (
    marka
    model
    rok
    cena
    MEMBER FUNCTION wiek RETURN NUMBER;
    MEMBER PROCEDURE nowacena''
    CONSTRUCTOR FUNCTION samochod(marka, model);
    )

CREATE OR REPLACE TYPE BODY samochod IS
    MEMBER FUNCTION nowacena RETURN NUMBER IS
        lata NUMBER;
        wynik NUMBER;
    BEGIN
        wynik:= cena;
        lata := EXTRACT(YEAR FROM CURRENT_TIMESTAMP) - EXTRACT(YEAR FROM data_wyd);
        FOR i IN 1..lata LOOP
            wynik := wynik * 0.9;
        END LOOP;
    END;
    MEMBER PROCEDURE wiek IS



CREATE TABLE wlasciciele (
    imie VARCHAR2(30),
    nazwisko VARCHAR2(30),
    sam samochod
);

ALTER TYPE samochod REPLACE AS OBJECT (
    marka VARCHAR2(30),
    model_sam VARCHAR(30),
    rok_prod NUMBER(4,0),
    cena NUMBER(15,2),
    MEMBER FUNCTION wiek RETURN NUMBER,
    MEMBER PROCEDURE obniz_cene,
    CONSTRUCTOR FUNCTION samochod(n_marka VARCHAR2(30), n_model_sam VARCHAR2(30)) RETURN self AS result
    );

CREATE OR REPLACE TYPE BODY samochod AS
    MEMBER FUNCTION wiek RETURN NUMBER IS
    BEGIN
        RETURN (EXTRACT(YEAR FROM SYSDATE) - rok_prod);
    END;
    MEMBER PROCEDURE obniz_cene IS
    lata NUMBER(4);
    BEGIN
        lata := wiek();
        FOR i IN 1..lata LOOP
            cena := cena * 0.9;
        END LOOP;
    END;
    CONSTRUCTOR FUNCTION samochod(n_marka VARCHAR2(30), n_model_sam VARCHAR2(30)) RETURN SELF AS RESULT IS
    BEGIN
        SELF.marka := n_marka;
        SELF.model_sam := n_model_sam;
        SELF.rok_prod := 1996;
        SELF.cena := 100000;
    END;
END;

-- 5. Zbuduj kolekcję (tablicę o zmiennym rozmiarze) przechowującą maksymalnie 10 różnych marek SAMOCHODÓW. Wstaw do
-- kolekcji przykładowe dane (6 marek). Wypisz zawartość kolekcji. Rozszerz kolekcję o dwa elementy, wypisz zawartość
-- kolekcji, usuń element z końca kolekcji.
CREATE OR REPLACE TYPE samochodyTab AS VARRAY(10) OF VARCHAR2(30);
DECLARE
    sam samochodyTab;
    LAST NUMBER;
BEGIN
    sam := samochodyTab('Fiat', 'Nissan', 'Opel', 'Mercedes', 'WV', 'Porsche');
    FOR x IN sam.FIRST()..sam.LAST() LOOP
        DBMS_OUTPUT.PUT_LINE(sam(x));
    END LOOP;
    LAST := sam.LAST();
    sam.extend(2);
    sam(LAST + 1) := 'Lamborghini';
    sam(LAST + 2) := 'xD';
    FOR x IN sam.FIRST()..sam.LAST() LOOP
        DBMS_OUTPUT.PUT_LINE(sam(x));
    END LOOP;
    sam.TRIM(1);
    FOR x IN sam.FIRST()..sam.LAST() LOOP
        DBMS_OUTPUT.PUT_LINE(sam(x));
    END LOOP;
END;

-- 6. Zbuduj kolekcję (tablicę zagnieżdzoną) przechowującą maksymalnie 10 różnych marek SAMOCHODÓW. Wstaw do kolekcji
-- przykładowe dane (6 marek). Wypisz zawartość kolekcji. Rozszerz kolekcję o dwa elementy, wypisz zawartość kolekcji,
-- usuń element ze środka kolekcji (3 i 4). Wypisz element 5 i 6.
CREATE OR REPLACE TYPE samochodyTab2 AS TABLE OF VARCHAR2(30);
DECLARE
    sam samochodyTab2;
    LAST NUMBER;
BEGIN
    sam := samochodyTab2('Fiat', 'Nissan', 'Opel', 'Mercedes', 'WV', 'Porsche');
    FOR x IN sam.FIRST()..sam.LAST() LOOP
        IF sam.EXISTS(x) THEN
            DBMS_OUTPUT.PUT_LINE(sam(x));
        END IF;
    END LOOP;
    DBMS_OUTPUT.PUT_LINE('********');
    LAST := sam.LAST();
    sam.extend(2);
    sam(LAST + 1) := 'Lamborghini';
    sam(LAST + 2) := 'xD';
    FOR x IN sam.FIRST()..sam.LAST() LOOP
        IF sam.EXISTS(x) THEN
            DBMS_OUTPUT.PUT_LINE(sam(x));
        END IF;
    END LOOP;
    DBMS_OUTPUT.PUT_LINE('********');
    sam.DELETE(3,4);
    FOR x IN sam.FIRST()..sam.LAST() LOOP
        IF sam.EXISTS(x) THEN
            DBMS_OUTPUT.PUT_LINE(sam(x));
        END IF;
    END LOOP;
    DBMS_OUTPUT.PUT_LINE('********');
    DBMS_OUTPUT.PUT_LINE(sam(5));
    DBMS_OUTPUT.PUT_LINE(sam(6));
END;

-- KOLOKWIUM III GRUPA II

-- 3. Zdefiniuj typ obiektowy reprezentujący STUDENTA. Każdy STUDENT powinien mieć nazwisko i imię, datę urodzenia oraz
-- nr indeksu. Utwórz tablicę obiektową i wprowadź dwa przykładowe obiekty. Wypisz zawartość tablicy w postaci
-- obiektowej i relacyjnej.
CREATE OR REPLACE TYPE studentObj AS OBJECT (
    imie VARCHAR2(30),
    nazwisko VARCHAR2(30),
    data_ur DATE,
    nr_indeksu NUMBER(6)
);

CREATE TABLE studenciTable OF studentObj;
INSERT INTO studenciTable VALUES(NEW studentObj('Tomasz', 'Pazera', DATE '1996-12-13', 121088));
INSERT INTO studenciTable VALUES(NEW studentObj('Zuzanna', 'Pazera', DATE '1996-12-13', 121089));

SELECT * FROM studenciTable;
SELECT VALUE(x) FROM studenciTable x;

-- 4. Utwórz tablicę ADRESY zawierającą adres zamieszkania studenta (miejscowość i ulica) a następnie powiąż te
-- obiekty za pomocą referencji. Wstaw obiekty do tabeli STUDENT oraz ADRESY. Wykonaj zapytania zwracające nazwisko
-- i adres studenta - wykorzystaj nawigację poprzez referencje.
CREATE OR REPLACE TYPE adresObj AS OBJECT
(
    miejscowosc VARCHAR2(30),
    ulica       VARCHAR2(50)
);

CREATE TABLE adresy OF adresObj;

INSERT INTO adresy VALUES(NEW adresObj('Kraków', 'Lea'));
INSERT INTO adresy VALUES(NEW adresObj('Kraków', 'Warszawska'));


CREATE OR REPLACE TYPE studentObj AS OBJECT (
    imie VARCHAR2(30),
    nazwisko VARCHAR2(30),
    data_ur DATE,
    nr_indeksu NUMBER(6),
    adres REF adresObj
    );

CREATE TABLE studenci OF STUDENTOBJ;

INSERT INTO studenci VALUES(NEW studentObj('Tomasz', 'Pazera', DATE '1996-12-13', 121088, (SELECT REF(a) FROM adresy a WHERE a.ulica = 'Lea' )));

SELECT nazwisko, DEREF(adres) FROM studenci;

-- 5. Zbuduj kolekcję (tablicę o zmiennym rozmiarze) przechowującą maksymalnie 10 różnych marek SAMOCHODÓW.
-- Wstaw do kolekcji przykładowe dane (6 marek). Wypisz zawartość kolekcji. Rozszerz kolekcję o dwa elementy,
-- wypisz zawartość kolekcji, usuń element z końca kolekcji.
-- JUŻ BYŁO

-- 6. Zbuduj kolekcję (tablicę zagnieżdzoną) przechowującą maksymalnie 5 różnych tytułów filmów. Wstaw do
-- kolekcji przykładowe dane (2 filmy). Wypisz zawartość kolekcji. Rozszerz kolekcję o dwa elementy, wypisz
-- zawartość kolekcji, usuń element ze środka kolekcji (2 i 3). Wypisz element 4 i 5.

-- SKORO ZAGNIEZDZONA TO CHYBA NIE MA MAKSYMALNEJ LICZBY ELEMENTOW !??!?!

CREATE OR REPLACE TYPE bazafilmow AS TABLE OF VARCHAR(255);

DECLARE
    baza bazafilmow;
    LAST NUMBER;
BEGIN
    baza := bazafilmow('Film 1', 'Film 2');
    FOR i IN baza.FIRST()..baza.LAST() LOOP
        IF baza.EXISTS(i) THEN
            DBMS_OUTPUT.PUT_LINE(baza(i));
        END IF;
    END LOOP;
    LAST := baza.LAST();
    baza.extend(2);
    baza(LAST + 1) := 'Film 3';
    baza(LAST + 2) := 'Film 4';
    FOR i IN baza.FIRST()..baza.LAST() LOOP
        IF baza.EXISTS(i) THEN
            DBMS_OUTPUT.PUT_LINE(baza(i));
        END IF;
    END LOOP;
    baza.DELETE(2,3);
    FOR i IN baza.FIRST()..baza.LAST() LOOP
        IF baza.EXISTS(i) THEN
            DBMS_OUTPUT.PUT_LINE(baza(i));
        END IF;
    END LOOP;
    DBMS_OUTPUT.PUT_LINE('********');
    IF baza.EXISTS(4) THEN
        DBMS_OUTPUT.PUT_LINE(baza(4));
    END IF;
    IF baza.EXISTS(5) THEN
        DBMS_OUTPUT.PUT_LINE(baza(5));
    END IF;
END;

-- KOLOKWIUM III GRUPA 3

-- 3. Zdefiniuj typ obiektowy reprezentujący TELEFON. Każdy telefon powinien mieć nazwę sieci, numer oraz
-- liczbę darmowych minut. Utwórz tablicę obiektową i wprowadź dwa przykładowe obiekty. Wypisz zawartość
-- tablicy w postaci obiektowej i relacyjnej.
CREATE OR REPLACE TYPE telefon AS OBJECT (
    siec VARCHAR2(30),
    nr NUMBER(9),
    darmowe_minuty NUMBER(20)
);

CREATE TABLE telefony OF telefon;

INSERT INTO telefony VALUES(NEW telefon('TMobile', 95929323, 200));
INSERT INTO telefony VALUES(NEW telefon('Orange', 929233123, 100));

SELECT * FROM telefony;
SELECT VALUE(x) FROM telefony x;

-- 4. Utwórz tablicę WLASCICIELE zawierającą imiona i nazwiska właścicieli telefonów oraz atrybut obiektowy
-- TELEFON. Dodaj funkcję przeliczającą minuty na sekundy oraz procedurę która będzie aktualizowała
-- liczbę darmowych minut (parametr procedury – wykorzystane minuty). Zaproponuj przykład wykorzystana
-- metody constructor.
CREATE TABLE wlasciciele (
    imie VARCHAR2(30),
    nazwisko VARCHAR2(30),
    tel telefon
);

ALTER TYPE telefon REPLACE AS OBJECT (
    siec VARCHAR2(30),
    nr NUMBER(9),
    darmowe_minuty NUMBER(20),
    MEMBER FUNCTION mintosek RETURN NUMBER,
    MEMBER PROCEDURE aktualizujdarmoweminuty(liczba NUMBER),
    CONSTRUCTOR FUNCTION telefon(nr2 NUMBER) RETURN SELF AS RESULT
    );

CREATE OR REPLACE TYPE BODY telefon AS
    MEMBER FUNCTION mintosek RETURN NUMBER IS
        BEGIN
            RETURN darmowe_minuty*60;
        END;
    MEMBER PROCEDURE aktualizujdarmoweminuty(liczba NUMBER) IS
        BEGIN
            darmowe_minuty := liczba;
        END;
    CONSTRUCTOR FUNCTION telefon(nr2 NUMBER) RETURN SELF AS RESULT IS
        BEGIN
            SELF.nr := nr2;
            SELF.siec := 'Orange';
            SELF.tel := 123123123;
        END;
END;


-- 5. Zbuduj kolekcję (tablicę o zmiennym rozmiarze) przechowującą ceny wybranego produktu. Wstaw do
-- kolekcji przykładowe dane (6 obiektów). Wypisz zawartość kolekcji. Rozszerz kolekcję o dwa elementy,
-- wypisz zawartość kolekcji, usuń element z końca kolekcji.
CREATE OR REPLACE TYPE produkt AS VARRAY(10) OF VARCHAR2(30);

DECLARE
    bazap produkt;
    LAST NUMBER;
BEGIN
    bazap := produkt('Mleko', 'Miod', 'Jajko', 'Smietana', 'Czeresnie', 'Jabłko');
    FOR i IN bazap.FIRST()..bazap.LAST() LOOP
        DBMS_OUTPUT.PUT_LINE(bazap(i));
    END LOOP;
    LAST := bazap.LAST();
    bazap.extend(2);
    bazap(LAST + 1) := 'Test';
    bazap(LAST + 2) := 'Test2';
    FOR i IN bazap.FIRST()..bazap.LAST() LOOP
        DBMS_OUTPUT.PUT_LINE(bazap(i));
    END LOOP;
    bazap.TRIM(1);
    FOR i IN bazap.FIRST()..bazap.LAST() LOOP
        DBMS_OUTPUT.PUT_LINE(bazap(i));
    END LOOP;
END;

-- 6. Zbuduj kolekcję (tablicę zagnieżdzoną) przechowującą ceny wybranego produktu. Wstaw do kolekcji przykładowe
-- dane (6 obiektów). Wypisz zawartość kolekcji. Rozszerz kolekcję o dwa elementy, wypisz zawartość kolekcji, usuń
-- element ze środka kolekcji (3 i 4). Wypisz element 5 i 6.
CREATE OR REPLACE TYPE produkty2 AS TABLE OF VARCHAR2(30);

DECLARE
    bazap produkty2;
    LAST NUMBER;
BEGIN
    bazap := produkty2('Mleko', 'Miod', 'Jajko', 'Smietana', 'Czeresnie', 'Jabłko');
    FOR i IN bazap.FIRST()..bazap.LAST() LOOP
        IF bazap.EXISTS(i) THEN
            DBMS_OUTPUT.PUT_LINE(bazap(i));
        END IF;
    END LOOP;
    LAST := bazap.LAST();
    bazap.extend(2);
    bazap(LAST + 1) := 'Test';
    bazap(LAST + 2) := 'Test2';
    FOR i IN bazap.FIRST()..bazap.LAST() LOOP
        IF bazap.EXISTS(i) THEN
            DBMS_OUTPUT.PUT_LINE(bazap(i));
        END IF;
    END LOOP;
    bazap.DELETE(3,4);
    FOR i IN bazap.FIRST()..bazap.LAST() LOOP
        IF bazap.EXISTS(i) THEN
            DBMS_OUTPUT.PUT_LINE(bazap(i));
        END IF;
    END LOOP;
    IF bazap.EXISTS(5) THEN
        DBMS_OUTPUT.PUT_LINE(bazap(5));
    END IF;
    IF bazap.EXISTS(6) THEN
        DBMS_OUTPUT.PUT_LINE(bazap(6));
    END IF;
END;

-- TEORIA
Kolekcje TO zbiory obiektów

Metody:
nazwa_kolekcji(wartosc, ...) - konstruktor kolekcji
extend(x) - rozszerza kolekcję o x pustych elementów
extend(x,i) - rozszerza kolekcje o x elementow o wartosci i-tego elementu
TRIM(x) - usuwa x elementow od konca kolekcji
DELETE(i) - usuwa i-ty element kolekcji
delte(i, i+3) - usuwa od i-tego DO i+3-ego elementy kolekcji
next(x) - zwraca indeks elementu następującego element o indeksie x
PRIOR(x) - TO samo tylko poprzedzającego
EXISTS(x) - sprawdza czy x element istnieje
FIRST - indeks pierwszego
LAST - indeks ostatniego
limit - MAX zakres kolekcji
COUNT - liczba elementow kolekcji


Porównaj typy kolekcji:
Wyróżniamy 2 typy kolekcji:
- tabelę o zmiennym rozmiarze
- tabelę zagnieżdżONą
W tabeli o zmiennym rozmiarze nie można manipulować pojedynczymi elementami w SQL oraz elementy zachowują
fizyczny porzadek. W varray podajemy maksymalną liczbę elementów.

W tabeli zagnieżdzonej mozna manipulowac pojedynczymi elementami w SQL oraz należy wskazać tabelę out-line DO
przechowywania kolekcji. Nie ma limitu liczby elementów tabeli. Można na przykład usunąć element ze środka tabeli.

Dostęp obiektowy DO obiektu krotkowego: SELECT VALUE(x) FROM TABLE x;
Dostep relacyjny DO obiektu krotkowego: SELECT * FROM TABLE;

Metody typu obiektowego:
- MEMBER - wywoływane na rzecz konkretnego obiektu
- STATIC - wywoływane na rzecz całego typu obiektowego
- MAP/ORDER - metody wykorzystywane DO porównywania obiektów
- CONSTRUCTOR - metody tworzace nowe obiekty

Metoda jest definiowana dwukrotnie:
- w deklaracji typu: sygnatura metody (nazwa i lista argumentów)
- w definicji typu (BODY): ciało metody (implementacja i kod źródłowy)

DROP TYPE nazwa_typu FORCE - usunięcie typu wraz z zależnościami

Perspektywy:
    USER_OBJECTS - informacje o typach obiektowych
    USER_METHOD_PARAMS, USER_METHOD_RESULTS, USER_TYPE_METHODS - informacje o metodach typów obiektowych

TOżsamość obiektu TO unikalny i niezmienny identyfikator związany z danym obiektem przez cały cykl jego życia/
TOżsamość posiadają tylko obiekty krotkowe, zapewniana jest przez OID.
Identyfikatory sa lokalne i globalnie unikalne, automatycznie indeksowane.
Aplikacja może wykorzystywac referencje DO identyfikatorów, odczytywane za pomocą REF()

Przykład funkcji odwzorowującej:
MAP MEMBER FUNCTION odwzoruj RETURN NUMBER IS
BEGIN
    RETURN wiek() + 3;
END;

Co TO konstruktor?
Metoda DO tworzenia typów obiektowych. Typ obiektowy dostarcza domyslny konstruktor.
Nazwa konstruktora jest taka sama jak nazwa typu obiektowego. Użytkownik może defniować własne konstruktory lub
przesłonić domyślny.
CONSTRUCTOR FUNCTION nazwa_typu (test VARCHAR2) RETURN SELF AS RESULT;

Referencje
typ obiektowy może posiadac referencje na istniejący obiekt innego typu obiektowego.
np. obiekt osoba i adres
kilka obiektów osoba może posiadać referencje na ten sam obiekt adres

Nawigacja jawna
SELECT o.pole1, DEREF(o.referencja) FROM tablica o;

Nawigacja niejawna
SELECT o.pole1, o.referencja.pole1 FROM tablica o;

SELECT nazwisko, VALUE(x) FROM klienci CROSS JOIN TABLE(filmy) x;

Ograniczenia integralnościowe
możliwe jest tylko dla tabel obiektowych (czyli CREATE TABLE tabela OF obiekt);
ALTER TABLE TABLE ADD PRIMARY KEY(pole1, pole2);
ALTER TABLE tabela ADD CONSTRAINT ograniczenie CHECK (liczba > 0);
ALTER TABLE tabela ADD CONSTRAINT ograniczenie2 liczba NOT NULL;