· 6 years ago · Jun 28, 2019, 09:06 AM
1-- 1. Zdefiniuj typ obiektowy reprezentujący KSIAZKE. Każda książka
2-- powinien mieć autora, tytuł, liczbę stron oraz datę wydania i cenę, liczbę
3-- wypożyczeń. Utwórz tablicę obiektową i KSIAZKI przechowują obiekty
4-- tego typu. Wprowadź kilka przykładowych obiektów, obejrzyj zawartość
5-- tabeli w postaci obiektowej i w postaci relacyjnej
6CREATE OR REPLACE TYPE ksiazka AS OBJECT
7(
8 autor VARCHAR2(30),
9 tytul VARCHAR2(30),
10 lstron NUMBER(10),
11 data_wydania DATE,
12 cena FLOAT
13);
14
15CREATE TABLE ksiazki OF ksiazka;
16INSERT INTO ksiazki VALUES (NEW ksiazka('Tolkien', 'Wladca Pierscieni Dwie wieze', 500, DATE '1970-01-01', 500));
17INSERT INTO ksiazki VALUES (NEW ksiazka('Tolkien', 'Wladca Pierscieni Powrot krola', 500, DATE '1971-01-01', 600));
18SELECT VALUE(k) FROM ksiazki k;
19SELECT * FROM ksiazki;
20
21
22-- 2. Utwórz tabelę BIBLIOTEKI zawierającą nazwę biblioteki, adres oraz
23-- atrybut obiektowy KSIAZKA. Wprowadź do tabeli przykładowe dane
24-- i wyświetl jej zawartość.
25CREATE TABLE biblioteki (
26 nazwa VARCHAR2(30),
27 adres VARCHAR2(50),
28 ksiazka ksiazka
29);
30INSERT INTO biblioteki VALUES ('Jakas tam nazwa', 'Lea 240', new ksiazka('Tolkien', 'Wladca Pierscieni Powrot krola', 500, DATE '1971-01-01', 600));
31INSERT INTO biblioteki VALUES ('Jakas tam nazwa 2', 'Lea 236', new ksiazka('Tolkien', 'Wladca Pierscieni Powrot krola', 500, DATE '1971-01-01', 600));
32SELECT nazwa, adres FROM biblioteki;
33SELECT b.nazwa, b.ksiazka.tytul FROM biblioteki b;
34
35-- 3. Wartość książki maleje o 5% z każdym rokiem. Dodaj do typu obiektowego
36-- KSIAZKA metodę wyliczającą na podstawie daty wydania
37-- i ceny aktualną wartość książki (wykorzystaj polecenie ALTER i
38-- zaimplementuj ciało). Wykonaj zapytanie do tabeli, które aktywuje tę
39-- metodę.
40ALTER TYPE ksiazka REPLACE AS OBJECT
41(
42 autor VARCHAR2(30),
43 tytul VARCHAR2(30),
44 lstron NUMBER(10),
45 data_wydania DATE,
46 cena FLOAT,
47 MEMBER FUNCTION cenaksiazki RETURN NUMBER
48);
49
50CREATE OR REPLACE TYPE BODY ksiazka IS
51 MEMBER FUNCTION cenaksiazki RETURN NUMBER IS
52 lata NUMBER(2);
53 wynik NUMBER(10,2) := 0;
54 BEGIN
55 lata := EXTRACT(YEAR FROM CURRENT_TIMESTAMP) - EXTRACT(YEAR FROM data_wydania);
56 wynik := cena;
57 FOR i IN 0..lata LOOP
58 wynik := wynik * 0.95;
59 end loop;
60 return wynik;
61 end cenaksiazki;
62END;
63
64SELECT p.tytul, p.cenaksiazki() FROM ksiazki p;
65
66-- 4. Dodaj do typu KSIAZKA metodę odwzorowującą, która pozwoli na
67-- porównywanie książek na podstawie lat od daty ich wydania raz
68-- zniszczenia (decyduje ilość wypożyczeń). Przyjmujemy, że 10
69-- wypożyczeń to jeden rok jeśli chodzi o lata, które upłynęły od daty wydania
70-- książki.
71ALTER TYPE ksiazka ADD MAP MEMBER FUNCTION odwzoruj RETURN NUMBER CASCADE INCLUDING TABLE DATA;
72
73CREATE OR REPLACE TYPE BODY ksiazka IS
74 MEMBER FUNCTION cenaksiazki RETURN NUMBER IS
75 lata NUMBER(2);
76 wynik NUMBER(10,2) := 0;
77 BEGIN
78 lata := EXTRACT(YEAR FROM CURRENT_TIMESTAMP) - EXTRACT(YEAR FROM data_wydania);
79 wynik := cena;
80 FOR i IN 0..lata LOOP
81 wynik := wynik * 0.95;
82 end loop;
83 return wynik;
84 end cenaksiazki;
85 MAP MEMBER FUNCTION odwzoruj RETURN NUMBER IS
86 liczbalat NUMBER(10);
87 BEGIN
88 return (EXTRACT(YEAR FROM CURRENT_TIMESTAMP) - EXTRACT(YEAR FROM data_wydania))*10;
89 END;
90END;
91
92SELECT p.tytul, p.cenaksiazki(), p.odwzoruj() FROm ksiazki p;
93
94
95-- 5. Utwórz typ CZYTELNIK zawierający nazwisko i imię czytelnika. Dodaj
96-- do typu KSIAZKA referencje do CZYTELNIKA. Utwórz tabelę obiektową
97-- CZYTELNICY i wypełnij obie tabele danymi.
98DROP TYPE czytelnik FORCE;
99CREATE OR REPLACE TYPE czytelnik AS OBJECT
100(
101 imie VARCHAR2(20),
102 nazwisko VARCHAR2(20)
103);
104
105DROP TYPE ksiazka FORCE;
106
107CREATE OR REPLACE TYPE ksiazka AS OBJECT
108(
109 autor VARCHAR2(30),
110 tytul VARCHAR2(30),
111 lstron NUMBER(10),
112 data_wydania DATE,
113 cena FLOAT,
114 czyt REF CZYTELNIK,
115 MEMBER FUNCTION cenaksiazki RETURN NUMBER,
116 MAP MEMBER FUNCTION odwzoruj RETURN NUMBER
117);
118
119DROP TABLE czytelnicy;
120CREATE TABLE czytelnicy OF czytelnik;
121INSERT INTO czytelnicy VALUES(new czytelnik('Tomek', 'Pazera'));
122INSERT INTO czytelnicy VALUES(new czytelnik('Zuza', 'Pazera'));
123INSERT INTO czytelnicy VALUES(new czytelnik('Paulina', 'Pazera'));
124
125SELECT r.imie FROM czytelnicy r;
126
127DROP TABLE ksiazki;
128CREATE TABLE ksiazki OF ksiazka;
129INSERT 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')));
130INSERT 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')));
131
132SELECT r.czyt.imie FROM ksiazki r;
133
134-- 6. Wypisz autora i tytuł książki oraz nazwiska i imiona czytelników
135-- korzystając z nawigacji poprzez referencję.
136select o.autor, o.tytul, o.czyt.imie, o.czyt.nazwisko from ksiazki o;
137select o.autor, o.tytul, deref(o.czyt) from ksiazki o;
138
139
140-- 7. Usuń z tabeli CZYTELNICY jeden obiekt. Wyszukaj w tabeli KSIAZKI ,
141-- te książki, które nie mają przypisanego czytelnika (wiszące referencje) i
142-- przypisz tym referencjom NULL. Wykorzystaj pojedyncze polecenie
143-- DELETE i UPDATE.
144SELECT * FROM czytelnicy;
145DELETE FROM czytelnicy WHERE imie = 'Zuza';
146SELECT * FROM ksiazki k WHERE czyt is NULL;
147UPDATE ksiazki SET czyt = null WHERE czyt is dangling;
148
149-- 8. Wykonaj kilka eksperymentów na tablicach o zmiennym rozmiarze.
150-- Przykładowo: stwórz typ kolekcji zawierający informacje o przedmiotach
151-- nauczanych na studiach (łańcuchy znaków). Napisz program w PL/SQL,
152-- który tworzy kolekcję, wstawia do kolekcji przykładowe przedmioty,
153-- rozszerza kolekcję, wyświetla zawartość kolekcji, usuwa elementy z końca
154-- kolekcji, wyświetla informacje o długości kolekcji i o limicie na liczbę
155-- elementów.
156DROP TYPE przedmiot FORCE;
157
158CREATE OR REPLACE TYPE przedm AS OBJECT
159(
160 nazwa VARCHAR2(30)
161);
162
163CREATE OR REPLACE TYPE tab_przedmioty IS VARRAY(5) of przedm;
164
165SET SERVEROUTPUT ON;
166
167DECLARE
168 names tab_przedmioty;
169 total integer;
170 ostatni integer;
171BEGIN
172 names := tab_przedmioty(new przedm('Matematyka'), new przedm('Polski'));
173 total := names.count;
174 dbms_output.put_line('Liczba przedmiotow: '|| total);
175 FOR i in 1 .. total LOOP
176 dbms_output.put_line('Przedmiot: ' || names(i).nazwa);
177 NULL;
178 END LOOP;
179
180 names.extend;
181 dbms_output.put_line('Ostatni: ' || names.last);
182 dbms_output.put_line('Usuwamy ostatni rekord');
183 names.trim;
184 dbms_output.put_line('Dodajemy nowy rekord');
185 names.extend;
186 ostatni := names.last;
187 names(ostatni) := new przedm('Angielski');
188 total := names.count;
189 dbms_output.put_line('Liczba przedmiotow: '|| total);
190 FOR i in 1 .. total LOOP
191 dbms_output.put_line('Przedmiot: ' || names(i).nazwa);
192 NULL;
193 END LOOP;
194
195 dbms_output.put_line('Limit: '|| names.limit);
196
197END;
198
199-- 9. Utwórz typ tablicy o zmiennym rozmiarze przechowujący maksymalnie 30
200-- liczb, który będzie reprezentował listę ocen studenta. Utwórz typ
201-- obiektowy Student, który posiada atrybuty: indeks (typ liczbowy),
202-- nazwisko (typ łańcuchowy) oraz oceny (typu wcześniej zdefiniowanej
203-- kolekcji). Utwórz tabelę obiektową STUDENCI przechowującą obiekty
204-- typu STUDENT. Wstaw za pomocą polecenia INSERT kilku studentów,
205-- razem z ocenami, do tabeli. Odczytaj tabelę za pomocą polecenia SELECT.
206-- Zmień listę ocen jednego ze studentów za pomocą polecenia UPDATE.
207
208
209CREATE OR REPLACE TYPE OCENY IS VARRAY(30) OF INTEGER;
210CREATE OR REPLACE TYPE STUDENTOBJ AS OBJECT
211(
212 indeks INTEGER,
213 nazwisko VARCHAR2(30),
214 ocenki OCENY
215);
216CREATE TABLE STUDENTTAB OF STUDENTOBJ;
217INSERT INTO STUDENTTAB VALUES(new STUDENTOBJ(1, 'Pazera', oceny(5,4,3,2)));
218INSERT INTO STUDENTTAB VALUES(new STUDENTOBJ(1, 'Peron', oceny(2,2,2,2)));
219INSERT INTO STUDENTTAB VALUES(new STUDENTOBJ(1, 'Rybicki', oceny(3,2,3,2)));
220
221SELECT * FROM STUDENTTAB;
222UPDATE STUDENTTAB SET ocenki = oceny(3,3,3,3) WHERE nazwisko = 'Rybicki';
223
224-- 10. Wykonaj kilka eksperymentów na zagnieżdżonych tabelach. Przykładowo:
225-- stwórz typ kolekcji reprezentujący listę tytułów książek. Napisz program w
226-- PL/SQL, który tworzy kolekcję, rozszerza kolekcję i wstawia kilka książek,
227-- usuwa jakieś elementy ze środka oraz wyświetla wszystkie książki z
228-- kolekcji na konsoli z wykorzystaniem pętli FOR i metod EXISTS, FIRST
229-- i LAST oraz z pętli WHILE i metod FIRST i NEXT.
230CREATE OR REPLACE TYPE tytulyksiazek AS TABLE OF CHARACTER VARYING (50);
231
232DECLARE
233 tytuly tytulyksiazek;
234 total INTEGER;
235 ostatni INTEGER;
236BEGIN
237 tytuly := tytulyksiazek('Powrot krola', 'Dwie wieze');
238 total := tytuly.count;
239 dbms_output.put_line('Liczba ksiazek: ' || total);
240 FOR i IN 1..total LOOP
241 dbms_output.put_line('Tytul: ' || tytuly(i));
242 END LOOP;
243
244 tytuly.extend;
245 ostatni := tytuly.last;
246 tytuly(ostatni) := 'Druzyna pierscienia';
247
248 total := tytuly.count;
249 dbms_output.put_line('Liczba ksiazek: ' || total);
250 FOR i IN 1..total LOOP
251 dbms_output.put_line('Tytul: ' || tytuly(i));
252 END LOOP;
253
254 tytuly.delete(2);
255 total := tytuly.count;
256 dbms_output.put_line('Liczba ksiazek: ' || total);
257END;
258
259-- 11. Utwórz typ zagnieżdżonej tabeli przechowującej listę tytułów
260-- wypożyczonych filmów. Utwórz typ obiektowy reprezentujący klienta
261-- wypożyczalni o atrybutach: nazwisko (typu łańcuchowego) oraz filmy
262-- (typu wcześniej zdefiniowanej kolekcji). Utwórz tabelę obiektową
263-- KLIENCI przechowującą obiekty typu KLIENT. Wstaw przynajmniej
264-- dwóch klientów z wypożyczonymi filmami. Wykorzystując operator
265-- TABLE i polecenia INSERT, UPDATE i DELETE, wstaw, zmień i usuń
266-- jakieś filmy z tabeli zagnieżdżonej skojarzonej z jednym z klientów.
267CREATE OR REPLACE TYPE wypozyczonefilmy AS TABLE OF VARCHAR2(255);
268
269CREATE OR REPLACE TYPE klient AS OBJECT (
270 nazwisko VARCHAR2(30),
271 filmy wypozyczonefilmy
272);
273
274CREATE TABLE klienci OF klient NESTED TABLE filmy STORE AS filmytable;
275
276INSERT INTO klienci VALUES(new klient('Pazera', new wypozyczonefilmy('film 1', 'film 2')));
277INSERT INTO klienci VALUES(new klient('Sekuła', new wypozyczonefilmy('film 3', 'film 4')));
278
279SELECT VALUE(x) FROM TABLE(SELECT filmy FROM klienci WHERE nazwisko = 'Pazera') x;
280INSERT INTO TABLE(SELECT filmy FROM klienci WHERE nazwisko = 'Pazera') VALUES('film 10');
281UPDATE TABLE(SELECT filmy FROM klienci WHERE nazwisko = 'Pazera') x SET VALUE(x) = 'film 2' WHERE VALUE(x) = 'film2 ';
282DELETE FROM TABLE(SELECT filmy FROM klienci WHERE nazwisko = 'Pazera') x WHERE VALUE(x) = 'film 1';
283
284-- 12. Napisz zapytanie, które wypisze tabelę składającą się z dwóch kolumn:
285-- nazwisko klienta i wypożyczony film. Wykorzystaj połączenie tabeli
286-- obiektowej z zagnieżdżoną tabelą.
287SELECT nazwisko, value(x) FROM klienci CROSS JOIN TABLE(filmy) x;
288
289-- KOLOKWIUM III GRUPA 1
290
291-- 3. Zdefiniuj typ obiektowy reprezentujący SAMOCHODY. Każdy samochód powinien mieć markę, model, datę produkcji i
292-- cenę. Stwórz tablicę obiektową i wprowadź dwa przykładowe obiekty. Wypisz zawartość tablicy w postaci obiektowej
293-- i relacyjnej.
294CREATE OR REPLACE TYPE samochod AS OBJECT(
295 marka VARCHAR2(30),
296 model_sam VARCHAR(30),
297 rok_prod NUMBER(4,0),
298 cena NUMBER(15,2)
299);
300
301CREATE TABLE samochody of samochod;
302INSERT INTO samochody VALUES(new samochod('Fiat', 'Punto', 1996, 3000.50));
303INSERT INTO samochody VALUES(new samochod('Opel', 'Astra', 1997, 7000.50));
304
305SELECT * FROM samochody;
306SELECT VALUE(x) FROM samochody x;
307
308-- 4. Utwórz tablicę WLASCICIELE zawierającą imiona i nazwiska właścicieli oraz atrybut obiektowy SAMOCHOD. Dodaj
309-- funkcję obliczającą wiek samochodu oraz procedurę obniżającą cenę samochodu, która maleje z każdym rokiem o 10%.
310-- Zaproponuj przykład wykorzystana metody constructor.
311CREATE TABLE wlasciciele (
312 imie VARCHAR2(30),
313 nazwisko VARCHAR2(30),
314 sam samochod
315);
316
317ALTER TYPE samochod REPLACE AS OBJECT (
318 marka VARCHAR2(30),
319 model_sam VARCHAR(30),
320 rok_prod NUMBER(4,0),
321 cena NUMBER(15,2),
322 MEMBER FUNCTION wiek RETURN NUMBER,
323 MEMBER PROCEDURE obniz_cene,
324 CONSTRUCTOR FUNCTION samochod(n_marka VARCHAR2(30), n_model_sam VARCHAR2(30)) return self as result
325 );
326
327CREATE OR REPLACE TYPE BODY samochod AS
328 MEMBER FUNCTION wiek RETURN NUMBER IS
329 BEGIN
330 return (EXTRACT(YEAR FROM sysdate) - rok_prod);
331 END;
332 MEMBER PROCEDURE obniz_cene IS
333 lata NUMBER(4);
334 BEGIN
335 lata := wiek();
336 FOR i IN 1..lata LOOP
337 cena := cena * 0.9;
338 end loop;
339 END;
340 CONSTRUCTOR FUNCTION samochod(n_marka VARCHAR2(30), n_model_sam VARCHAR2(30)) RETURN SELF AS RESULT IS
341 BEGIN
342 SELF.marka := n_marka;
343 SELF.model_sam := n_model_sam;
344 SELF.rok_prod := 1996;
345 SELF.cena := 100000;
346 END;
347end;
348
349-- 5. Zbuduj kolekcję (tablicę o zmiennym rozmiarze) przechowującą maksymalnie 10 różnych marek SAMOCHODÓW. Wstaw do
350-- kolekcji przykładowe dane (6 marek). Wypisz zawartość kolekcji. Rozszerz kolekcję o dwa elementy, wypisz zawartość
351-- kolekcji, usuń element z końca kolekcji.
352CREATE OR REPLACE TYPE samochodyTab AS VARRAY(10) OF VARCHAR2(30);
353DECLARE
354 sam samochodyTab;
355 last NUMBER;
356BEGIN
357 sam := samochodyTab('Fiat', 'Nissan', 'Opel', 'Mercedes', 'WV', 'Porsche');
358 FOR x IN sam.first()..sam.last() LOOP
359 DBMS_OUTPUT.PUT_LINE(sam(x));
360 end loop;
361 last := sam.last();
362 sam.extend(2);
363 sam(last + 1) := 'Lamborghini';
364 sam(last + 2) := 'xD';
365 FOR x IN sam.first()..sam.last() LOOP
366 DBMS_OUTPUT.PUT_LINE(sam(x));
367 end loop;
368 sam.trim(1);
369 FOR x IN sam.first()..sam.last() LOOP
370 DBMS_OUTPUT.PUT_LINE(sam(x));
371 end loop;
372end;
373
374-- 6. Zbuduj kolekcję (tablicę zagnieżdzoną) przechowującą maksymalnie 10 różnych marek SAMOCHODÓW. Wstaw do kolekcji
375-- przykładowe dane (6 marek). Wypisz zawartość kolekcji. Rozszerz kolekcję o dwa elementy, wypisz zawartość kolekcji,
376-- usuń element ze środka kolekcji (3 i 4). Wypisz element 5 i 6.
377CREATE OR REPLACE TYPE samochodyTab2 AS TABLE OF VARCHAR2(30);
378DECLARE
379 sam samochodyTab2;
380 last NUMBER;
381BEGIN
382 sam := samochodyTab2('Fiat', 'Nissan', 'Opel', 'Mercedes', 'WV', 'Porsche');
383 FOR x IN sam.first()..sam.last() LOOP
384 IF sam.exists(x) THEN
385 DBMS_OUTPUT.PUT_LINE(sam(x));
386 end if;
387 end loop;
388 DBMS_OUTPUT.PUT_LINE('********');
389 last := sam.last();
390 sam.extend(2);
391 sam(last + 1) := 'Lamborghini';
392 sam(last + 2) := 'xD';
393 FOR x IN sam.first()..sam.last() LOOP
394 IF sam.exists(x) THEN
395 DBMS_OUTPUT.PUT_LINE(sam(x));
396 END IF;
397 end loop;
398 DBMS_OUTPUT.PUT_LINE('********');
399 sam.delete(3,4);
400 FOR x IN sam.first()..sam.last() LOOP
401 IF sam.exists(x) THEN
402 DBMS_OUTPUT.PUT_LINE(sam(x));
403 END IF;
404 end loop;
405 DBMS_OUTPUT.PUT_LINE('********');
406 DBMS_OUTPUT.PUT_LINE(sam(5));
407 DBMS_OUTPUT.PUT_LINE(sam(6));
408end;
409
410-- KOLOKWIUM III GRUPA II
411
412-- 3. Zdefiniuj typ obiektowy reprezentujący STUDENTA. Każdy STUDENT powinien mieć nazwisko i imię, datę urodzenia oraz
413-- nr indeksu. Utwórz tablicę obiektową i wprowadź dwa przykładowe obiekty. Wypisz zawartość tablicy w postaci
414-- obiektowej i relacyjnej.
415CREATE OR REPLACE TYPE studentObj AS OBJECT (
416 imie VARCHAR2(30),
417 nazwisko VARCHAR2(30),
418 data_ur DATE,
419 nr_indeksu NUMBER(6)
420);
421
422CREATE TABLE studenciTable OF studentObj;
423INSERT INTO studenciTable VALUES(new studentObj('Tomasz', 'Pazera', DATE '1996-12-13', 121088));
424INSERT INTO studenciTable VALUES(new studentObj('Zuzanna', 'Pazera', DATE '1996-12-13', 121089));
425
426SELECT * FROM studenciTable;
427SELECT value(x) FROM studenciTable x;
428
429-- 4. Utwórz tablicę ADRESY zawierającą adres zamieszkania studenta (miejscowość i ulica) a następnie powiąż te
430-- obiekty za pomocą referencji. Wstaw obiekty do tabeli STUDENT oraz ADRESY. Wykonaj zapytania zwracające nazwisko
431-- i adres studenta - wykorzystaj nawigację poprzez referencje.
432CREATE OR REPLACE TYPE adresObj AS OBJECT
433(
434 miejscowosc VARCHAR2(30),
435 ulica VARCHAR2(50)
436);
437
438CREATE TABLE adresy OF adresObj;
439
440INSERT INTO adresy VALUES(new adresObj('Kraków', 'Lea'));
441INSERT INTO adresy VALUES(new adresObj('Kraków', 'Warszawska'));
442
443
444CREATE OR REPLACE TYPE studentObj AS OBJECT (
445 imie VARCHAR2(30),
446 nazwisko VARCHAR2(30),
447 data_ur DATE,
448 nr_indeksu NUMBER(6),
449 adres REF adresObj
450 );
451
452CREATE TABLE studenci OF STUDENTOBJ;
453
454INSERT INTO studenci VALUES(new studentObj('Tomasz', 'Pazera', DATE '1996-12-13', 121088, (SELECT ref(a) FROM adresy a WHERE a.ulica = 'Lea' )));
455
456SELECT nazwisko, deref(adres) FROM studenci;
457
458-- 5. Zbuduj kolekcję (tablicę o zmiennym rozmiarze) przechowującą maksymalnie 10 różnych marek SAMOCHODÓW.
459-- Wstaw do kolekcji przykładowe dane (6 marek). Wypisz zawartość kolekcji. Rozszerz kolekcję o dwa elementy,
460-- wypisz zawartość kolekcji, usuń element z końca kolekcji.
461-- JUŻ BYŁO
462
463-- 6. Zbuduj kolekcję (tablicę zagnieżdzoną) przechowującą maksymalnie 5 różnych tytułów filmów. Wstaw do
464-- kolekcji przykładowe dane (2 filmy). Wypisz zawartość kolekcji. Rozszerz kolekcję o dwa elementy, wypisz
465-- zawartość kolekcji, usuń element ze środka kolekcji (2 i 3). Wypisz element 4 i 5.
466
467-- SKORO ZAGNIEZDZONA TO CHYBA NIE MA MAKSYMALNEJ LICZBY ELEMENTOW !??!?!
468
469CREATE OR REPLACE TYPE bazafilmow AS TABLE OF VARCHAR(255);
470
471DECLARE
472 baza bazafilmow;
473 last NUMBER;
474BEGIN
475 baza := bazafilmow('Film 1', 'Film 2');
476 FOR i IN baza.first()..baza.last() LOOP
477 IF baza.exists(i) THEN
478 DBMS_OUTPUT.PUT_LINE(baza(i));
479 end if;
480 end loop;
481 last := baza.last();
482 baza.extend(2);
483 baza(last + 1) := 'Film 3';
484 baza(last + 2) := 'Film 4';
485 FOR i In baza.first()..baza.last() LOOP
486 IF baza.exists(i) THEN
487 DBMS_OUTPUT.PUT_LINE(baza(i));
488 end if;
489 end loop;
490 baza.delete(2,3);
491 FOR i In baza.first()..baza.last() LOOP
492 IF baza.exists(i) THEN
493 DBMS_OUTPUT.PUT_LINE(baza(i));
494 end if;
495 end loop;
496 DBMS_OUTPUT.PUT_LINE('********');
497 IF baza.exists(4) THEN
498 DBMS_OUTPUT.PUT_LINE(baza(4));
499 end if;
500 IF baza.exists(5) THEN
501 DBMS_OUTPUT.PUT_LINE(baza(5));
502 end if;
503end;
504
505-- KOLOKWIUM III GRUPA 3
506
507-- 3. Zdefiniuj typ obiektowy reprezentujący TELEFON. Każdy telefon powinien mieć nazwę sieci, numer oraz
508-- liczbę darmowych minut. Utwórz tablicę obiektową i wprowadź dwa przykładowe obiekty. Wypisz zawartość
509-- tablicy w postaci obiektowej i relacyjnej.
510CREATE OR REPLACE TYPE telefon AS OBJECT (
511 siec VARCHAR2(30),
512 nr NUMBER(9),
513 darmowe_minuty NUMBER(20)
514);
515
516CREATE TABLE telefony OF telefon;
517
518INSERT INTO telefony VALUES(new telefon('TMobile', 95929323, 200));
519INSERT INTO telefony VALUES(new telefon('Orange', 929233123, 100));
520
521SELECT * FROM telefony;
522SELECT VALUE(x) FROM telefony x;
523
524-- 4. Utwórz tablicę WLASCICIELE zawierającą imiona i nazwiska właścicieli telefonów oraz atrybut obiektowy
525-- TELEFON. Dodaj funkcję przeliczającą minuty na sekundy oraz procedurę która będzie aktualizowała
526-- liczbę darmowych minut (parametr procedury – wykorzystane minuty). Zaproponuj przykład wykorzystana
527-- metody constructor.
528CREATE TABLE wlasciciele (
529 imie VARCHAR2(30),
530 nazwisko VARCHAR2(30),
531 tel telefon
532);
533
534ALTER TYPE telefon REPLACE AS OBJECT (
535 siec VARCHAR2(30),
536 nr NUMBER(9),
537 darmowe_minuty NUMBER(20),
538 MEMBER FUNCTION mintosek RETURN NUMBER,
539 MEMBER PROCEDURE aktualizujdarmoweminuty(liczba NUMBER),
540 CONSTRUCTOR FUNCTION telefon(nr2 NUMBER) RETURN SELF AS RESULT
541 );
542
543CREATE OR REPLACE TYPE BODY telefon AS
544 MEMBER FUNCTION mintosek RETURN NUMBER IS
545 BEGIN
546 return darmowe_minuty*60;
547 end;
548 MEMBER PROCEDURE aktualizujdarmoweminuty(liczba NUMBER) IS
549 BEGIN
550 darmowe_minuty := liczba;
551 end;
552 CONSTRUCTOR FUNCTION telefon(nr2 NUMBER) RETURN SELF AS RESULT IS
553 BEGIN
554 SELF.nr := nr2;
555 SELF.siec := 'Orange';
556 SELF.tel := 123123123;
557 END;
558END;
559
560
561-- 5. Zbuduj kolekcję (tablicę o zmiennym rozmiarze) przechowującą ceny wybranego produktu. Wstaw do
562-- kolekcji przykładowe dane (6 obiektów). Wypisz zawartość kolekcji. Rozszerz kolekcję o dwa elementy,
563-- wypisz zawartość kolekcji, usuń element z końca kolekcji.
564CREATE OR REPLACE TYPE produkt AS VARRAY(10) OF VARCHAR2(30);
565
566DECLARE
567 bazap produkt;
568 last NUMBER;
569BEGIN
570 bazap := produkt('Mleko', 'Miod', 'Jajko', 'Smietana', 'Czeresnie', 'Jabłko');
571 FOR i IN bazap.first()..bazap.last() LOOP
572 DBMS_OUTPUT.PUT_LINE(bazap(i));
573 end loop;
574 last := bazap.last();
575 bazap.extend(2);
576 bazap(last + 1) := 'Test';
577 bazap(last + 2) := 'Test2';
578 FOR i IN bazap.first()..bazap.last() LOOP
579 DBMS_OUTPUT.PUT_LINE(bazap(i));
580 end loop;
581 bazap.trim(1);
582 FOR i IN bazap.first()..bazap.last() LOOP
583 DBMS_OUTPUT.PUT_LINE(bazap(i));
584 end loop;
585end;
586
587-- 6. Zbuduj kolekcję (tablicę zagnieżdzoną) przechowującą ceny wybranego produktu. Wstaw do kolekcji przykładowe
588-- dane (6 obiektów). Wypisz zawartość kolekcji. Rozszerz kolekcję o dwa elementy, wypisz zawartość kolekcji, usuń
589-- element ze środka kolekcji (3 i 4). Wypisz element 5 i 6.
590CREATE OR REPLACE TYPE produkty2 AS TABLE OF VARCHAR2(30);
591
592DECLARE
593 bazap produkty2;
594 last NUMBER;
595BEGIN
596 bazap := produkty2('Mleko', 'Miod', 'Jajko', 'Smietana', 'Czeresnie', 'Jabłko');
597 FOR i IN bazap.first()..bazap.last() LOOP
598 IF bazap.exists(i) THEN
599 DBMS_OUTPUT.PUT_LINE(bazap(i));
600 end if;
601 end loop;
602 last := bazap.last();
603 bazap.extend(2);
604 bazap(last + 1) := 'Test';
605 bazap(last + 2) := 'Test2';
606 FOR i IN bazap.first()..bazap.last() LOOP
607 IF bazap.exists(i) THEN
608 DBMS_OUTPUT.PUT_LINE(bazap(i));
609 end if;
610 end loop;
611 bazap.delete(3,4);
612 FOR i IN bazap.first()..bazap.last() LOOP
613 IF bazap.exists(i) THEN
614 DBMS_OUTPUT.PUT_LINE(bazap(i));
615 end if;
616 end loop;
617 IF bazap.exists(5) THEN
618 DBMS_OUTPUT.PUT_LINE(bazap(5));
619 end if;
620 IF bazap.exists(6) THEN
621 DBMS_OUTPUT.PUT_LINE(bazap(6));
622 end if;
623end;
624
625-- TEORIA
626Kolekcje to zbiory obiektów
627
628Metody:
629nazwa_kolekcji(wartosc, ...) - konstruktor kolekcji
630extend(x) - rozszerza kolekcję o x pustych elementów
631extend(x,i) - rozszerza kolekcje o x elementow o wartosci i-tego elementu
632trim(x) - usuwa x elementow od konca kolekcji
633delete(i) - usuwa i-ty element kolekcji
634delte(i, i+3) - usuwa od i-tego do i+3-ego elementy kolekcji
635next(x) - zwraca indeks elementu następującego element o indeksie x
636prior(x) - to samo tylko poprzedzającego
637exists(x) - sprawdza czy x element istnieje
638first - indeks pierwszego
639last - indeks ostatniego
640limit - max zakres kolekcji
641count - liczba elementow kolekcji
642
643
644Porównaj typy kolekcji:
645Wyróżniamy 2 typy kolekcji:
646- tabelę o zmiennym rozmiarze
647- tabelę zagnieżdżoną
648W tabeli o zmiennym rozmiarze nie można manipulować pojedynczymi elementami w SQL oraz elementy zachowują
649fizyczny porzadek. W varray podajemy maksymalną liczbę elementów.
650
651W tabeli zagnieżdzonej mozna manipulowac pojedynczymi elementami w SQL oraz należy wskazać tabelę out-line do
652przechowywania kolekcji. Nie ma limitu liczby elementów tabeli. Można na przykład usunąć element ze środka tabeli.
653
654Dostęp obiektowy do obiektu krotkowego: SELECT VALUE(x) FROM table x;
655Dostep relacyjny do obiektu krotkowego: SELECT * FROM table;
656
657Metody typu obiektowego:
658- MEMBER - wywoływane na rzecz konkretnego obiektu
659- STATIC - wywoływane na rzecz całego typu obiektowego
660- MAP/ORDER - metody wykorzystywane do porównywania obiektów
661- CONSTRUCTOR - metody tworzace nowe obiekty
662
663Metoda jest definiowana dwukrotnie:
664- w deklaracji typu: sygnatura metody (nazwa i lista argumentów)
665- w definicji typu (body): ciało metody (implementacja i kod źródłowy)
666
667DROP TYPE nazwa_typu FORCE - usunięcie typu wraz z zależnościami
668
669Perspektywy:
670 USER_OBJECTS - informacje o typach obiektowych
671 USER_METHOD_PARAMS, USER_METHOD_RESULTS, USER_TYPE_METHODS - informacje o metodach typów obiektowych
672
673Tożsamość obiektu to unikalny i niezmienny identyfikator związany z danym obiektem przez cały cykl jego życia/
674Tożsamość posiadają tylko obiekty krotkowe, zapewniana jest przez OID.
675Identyfikatory sa lokalne i globalnie unikalne, automatycznie indeksowane.
676Aplikacja może wykorzystywac referencje do identyfikatorów, odczytywane za pomocą REF()
677
678Przykład funkcji odwzorowującej:
679MAP MEMBER FUNCTION odwzoruj RETURN NUMBER IS
680BEGIN
681 RETURN wiek() + 3;
682end;
683
684Co to konstruktor?
685Metoda do tworzenia typów obiektowych. Typ obiektowy dostarcza domyslny konstruktor.
686Nazwa konstruktora jest taka sama jak nazwa typu obiektowego. Użytkownik może defniować własne konstruktory lub
687przesłonić domyślny.
688CONSTRUCTOR FUNCTION nazwa_typu (test VARCHAR2) RETURN SELF AS RESULT;
689
690Referencje
691typ obiektowy może posiadac referencje na istniejący obiekt innego typu obiektowego.
692np. obiekt osoba i adres
693kilka obiektów osoba może posiadać referencje na ten sam obiekt adres
694
695Nawigacja jawna
696SELECT o.pole1, DEREF(o.referencja) FROM tablica o;
697
698Nawigacja niejawna
699SELECT o.pole1, o.referencja.pole1 FROM tablica o;
700
701SELECT nazwisko, value(x) FROM klienci CROSS JOIN TABLE(filmy) x;
702
703Ograniczenia integralnościowe
704możliwe jest tylko dla tabel obiektowych (czyli CREATE TABLE tabela OF obiekt);
705ALTER TABLE table ADD PRIMARY KEY(pole1, pole2);
706ALTER TABLE tabela ADD CONSTRAINT ograniczenie CHECK (liczba > 0);
707ALTER TABLE tabela ADD CONSTRAINT ograniczenie2 liczba NOT NULL;