00.02.22

Relacyjny model baz danych – baza danych jest zbudowana na zasadzie relacji matematycznych. Relacja jest to zbiór elementów w postaci tabeli dwuwymiarowej przy czym nie jest ważne uporządkowanie tabeli.

Zbiór krotek daje tablicę dwuwymiarową. Każda tabela (relacja) ma swoją nazwę która w danej bazie danych jest niepowtarzalna. W modelu relacyjnym istotne jest pojęcie klucza głównego. Kluczem dla tabeli jest kolumna lub pole (nie zawsze). Klucz ma dwie podstawowe role:

-ma rozróżniać wiersze (krotki)

-musi być nie pusty.

Kluczem może być zbiór kolumn.

Klucze kandydujące – identyfikują poszczególny rekord (krotkę)

Baza danych w modelu relacyjnym to wiele tabel. Jeśli mają stanowić jedną całość to dane muszą być spójne. Jeśli mamy dwie tabele stanowiące całość musi istnieć powiązanie aby korzystać z danych z tych tabel. Klucz główny 1 tabeli staje się kluczem obcym dla drugiej tabeli. Związki są postrzegane jako relacje. Jeśli w środowisku baz danych nie ma SQL to nie ma mowy o relacyjnej bazie danych.

Powiązania między tabelami – istotne na etapie tworzenia:

1:1 – jednemu rekordowi z 1 tabeli odpowiada dokładnie 1 rekord z drugiej tabeli;

1:n – jednemu rekordowi z 1 tabeli odpowiada wiele rekordów z drugiej tabeli;

n:m – wielu rekordom z 1 tabeli odpowiada wiele rekordów z drugiej tabeli.

Powiązania są głównie na zasadzie klucz główny – klucz obcy.

W bazie danych muszą być więzy integralności – punkty odniesienia – jak się ma jedna tabela do drugiej.

Dziedzina wartości musi być pojedyncza dla każdej kolumny.

Model relacyjny baz danych – tabele, pojedyncze relacje, traktowane jako zbiory relacji.

Z modelem relacyjnym związany jest SQL. Bazuje na algebrze relacyjnej, operatorach:

1)selekcji – argument na wejściu bierze relację a na wyjściu produkuje relację, Wybierany jest pewien fragment zbioru w oparciu o słowo kluczowe WHERE.

2)projekcji (rzutowania) – argumentem wejściowym jest relacja matematyczna i z tej relacji są brane tylko niektóre kolumny.

3)typowe operatory algebry zbiorów : suma, iloczyn, różnica.

Jeśli mamy dwie tabele jest mowa o złączeniach to wtedy można wykonać iloczyn kartezjański (wszystkie możliwe układy z 1 i 2 tabeli)

4)złączenia – równozłączenie – zgodność przez klucze; złączenie może być prawo i lewo stronne.

SELECT co FROM skąd WHERE warunek

Jednocześnie może być selekcja, projekcja, złączenie

00.02.29

Z modelem relacyjnym są związane pojęcia:

1)relacja – dwuwymiarowa tablica (zbiór krotek). Własności relacji:

-zbiór krotek niepowtarzalny;

-ma swoją nazwę i ta nazwa w obrębie bazy danych musi być niepowtarzalna;

-klucz główny relacji (musi być niepusty i niepowtarzalny);

-kolejność rekordów nie ma znaczenia.

2)atrybut – kolumna relacji, ew. pola.

3)krotka – wiersz, rekord.

Atrybut musi mieć nazwę i typ wartości (typ liczbowy całkowity, wartości z pewnego przedziału, wszystkie znaki tekstu, duże znaki kodów ASCII).

Określona jest szerokość kolumny. Jeżeli tabela spełnia model relacyjny to w ramach kolumny muszą być pojedyncze wpisy (atrybut jednoznaczny). Zbiór towarzyszących kolumn powinien dotyczyć jednego tematu i zależeć od klucza głównego.

Do obsługi bazy danych służy język SQL. Jest on wzorowany na algebrze relacyjnej. W ramach SQL wyróżniamy następujące grupy:

-język zapytań;

-język sterowania danych;

-język definicji danych;

-język manipulacji danych.

Algebra relacyjna

Mamy do czynienia z relacją i operatorami.

Operatory relacji:

1)selekcja – wchodzi do niej 1 relacja a wynikiem będzie inna relacja. Selekcja odpowiada:

RESTRICT <nazwa relacji>[WHERE <warunek logiczny>]=><nazwa relacji wynikowej>

2)rzutowanie –

PROJECT <nazwa relacji> [<lista kolumn>]=><nazwa relacji wynikowej>

3)złączenie – punktem wyjścia jest iloczyn kartezjański

-równozłączenia – zgodność klucza głównego i obcego

EQUIJOIN <nazwa relacji1> WITH <nazwa relacji2>=><nazwa relacji wynikowej>

-złączenie naturalne – w praktyce najczęściej stosowane

JOIN <nazwa relacji1> WITH <nazwa relacji2> ON <klucz>=><nazwa relacji wynikowej>

-złączenia zewnętrzne (lewo i prawostronne) – odwołujemy się do nich gdy np. jedna tabela- pracownik i 2 – zespół. Powiązanie: dany pracownik jest zatrudniony i zespole i zespół zatrudnia pracowników. Może być tak że nowy pracownik nie należy do zespołu lub jest nowy zespół który nie ma przydzielonych pracowników. W modelu relacyjnym dopuszcza się wartości NULL. Nie można zastosować złączenia naturalnego gdyż wartość klucza nie jest zgodna.

4)Suma – struktury obu tabel muszą być takie same. Mają taką samą ilość kolumn i tego samego typu

<nazwa relacji1> UNION <nazwa relacji2>=><nazwa relacji wynikowej>

5)Przecięcie (iloczyn)

<nazwa relacji1> INTERSECTION <nazwa relacji2>=><nazwa relacji wynikowej>

6)Różnica

<nazwa relacji1> DIFERENCE <nazwa relacji2>=><nazwa relacji wynikowej>

Na tym oparty jest SQL.

SELECT [DISTINCT] <lista atrybutów/wyrażeń> FROM <nazwa relacji1, nazwa relacji2> WHERE <warunek logiczny>];

DISTINCT – otrzymujemy relację bez powtórzeń

SQL nie jest proceduralny. Określa co chcemy otrzymać a nie w jaki sposób.

SELECT [DISTINCT] <lista atrybutów, wyrażeń> [AS <alias>] FROM <nazwa relacji1 alias>, <nazwa relacji2 alias> [WHERE <warunek logiczny>] [GROUP BY <kryterium grupowania>] [HAVING <warunek logiczny>] [ORDER BY <kryterium porządkowania>] [DESC/ASC];

W warunku logicznym są brane pod uwagę złączenia.

Alias – nazwa zastępcza może dotyczyć : atrybutu, wyrażenia, relacji.

Przykład

Podać uporządkowaną liczbę pracowników wraz z okresem zatrudnienia w pełnych latach.

SELECT numer, nazwisko, TRUNC(MONTHS_BETWEEN(SYSDATE, data_zat)/12) AS zatrudnienie FROM pracownik ORDER BY nazwisko, zatrudnienie DESC;

Nazwa zastępcza może być bez spacji, jeżeli człon składa się z kilku wyrazów to w ‘’ ‘’ np., ‘’zatrudnienie w latach”. Jako wyrażenia mogą wystąpić + - funkcje statystyczne (agrygujące):

-COUNT (*) (liczebność) – najczęściej nie zależą od argumentów;

-SUM() – argument typu liczba;

-AVG()- średnia arytmetyczna;

-MAX()

-MIN()

Grupowanie

Przy tej operacji pomocne są funkcje agregujące.

Przykład

Ilu pracowników liczy każdy zespół (trzeba podzielić na grupy i w ramach każdej grupy określić liczebność)

SELECT COUNT(*) FROM pracownik –wszyscy pracownicy

SELECT id_zesp, COUNT(*) AS ‘’liczba pracowników’’ FROM pracownik GROUP BY id_zesp;

Przykład

Podać pracowników i zespoły które zatrudniają więcej niż 3 pracowników.

SELECT id_zesp, COUNT(*) FROM pracownik GROUP BY id_zesp HAVING COUNT(*)>3 ORDER BY id_zesp;

Operatory w warunkach

= < > !=

IN() – przynależność do zbioru

BETWEEN .. AND – pomiędzy

LIKE – określa wzorzec, dotyczy tekstu np. %_ (%- dowolny ciąg znaków, _- jeden znak)

Jest możliwy pusty wpis (nie jest to zero dla liczby ani ciąg pustych spacji dla tekstu)

IS NULL – gdy chcemy dowiedzieć się czy coś jest w polu

NOT – operator zaprzeczenia

NVL(V1,V2) – ma wartość V2 jeśli V1 jest null w przeciwnym razie V1 np. NVL(płaca_pod, 0), NVL(tekst,’nieznane’)

07.III.2000

Złączenie wewnętrzne (równozłączenie)

SELECT nazwisko,nazwa FROM pracownik,zespół WHERE pracownik.id_zesp=zespół.id_zesp AND nazwa='ADMINISTRACJA';

Złączenie nierównościowe !

atrybut1=atrybut2(+) lub atrybut1(+)=atrybut2

SELECT z.id_zesp, nazwa FROM zespół z.pracownik p WHERE z.id_zesp(+)=p.id_zesp AND p.NUMER IS NULL;

Przykład1 : Podaj łączne wynagrodzenia w każdym zespole (wykorzystane połączenie i grupowanie)

SELECT z.id_zesp, nazwa, NVL(SUM(płaca_pod),0) FROM zespół z, pracownik p WHERE p.id_zesp(+)=z.id_zesp GROUP BY z.id_zesp, nazwa;

jeśli by nie było (+) to uzyskalibyśmy tylko te zespoły, które zatrudniają kogoś, nie uzyskalibyśmy zespołów, które nie zatrudniają. Przy GROUP BY muszą pojawić się wszystkie argumenty z SELECT, które nie są składnikami funkcji agregujących, statystycznych....

Przykład2: Wypisać pracowników i ich przełożonych szefów, także tych, którzy nie mają swoich szefów. Nie interesuje nas numer, lecz nazwisko szefa. Trzeba zastosować zapytanie do tej samej tabeli dwukrotnie:

SELECT p.numer, p.nazwisko, p.szef, k.nazwisko FROM pracownik p, pracownik k WHERE p.szef=k.nazwisko(+) ORDER BY k.nazwisko;

----------

Pionowe łączenia relacji

SELECT <lista atrybutów/wyrażeń> FROM <nazwa relacji> [WHERE <warunek log 1>] OPERATOR SELECT <lista atrybutów/wyrażeń> FROM <nazwa relacji> [WHERE >warunek log 2>] [ORDER BY 1,...,n];

Przy order by mogą wystąpić tylko liczby. Jeśli operatorem będzie suma i relacja 1=10 krotek a relacja2=15 krotek, to uzyskujemy relacje =25 krotek. Jeśli operatorem jest różnica- wynikiem to co należy do jednego, nie należy do drugiego.

Liczba na liście atrybutów musi się zgadzać. Można łączyć więcej niż dwie relacje.

OPERATORY;

UNION- suma (bez powtórzeń)

UNION ALL- suma wszystkiego (z powtórzeniami)

MINUS- różnica

INTERSECT- przekrój.

przykład: uporządkowane nazwiska wszystkich pracowników, zatrudnionych w danych zespołach. Ze szczególnym wyróżnieniem osób pracujących w zespole nr 10, wyróżnieni będą gwiazdką.

SELECT nazwisko ||'*' FROM pracownik WHERE id_zesp=10 UNION SELECT nazwisko FROM pracownik WHERE id_zesp<>10 GROUP BY 1;

przykład:

lista etatów dotyczących zespołu 30 i 10. Lista atrybutów co do ilości i typów jest taka sama.

SELECT etat FROM pracownik WHERE id_zesp=30 UNION SELECT etat FROM pracownik WHERE id_zesp=10;

przykład:

lista nazwisk i płac z komentarzami

SELECT nazwisko, płaca_pod ,'Powyżej' płaca FROM pracownik WHERE płaca_pod>1500 UNION SELECT nazwisko, płaca_pod ,'...1500' płaca FROM pracownik WHERE płaca_pod=1500 UNION SELECT nazwisko, płaca_pod ,'Poniżej' płaca FROM pracownik WHERE płaca_pod<1500 ORDER BY 2;

przykład:

SELECT id_zesp FROM zespół MINUS SELECT id_zesp FROM pracownik;

przykład:

zespoły niezatrudniające pracowników

SELECT z.id_zesp, z.nazwa FROM zespół z, pracownik p WHERE p.id_zesp(+)=z.id_zesp MINUS SELECT z.id_zesp=z.id_zesp;

PODZAPYTANIA

Podać nazwiska osób których wynagrodzenie (płaca_pod) jest najwyższa

1. Trzeba najpierw wiedzieć ile wynosi najwyższa płaca: SELECT max(płaca_pod) FROM pracownik; //=2370

2. chcemy uzyskać nazwisko osoby otrzymującej takie wynagrodzenie.: SELECT nazwisko,płaca_pod FROM pracownik WHERE płaca_pod=2370;

Z tych dwóch punktów składamy podzapytania (są zewnętrzne i wewnętrzne).

SELECT nazwisko, płaca_pod FROM pracownik WHERE płaca_pod=(SELECT max(płaca_pod) FROM pracownik);

Poziomy zagnieżdżeń mogą być różne: -w trybie normalnym, w trybie skorelowanym.

Podzapytania w trybie normalnym:

przykład:

Nazwiska osób pracujących na takim samym etacie jak osoba o nazwisku "Kolski"

SELECT nazwisko,etat FROM pracownik WHERE etat=(SELECT etat FROM pracownik WHERE nazwisko='Kolski');

Podzapytanie zwraca tylko jedną wartość. Jeśli by zwracało więcej wartości, to trzeba zastosować IN,ANY,ALL

ANY i ALL- współpracują z operatorami <,>. ANY- jakakolwiek wartość spełniająca warunek, ALL- wszystkie wartości muszą spełnić warunek

przykład:

SELECT * FROM pracownik WHERE (płaca_pod, id_zesp) IN (SELECT MIN(płaca_pod),id_zesp FROM pracownik GROUP BY id_zesp);

dowiadujemy się wszystkiego pod warunkiem, że płaca podstawowa jest najniższa w ramach swojego zespołu.

przykład:

nazwiska, płace i zespoły , podczas gdy płaca jest większa od jakiejkolwiek płacy z zespołu 10.

SELECT nazwisko,płaca_pod,id_zesp FROM pracownik WHERE płaca_pod >ANY (SELECT DISTINCT płaca_pod FROM pracownik WHERE id_zesp=10);

14.III.2000

Podzapytania proste

najpierw wykonywane jest podzapytanie wewnętrzne i przekazywane jest wyżej.

SELECT <lista wyrażeń> FROM <lista relacji> [WHERE atrybut operator (podzapytanie)]

podzapytanie proste jest wykorzystywane jeden raz. Ważny jest operator. Dla podzapytania zwracającego jedną wartość =,!=,>,< , dla podzapytania zwracającego więcej wartości stosuje się IN, <;> ANY, <;>ALL

przykład:

SELECT nazwisko, płaca_pod FROM pracownik WHERE płaca_pod >ALL(SELECT płaca_pod FROM pracownik, zespół WHERE nazwa='ADMINISTRACJA' AND pracownik.id_zesp=zespół.id_zesp) ORDER BY nazwisko;

przykład:

należy wybrać etat na którym jest najniższe średnie wynagrodzenie w grupie. Trzeba użyć funkcji agregującej.

SELECT etat, AVG(płaca_pod) FROM pracownik HAVING AVG(płaca_pod)=(SELECT MIN(AVG(płaca_pod)) FROM pracownik GROUP BY etat) GROUP BY etat;

przykład:

nazwa i identyfikator, który zespół łącznie dostaje największe wynagrodzenie.

SELECT id_zesp, nazwa FROM zespół WHERE id_zesp=(SELECT id_zesp FROM pracownik GROUP BY id_zesp HAVING sum (płaca_pod)=(SELECT MAX(SUM(płaca_pod)) FROM pracownik GROUP BY id_zesp));

Podzapytania skorelowane

Pod przyczyną podzapytania zewnętrznego przekazywany jest wynik. Tu odwołania są przez aliasy, zwykle podzapytania do tej samej tabeli.

przykład:

podzapytanie dotyczy jednej tabeli, ta tabela ma alias. Dla każdego np. nazwiska wykonywane jest podzapytanie. Połączenie tabeli samej ze sobą)

SELECT nazwisko,płaca_pod, etat FROM pracownik p WHERE płaca_pod >(SELECT AVG(płaca_pod) FROM pracownik WHERE etat=p.etat);

przykład:

wyprowadzić powtarzające się nazwiska.

SELECT nazwisko FROM pracownik p WHERE 1<(SELECT COUNT(*) FROM pracownik WHERE nazwisko=p.nazwisko);

przykład:

nazwisko pracownika, którego pensja jest najwyższa, oraz nazwisko pracownika, którego pensja jest druga w kolejności.

SELECT nazwisko, płaca_pod FROM pracownik p WHERE 1>=(SELECT count(DISTINCT płaca_pod) FROM pracownik WHERE płaca_pod>p.płaca_pod);

----

Operator istnienia EXISTS, NOT EXISTS

chcę otrzymać listę nazwisk pracowników, którzy mają podwładnych. W tabeli pracownik jest zapisany numer szefa. Wykorzystujemy podzapytania skorelowane, gdyż korzystamy z tej samej tabeli

SELECT nazwisko, id_zesp FROM pracownik p WHERE EXIST (SELECT numer FROM pracownik WHERE pracownik.szef=p.numer);

----

przykład:

wskazywać nazwę zespołów, które nie zatrudniają pracowników. Można za pomocą MINUS , można też przy pomocy operatora EXISTS.

SELECT nazwa,id_zesp FROM zespół z WHERE NOT EXISTS (SELECT 1 FROM pracownik p WHERE p.id_zesp=z.id_zesp);

Podzapytania mogą znaleść się w WHERE,HAVING,FROM.

Załóżmy, że mamy zespoły pracownicze. Ile każdy zespół zatrudnia pracowników. Ile kwoty ma każdy zespół i procentowo, ile zespół zatrudnia pracowników.

Kolumny id_zesp, ile pracowników, procentowy udział pracowników, procentowy udział płac.

SELECT a.id_zesp "Zespół", TRUNC(100*a.liczba_prac/b.liczba_prac,1) AS "%pracowników",TRUNC(100*a.suma_wyn/b.suma_wyn,1) AS "%wynagrodzenia" FROM (SELECT id_zesp,COUNT(*) AS liczba_prac, SUM(płaca_pod) AS suma_wyn FROM pracownik GROUP BY id_zesp)a, (SELECT COUNT(*) AS liczba_prac, SUM(płaca_pod) AS suma_wyn FROM pracownik) b;

Są trzy atrybuty. Pierwszy atrybut id_zesp, z relacji a, kolumna będzie miała tytuł "zespół", drugi i trzeci – to wyrażenia.

00.III.28

Definiowanie tabel DDL

Polecenia

- tworzenie obiektów baz danowych (relacje, tabele)

- perspektywy, widoki

- sekwencje, liczniki

- indeksy

Konkretne pole ma dziedzinę wartości.

Składnia polecenia które pozwoli tworzyć obiekt typu relacja:

CREATE TABLE <nazwa relacji> (<nazwa atrybutu1><nazwa atrybutu2> (rozmiar) [DEFAULT<wartość domyślna>] [CONSTRAINT<nazwa ograniczenia> <ograniczenie atrybutu1>], <nazwa atrybutu2><typ atrybutu2> (rozmiar) [.....] [CONSTRAINT<nazwa ograniczenia>]<ograniczenie relacji>];

Typy atrybutów:

1.dla liczb

NUMBER – liczby zapisane za pomocą cyfr 0..9, znaków +-. (ilość cyfr 38)

NUMBER(r) – liczba nie może być zapisana na więcej niż r znakach

NUMBER(r, n) r- obejmuje wszystko n – ilość znaków po kropce

2. tekst

CHAR(r) r – ilość znaków (napisy, łańcuchy, teksty składające się z małych i dużych znaków, od 1 do 255 znaków)

VARCHAR(r) – długość od 1 do 2000

VARCHAR2(r) – długość od 1 do 2000 (jeśli nazwisko jest tego typu i ma 20 znaków to jest tyle miejsca ile dla konkretnego nazwiska, natomiast dla varchar(r) reszta znaków wypełniona jest spacjami)

3. data

DATE – przedział od 1.I.4117 r. p.n.e do 31.XII.4117 r. n.e.

LONG – zachowuje się jak CHAR ale długość od 1 do 2GB, nie można tego typu wykorzystywać w klauzuli WHERE, nie można grupować, porządkować, w ramach tabeli może wystąpić tylko raz.

LONG RAW – rozmiar od 1 do 2GB, jest wykorzystywany do przechowywania różnych typów nie tylko znaków np. obrazy, dźwięki

Przez wartość domyślną rozumiemy np. że dla daty urodzenia wartością domyślną może być data systemowa, dla kwoty może być jakaś wartość wpisana

Ograniczenia integralnościowe

NULL – wartość pusta

NOT NULL – wartość niepusta

UNIQUE – wartość niepowtarzalna

FOREIGN KEY – klucz obcy

PRIMARY KEY – wartość klucza głównego (niepusty i niepowtarzalny)

REFERENCES – powiązania z kolejnymi tabelami (wykorzystane przy definiowaniu klucza obcego tabeli)

CHECK... – warunek

W skład CHECK może wchodzić:

operatory > < = IN, LIKE, BETWEEN, OR, AND, NOT

ON DELETE CASCADE – jeżeli zostanie usunięty rekord z kluczem podstawowym automatycznie kasowane są rekordy odwołujące się do klucza obcego.

Jeżeli sami nie podajemy nazwy ograniczenia wtedy system nadaje SYS_C

Przykład1

Tabela1

CREATE TABLE dydaktycy (id_dydaktycy NUMBER(2) CONSTRAINT id_dydakt_pk PRIMARY KEY, nazwisko VARCHAR2(15) NOT NULL, tytuł VARCHAR2(10) NOT NULL);

Tabela2

CREATE TABLE przedmioty(id_przedm NUMBER(2) CONSTRAINT id_przedm_pk PRIMARY KEY, nazwa VARCHAR2(15) NOT NULL);

Tabela3

CREATE TABLE zajęcia (id_zajęć NUMBER(2) CONSTRAINT rodz CHECK (rodzaj_zajęć IN (‘WYKŁAD’,’LABORATORIUM’,’PROJEKT’)), id_dydakt NUMBER(2) NOT NULL, id_przed NUMBER(2) NOT NULL,

FOREIGN KEY(id_dydakt) ON DELETE CASCADE FOREIGN KEY(id_przed) REFERENCES przedmioty(id_przed));

W trzeciej tabeli są powiązania z poszczególnymi tabelami (a więc te tabele do których się odwołujemy muszą być utworzone wcześniej).

Przykład2

Tabela1

CREATE TABLE Zaszeregowania (grupa NUMBER(2) PRIMARY KEY, dolne NUMBER(8,2) NOT NULL, górne NUMBER(8,2) NOT NULL, CHECK (dolne<górne));

Tabela2

CREATE TABLE Działy (id_dział NUMBER(3) PRIMARY KEY, nazwa VARCHAR2(15) NOT NULL UNIQUE, miejsce VARCHAR2(25));

Tabela3

CREATE TABLE Pracownicy (id_prac NUMBER(4) PRIMARY KEY, nazwisko VARCHAR2(20) NOT NULL, stanowisko VARCHAR2(15), kierownik NUMBER(4) REFERENCES Pracownicy data_zat DATE, zarobki NUMBER(8,2), premia NUMBER(8,2), id_dział NUMBER(3) REFERENCES Działy CHECK (premia<zarobki));

To jest wszystko sam szkielet tabeli, ale można również tabele od razu wypełniać odpowiednimi wartościami

CREATE TABLE <nazwa relacji> [<nazwa atrybutu1> DEFAULT <wartość domyślana>] [NULL/NOT NULL] AS SELECT <....>;

czyli twórz tabelę bazując na podzapytaniu.

Pzykład3

CREATE TABLE lista_płac (id_prac NOT NULL, nazwisko NOT NULL, pensja DEFAULT 750 NOT NULL) AS SELECT id_prac, nazwisko, zarobki+premia FROM pracownik;

Parametry składowania tabel (bazy danych)

- ilość wolnej przestrzeni w % (domyślnie 10)

- procent wypełnienia bloku

- liczba pozycji

- nazwa przestrzeni tabel

Ilość wolnej przestrzeni ma związek z typem VARCHAR2.

Istnieje możliwość zmian struktury tabel

1. Zmiana schematu

ALTER TABLE <nazwa relacji> ADD (<nazwa atrybutu> <typ atrybutu> <rozmiar> [DEFAULT <...>] [CONSTRAINT <ograniczenia>]);

2. Zmodyfikowanie istniejącego atrybutu

ALTER TABLE <nazw relacji> MODIFY (<nazwa atrybutu> <typ atrybutu> <rozmiar> [DEFAULT <...>] [NULL/NOT NULL]);

W Oraclu nie ma możliwości usunięcia atrybutu

Przykład4

ALTER TABLE pracownik MODIFY (tytuł_nauk VARCHAR2(15) DEFAULT ‘mgr’ NOT NULL);

Ważne są więzy integralności

00.IV.04

Włączenie lub wyłączenie ograniczenia:

ALTER TABLE <nazwa relacji> DISABLE/ENABLE <rodzaj ograniczenia> / CONSTRAINT <nazwa ograniczenia> [CASCADE];

Rodzaj ograniczenia: UNIQUE, PRIMARY KEY, ALL TRIGGERS(wszystkie wyzwalacze)

Usunięcie ograniczenia:

ALTER TABLE <nazwa relacji> DROP <rodzaj ograniczenia> /CONSTRAINT < > [CASCADE];

CASCADE- usuwane są wszystkie połączenia.

Jest możliwość odroczonych więzów integralności.

Przykłady na DDL (język definiowania danych)

1. ALTER TABLE pracownik ADD (CONSTRAINT prac_fiz FOREIGN KEY (id_dział) REFERENCES dział(id_dział);

2. ALTER TABLE zajęcia DISABLE PRIMARY KEY;

3. ALTER TABLE pracownik DROP CONSTRAINT etat_dz;

Usunięcie tabeli:

DROP TABLE <nazwa relacji< [CASCADE CONSTRAINT];

to polecenie również jest użyteczne w przypadku gdy jesteśmy użytkownikami danej tabeli

Można zmienić nazwę tabeli:

RENAME <stara nazwa relacji> TO <nowa nazwa relacji>;

DESCRIBE <nazwa relacji>;

DML – manipulacja danymi

INSERT INTO <nazwa relacji/tabeli> [<lista atrybutów>] VALUES(wartość1, wartość2,...);

polecenie to umożliwia dodanie jednego rekordu (krotki), powinna być zgodność atrybutów.

INSERT INTO <nazwa relacji> [<lista atrybutów>] SELECT <lista atrybutów>

FROM ...;

poprzez to polecenie istnieje możliwość dołączenia tylu rekordów ile powstanie w wyniku SELECT (może zostać dołączonych kilka rekordów).

UPDATE <nazwa relacji/tabeli> SET <nazwa atrybutu1>,<nazwa atrybutu2>] = {wyrażenie/podzapytanie} [WHERE <warunek logiczny>];

polecenie to umożliwia modyfikowanie istniejących danych, jeżeli nie ma klauzuli WHERE to modyfikowane są wszystkie rekordy.

DELETE FROM <nazwa tabeli/relacji> [WHERE <warunek logiczny>];

polecenie to pozwala na usunięcie rekordów (krotek), jeśli nie ma warunku usuwane są wszystkie rekordy z tabeli.

Przykłady

1. INSERT INTO zajęcia VALUES(5, ‘LABORATORIUM’,10,12);

2. INSERT INTO pracownik SELECT * FROM pracownik@baza.zgoda.bytom.pl; przykład z tabelą która znajduje się na innym hoście

3. UPDATE pracownik SET płaca_pod=(SELECT płaca_pod FROM

dodatki d WHERE d.numer=pracownik.numer) WHERE numer IN

(SELECT numer FROM dodatki);

4. UPDATE pracownik a SET (a.płaca_pod, a.płaca_dod)=(SELECT

AVG(płaca_pod)*1.2, MAX(NVL(płaca_pod,0)) FROM pracownik WHERE id_zesp=a.id_zesp) WHERE a.pracuje_od>’89/12/31’;

zmiany będą u pracowników którzy mają określony staż

PERSPEKTYWA – VIEW (DDL)

Jest to obiekt bazy danych, utożsamiana z tabelą, ale fizycznie nie istnieje, bazuje ona tylko na definicji.

Cele stosowania:

- uproszczenie (z całej tabeli wycinamy pogląd atrybutów które mnie interesują)

- ochrona pewnych danych – nie do wszystkich danych mają wszyscy dostęp (ograniczenie informacji)

- powtarzające się czynności możemy zastąpić perspektywą.

Perspektywy bazują na podzapytaniu (może dołączyć jedną tabelę lub wiele)

Podzapytanie dotyczące jednej tabeli – perspektywa prosta.

Podzapytanie z grupowaniem, porządkowaniem, ograniczenia, kilka podzapytań – perspektywa złożona.

CREATE [OR REPLACE] VIEW <nazwa perspektywy> [<lista atrybutów>] AS SELECT ... [WITH CHECK OPTION];

Można stworzyć perspektywę, która jest jakby podsumowaniem. Jeśli jest podana perspektywa to do tego momentu można ją traktować jak tabelę.

Do perspektywy możemy dodawać zapytania SELECT, dopisywać INSERT, modyfikować UPDATE, kasować DELETE.

Jeśli dopisuje się do perspektywy lub też modyfikuje to również modyfikowane wartości zmieniają się w tabeli macierzystej. Jeśli usuwam z perspektywy to rekordy mogą zostać usunięte również z tabeli macierzystej.

Perspektywę można również usunąć:

DROP VIEW <nazwa perspektywy>;

Przykłady perspektyw

1. CREATE VIEW asystenci AS SELECT numer, nazwisko FROM

pracownik WHEERE etat=’ASYSTENT’;

2. CREATE VIEW klientki AS SELECT * FROM klient WHERE płeć=’KOBIETA’;

3. CREATE VIEW szefowie AS SELECT nazwisko, nazwa FROM

pracownik p, zespół z WHERE numer IN (SELECT DISTINCT szef FROM pracownik) AND p.id_zesp=z.id_zesp;

2000-04-11

Sekwencje licznikowe.

Każda tabela relacja ma mieć klucz główny. Sekwencje licznikowe służą, że móc generować niepowtarzalne się wartości.

CREATE SEQUENCE [<nazwa użytkownika>] <nazwa sekwencji>

[INCREMENT BY <liczba>] [START WITH <liczba (wartość początkowa)>]

[CYCLE/NOCYCLE];

CYCLE – cyklicznie

NOCYCLE – niecyklicznie

W ramach sekwencji dostępne są dwie wartości:

-aktualna

-następna.

Sposoby do pobierania sekwencji:

<nazwa sekwencji>.NEXTVAL

<nazwa sekwencji>.CURRVAL

Gdy chcemy dopisywać kolejnego pracownika

INSERT INTO pracownik

VALUES (prac_seq.NEXTVAL,’NOWAK’,....);

Możliwe jest usuwanie sekwencji

DROP SEQUENCE <nazwa sekwencji>;

Można stworzyć sekwencje, która ma wartości tekstowe.

Indeksy można rozumieć jako sposób dotarcia do rekordu. Jeśli tabela ma atrybuty unikalne, to sam system zakłada indeks na klucze główne i na atrybuty unikalne, niepowtarzalne. Stosuje się indeksy bitmapowe (są to indeksy rzadkie). Jest możliwe tworzenie indeksów przez użytkownika.

CREATE [UNIQUE] INDEX <nazwa indeksu> ON <nazwa relacji>(nazwa atrybutu1, [<nazwa atrybutu2>]);

Indeksy można stosować gdy:

-jeśli mamy doczynienia z dużymi tabelami, jest sens zakładania indeksów, jeśli występują w warunkach zapytań.

Podobnie gdy łączymy warunki

-jeśli wprowadzamy nowe dane, a jeśli atrybuty mają indeksy to muszą być one uaktualniane

-jeśli mamy klucze obce w relacji to dobrze jest zakładać na nią indeksy

Przykład 1

CREATE UNIQUE INDEX id_zesp

ON pracownik (id_zesp);

id_zesp jest kluczem obcym.

Przykład 2

CREATE INDEX nazwisko

ON pracownik (nazwisko);

Usuwanie indeksu

DROP INDEKS <nazwa indeksu>;

Wszystkie obiekty są rejestrowane w słownikach danych.

USER_TABLES

USER_CONSTRAINTS

USER_SEQUENCES

USER_VIEWS

USER_INDEXES

USER_OBJECTS

USER_TRIGGERS - wyzwalacze

USER_SOURCE – obiekty źródłowe

Z przedrostkiem ALL_ dotyczy wszystkich tabel, sekwencji.

DBA_ - dotyczy administratora.

PL/SQL – rozszerzenie proceduralne języka SQL, która pozwala pisać aplikacje. Jest dostępny w różnych produktach narzędziowych i jest dostępny w SQL+.

Podstawą jest blok anonimowy, który zawiera pewne słowa kluczowe, ustawienia.

Blok anonimowy dotyczący proceduralnego SQL-a

[DECLARE

<deklaracje obiektów PL/SQL zmienne, stałe, wyjątki, procedury, funkcje]

BEGIN

<ciąg instrukcji do wykonania

[EXCEPTION

<obsługa wyjątków>]

END;

Część deklaracyjna może być nieobecna, podobnie jest z wyjątkiem.

Instrukcje, które mogą się znaleźć w bloku anonimowym.

SELECT – instrukcja wyszukiwania

INSERT – manipulacja danymi

UPDATE – wstaw

DELETE – usuń

COMMIT, ROLLBACK – dotyczą transakcji.

Rezultat wyszukiwania – nie ma przekazania rezultatu wyszukiwań. Wynik jest zapisywany w zmiennych. Jeśli jest to jedna wartość lub jedna linijka odpowiedzi – wtedy wystarczy powołać zmienne. Jeśli mamy klika linijek odpowiedzi – należy się odwoływać do bardziej złożonych instrukcji, przesyłając je do bufora danych. Nazwa bufora – kursor.

Deklaracja zmiennych

identyfikacja.zm typ danych [NOT NULL]

[:=przyporządkowane wyrażenie];

identyfikator CONSTANT typ_danych [NOT NULL]

[:=wyrażenie];

Przykład

Znak CHAR(1);

Wynagrodzenie NUMBER(7,2);

PI CONSTANT NUMBER (7,2):=3,14159;

Nazwa VARCHAR2(10):=’DRUKARKA’;

Termin DATE:=Sysdate;

Stan_Cywilny BOOLEAN:=False;

Liczba_Dzieci BINARY_INTEGER:=0;

Brak_Danych EXCEPTION;

Osoba pracownik_nazwisko%TYPE;

Pracownik_rekord pracownik%ROWTYPE;

2 ostatnie wiersze – odwołujemy się do struktur tabel. Osoba będzie takiego typu jak nazwisko w tabeli pracownik. W ostatnim mamy zmienną typu rekordowego, będzie miał taki typ jak jego odpowiednik w tabeli. BINARY_INTEGER – typ w proceduralnym SQL.

Zmienne systemowe

SQL%ROWCOUNT – ile wierszy zostało przekazanych przez ostatnią instrukcję SQL-a.

SQL%FOUND – zmienna ma wartość logiczną

-(TRUE) – jeśli został znaleziony przynajmniej jeden wiersz

SQL%NOTFOUND – TRUE – żaden wiersz nie został znaleziony, przetworzony.

Używane w razie wyjątków są:

SQLERRM – tekstowy, można dodać informację o błędzie

SQLCODE – kod błędu

Przykład 4

DECLARE

usunięte NUMBER;

BEGIN

DELETE FROM zespół WHERE id_zesp=50;

usunięte :=SQL%ROWCOUNT;

INSERT INTO dziennik VALUES (‘Zespół’, usunięte, Sysdate);

END;

Bloki anonimowe są punktem wyjścia dla procedur, funkcji.

Różnica w skłądni SQL

SELECT <atrybut/wyrażenie>

INTO <zmienna 1>...

FROM <nazwa relacji>

[WHERE <warunek logiczny>]

[GROUP BY < >];

Rzykład 5

DECLARE

Nazw Spis.Nazwisko%TYPE;

Eta Spis.Etat%TYPE;

Komunikat VARCHAR2(45);

BEGIN

SELECT Nazwisko, Etat INTO Nazw, Eta

FROM Spis

WHERE Data BETWEEN ‘99/05/01’ AND ‘99/05/31’;

EXCEPTION

WHEN no_data_found THEN

INSERT INTO dziennik VALUES (‘Nikt nie był zatrudniony w maju’);

WHEN too_many _roows THEN

INSERT INTO dziennik VALUES (‘Więcej niż jeden zatrudniony’);

WHEN OTHERS THEN

Komunikat:=’Błąd nr’||SQLCODE||’,Komunikat=’||’SUBSTR(SQLERRM,1,30);

INSERT INTO dziennik VALUES (Komunikat);

END:

2000.05.16

SELECT __ INTO __ FROM

INSERT

UPDATE

DELETE

COMMIT

Wynik Selectu jest (zapamiętywany) przekazywany do zmiennej PL/SQL. Nie ma możliwości tworzenia tabel i zmiennej create, after.

Instrukcje sterujące

1) IF <warunek logiczny> THEN <blok instrukcji>

END IF;

2) IF <warunek logiczny> THEN <blok instrukcji>

ELSE <blok instrukcji> END IF;

3) IF <warunek logiczny> THEN <blok instrukcji>

ELSIF <warunek logiczny> THEN <blok instrukcji>

END IF;

PĘTLE

1) LOOP

<blok instrukcji EXIT względnie EXIT WHEN <warunek logiczny>>

END LOOP;

2) FOR <zmienna> IN <wartość1> ... <wartość2>

LOOP

<blok instrukcji>

END LOOP;

3) WHILE <warunek logiczny>

LOOP

<blok instrukcji>

END LOOP;

@nazwa pliku – uruchamianie skryptów

EXEC __

Wyzwalacze w bazach danych

Jest to rodzaj procedury, które wykonują się samoistnie, biorąc pod uwagę zdarzenie – operację ustaw, modyfikuj i usuń. Utrzymują węzły spójności tabel. Przez wyzwalacz można zadbać o spójność tabel.

Wyzwalacze są traktowane jako obiekty bazy danych, i jest składowany na serwerze.

Schemat tworzenia wyzwalaczy

CREATE [OR REPLACE] TRIGGER <nazwa wyzwalacza>

BEFORE / AFTER

<specyfikacja instrukcji> ON <nazwa relacji>

[FOR EACH ROW]

<blok instrukcji PL/SQL>

W specyfikacji mogą występować

INSERT

UPDATE OF

DELETE

Jeżeli chcemy łączyć wszystko to dodajemy słowo OR

:NEW.<nazwa atrybutu> - nowa wartość

:OLD.<nazwa atrybutu> - stara wartość

Przykład 1

Wyzwalacz, który będzie reagował przed faktem wstawiania nowego rekordu do tabeli, jeden z atrybutów np. nowa płaca podstawowa. Chcemy aby nie była za mała.

CREATE OR REPLACE TRIGGER sprawdź_płacę

BEFORE INSERT ON pracownik

FOR EACH ROW

BEGIN

IF :NEW.płaca <500 THEN

RAISE_APPLICATION_ERROR (-20000, Płaca zbyt niska’);

END IF;

END;

/

żeby ten kod źródłowy został przyjęty w dobrym wierszu piszemy znak dzielenia

Jeśli się skompiluje piszemy to co jest poniżej

INSERT INTO pracownik VALUES ( , , )

-jeśli wpiszemy płacę < 500 to wypisze komunikat.

Przykład 2

Wyzwalacz, będzie sprawdzał czy dany zespół będzie zatrudniał pracowników. Jeśli tak ten rekord nie powinien być usunięty.

CREATE OR REPLACE TRIGGER czy_zatrudnia

BEFORE DELETE ON zespół

FOR EACH ROW

DECLARE

L_prac NUMBER (2) :=0;

BEGIN

SELECT COUNT (*) INTO l_prac FROM pracownik

WHERE id_zesp = :OLD.id_zesp;

IF l_prac >0 THEN

RAICE_APPLICATION_ERROR (-20005, ‘W tym zespole są zatrudnieni pracownicy ‘);

END IF;

END;

INSERTING

DELETING o wartości logicznej

UPDATING

Możemy się odwoływać jaka jest wartość logiczna

Przykład 3

CREATE TRIGGER ustaw_null

AFTER DELETE OR UPDATE OF

id_zesp ON zespół

FOR EACH ROW

BEGIN

IF updating AND :OLD.id_zesp<>

:NEW.id_zesp OR deleting

THEN UPDATE prac SET

prac.id_zesp = NULL WHERE

prac.id_zesp = :OLD.id_zesp;

END IF;

END;

Był to przykład wyzwalacza działającego po fakcie.

Przykład 4

Wyzwalacz do obsługi budżetu

CREATE TRIGGER budżet.zesp

AFTER DELETE OR INSERT OR UPDATE

OF wynagrodzenie, id_zesp ON pracownik

FOR EACH ROW

BEGIN

IF deleting OR (updating AND :OLD.id_zesp <>:NEW.id_zesp)

THEN UPDATE budżet SET

fundusz_płac = fundusz_płac - :OLD. wynagrodzenie WHERE nr_zesp = OLD.id_zesp;

END IF;

IF inserting OR (updating AND :OLD. id_zesp <> :NEW.id_zesp)

THEN UPDATE budżet SET

fundusz_płac = fundusz_płac + ;NEW.wynagrodzenie WHERE nr_zesp=NEW.id_zesp;

END IF;

IF updating AND (:OLD.id_zesp = : NEW.id_zesp)

AND:OLD.wynagrodzenie <>:NEW.wynagrodzenie

THEN UPDATE budżet SET

fundusz_płac = fundusz_płac - :OLD.wynagrodzenie + :NEW.id_zesp;

END IF;

END;

Żeby zmienić status wyzwalacza

AFTER TRIGGER <nazwa wyzwalacza>

ENABLE/DISABLE

Usunięcie wyzwalacza

DROP TRIGGER <nazwa wyzwalacza>

DESC USER_TRIGGERS

KURSORY

Rodzaj bufora do przechowywania krotek. Należy zadeklarować kursor bazujący na konkretnych tabelach.

DECLARE CURSOR <nazwa kursora>

IS SELECT (...) FROM (...) WHERE …;

Polecenie otwierające kursor

OPEN

Pobranie pojedynczej krotki

FETCH

Zamknięcie kursora

CLOSE

Atrybuty:

kursor%FOUND – znaleziono

kursor%NOTFOUND – nie znaleziono

kursor%ROWCOUNT – ilość krotek

kursor%ISOPEN – czy otwarty

Przykład 5

Sprawdzić pracowników zatrudnionych w zespole o konkretnej nazwie

BEGIN

DECLARE CURSOR pracownik_kursor

IS

SELECT nazwa, płaca_pod, pracuje_od, pracownik.id_zesp

FROM pracownik, zespół

WHERE pracownik.is_zesp = zespół.id_zesp

AND nazwa=’ BAZY DANYCH’;

Zostanie powołana zmienna pracownik_dane która będzie tego samego typu jak pracownik_kursor.

pracownik_dane pracownik_kursor%ROWTYPE;

BEGIN

OPEN pracownik_kursor

LOOP FETCH pracownik_kursor

INTO pracownik_dane;

EXIT WHEN pracownik_kursor

%NOTFOUND

2000-05-23

BLOK ANONIMOWY

Przykład 1

BEGIN

DECLARE

CURSOR pracownik_kursor IS SELECT numer,

płaca, pracuje_od, pracownik.id_zesp

FROM pracownik, zespół WHERE

pracownik.id_zesp = zespół.id_zesp AND

nazwa = ‘ BAZY DANYCH ‘;

Tak wygląda główny select zapytania

Zmienna dane typu pracownik

pracownik_dane pracownik_kursor %ROWTYPE;

BEGIN

OPEN pracownik_kursor;

LOOP

FETCH pracownik_kursor INTO pracownik_dane;

EXIT WHEN pracownik_kursor % NOTFOUND;

IF pracownik_dane.pracuje_od < ‘70/01/05’

THEN UPDATE pracownik SET płaca = płaca*1,3

WHERE numer = pracownik_dane.numer;

ELSIF pracownik_dane.pracuje_od > ‘70/01/05’

AND pracownik_dane.pracuje_od <’95/01/01’

THEN UPDATE pracownik SET płaca = płaca*1,2

WHERE numer = pracownik_dane.numer;

ELSE

UPDATE pracownik SET płaca=płaca*1.05

WHERE numer = pracownik_dane.numer;

END IF;

END LOOP

CLOSE pracownik.kursor;

END;

END;

Przykład 2

Dotyczy pracowników, którzy mają najniższe wynagrodzenie w pierwszej i w drugiej kolejności.

BEGIN

DECLARE

CURSOR pracownik_kursor (id_zespołu NUMBER)

IS SELECT numer, nazwisko, płaca

FROM pracownik WHERE pracownik.id_zesp = id_zespołu

AND 3> (SELECT COUNT (DISTINCT płaca)

FROM pracownik WHERE id_zespołu = pracownik.id_zesp AND płaca <= pracownik.płaca)

pracownik_rekord pracownik_kursor%ROWTYPE;

BEGIN

FOR pracownik_rekord IN pracownik_kursor (20)

LOOP

UPDATE pracownik SET płaca = płaca*1.1

WHERE numer = pracownik_rekord.numer;

END LOOP;

END;

END;

Pobranie kursora (otwieranie) nie musi być jawnie pisany.

Przykład 3

CREATE OR REPLACE PROCEDURE nowy_pracownik

(nazwisko_prac IN VARCHAR2, nazwisko_szefa IN VARCHAR2, nazwa_zespołu IN VARCHAR2, etat IN VARCHAR DEFAULT ‘STARZYSTA’, pensja IN NUMBER DEFAULT 900)

IS nr_szefa NUMBER(3);

nr_zespołu NUMBER(3);

BEGIN

SELECT id_zesp INTO nr_zespołu FROM zespół

WHERE nazwa = nazwa_zespołu;

SELECT numer INTO nr_szefa FROM pracownik

WHERE nazwisko = nazwisko_szefa AND id.zesp=nr.zespołu;

INSERT INTO pracownik VALUES (seq. NEXTVAL, nazwisko_pracownika, etat, nr_szefa, SYSDATE, pensja, NULL, nr_zespołu

EXCEPTION

WHEN no_data_found THEN

RAISE_APPLICATION_ERROR (-20000, ‘Nie znaleziono takiego szefa’);

END;

Uruchamianie

EXECUTE nazwa (lista wartości)

Procedura jest traktowana jako obiekt bazodanowy.

Usuwanie procedury

DROP nazwa_procedury

Przykład 4. Funkcja uwzględniona w składni.

Funkcja podaje stan zespołu

CREATE OR REPLACE FUNCTION podaj_stan_zespołu

(liczba IN NUMBER)

RETURN NUMBER

IS

wartość NUMBER;

BEGIN

SELECT COUNT(*) INTO wartość FROM pracownik

WHERE id_zesp=liczba;

RETURN wartość;

END;

Funkcje użytkownika mogą być wykorzystywane w selektach, w klauzuli where.

Możemy posługiwać się pakietem.

Pakiet obejmuję grupę procedur, funkcji. Specyfikacja pakietu i część implementacyjna pakietu.

Tworzenie lub zastępowanie pakietu.

CREATE OR REPLACE PACKAGE nazwa_pakietu AS Deklaracje procedur, funkcji (obiektów publicznych)

END nazwa pakietu;

CREATE OR REPLACE PACKAGE BODY

Nazwa_pakietu AS

Definicje obiektów publicznych (procedur, funkcji)

BEGIN

instrukcje inicjalizujące

END;

nazwa: obsługa_pakietów

Procedura: Podwyżka

Odwołanie się do pakietu: Obsługa_pracowników.Podwyżka ( )

Usuwanie pakietów

DROP PACKAGE nazwa pakietu

DROP PROCEDURE nazwa procedury

DROP FUNCTION nazwa funkcji

Polecenie, żeby otrzymać pośrednie wartości

DBMS_OUTPUT.PUT_lime(‘jakis tekst’||wartość zmiennej)

Przed rozpoczęciem uruchamiania procedury należy ustalić opcje:

SET SERVEROUTPUT ustawić na ON

Polecenie, które pozwoli utworzyć użytkownika

CREATE USER nazwa_użytkownika IDENTIFIED BY hasło;

W nazwie użytkownika nie może być polskich znaków.

Tak powołany użytkownik nie ma jeszcze uprawnień.

Przywileje, jakie może mieć użytkownik

-możliwość tworzenia własnych obiektów

-łączenia

-oglądania wybranej tabeli.

Uprawnienia dzieli się na:

-systemowe (administratorzy)

-obiektowe (oglądanie tabel)

Zmiana hasła

ALTER USER nazwa użytkownika IDENTIFIED BY hasło;

Zbiór uprawnień – rola. Użytkownikowi przyznaję się pewną rolę. W systemie Oraclowym są 3 role predefiniowane:

-rola CONNECT

-tworzenia wszystkich źródeł RESOURCE

-DBA – rola zarządcy, może powoływać innych użytkowników.

Nadawanie uprawnień

GRANT lista uprawnień TO użytkownik;

Odbieranie uprawnień

REVOKE lista uprawnień FROM użytkownik;

Lista uprawnień – systemowe, jeśli jeszcze ON – obiektowe.

Tworzenie roli

CREATE ROLE nazwa_roli

[IDENTIFIED BY hasło];

identified może być zabezpieczone hasłem

2000-05-30

Pojęcia związane z obiektowością:

1.Abstrakcyjny typ danych

2.Klasa (obiekt) – hermetyzacja

3.Dziedziczenie, klasa dziedziczy coś po poprzedniej klasie.

4.Agregacje (związki)

Przeciążenie operatorów, przeciążenie funkcji

int liczba1, liczba2

liczba1 = liczba1+liczba2;

wiel w1,w2,ww; operator + można przeciążyć i poprawne też będzie ww=w1+w2; - dodaj w sensie dwa wielomiany.

Dwie metody przejścia z modelu relacyjnego do modelu obiektowego baz danych: rozszerzenie modelu relacyjnego i dołączenie obiektowości (systemy hybrydowe, postrelacyjne).

Wspólna standaryzacja:

ODMG (Object Database Management Group) organizacja, która skupia firmy tworzące obiektowe bazy danych. Elementy:

-język definicji danych ODL (Object Definition Language)

-język zapytań OQL (Object Query Language)

-wiązania do trzech języków programowania obiektowego C++, Java, Smalktalk.

Są one odpowiednikiem manipulacji danymi

INSERT
UPDATE
DELETE

Abstrakcyjny typ danych to nie tylko dane statyczne, ale i metody.

CORBA (Common Object Request Broker Architecture)

Przykład

#include <stdio.h>

#include <sqlca.h>

void sql_error();

main()

{

char temp[32];

EXEC SQL BEGIN DECLARE SECTION;

char * uid = “scott/tiger”

SQL_CURSOR gener_cv;

int tab_num;

struct

{ int num;

char naz[15];

char eta[10];

int szef;

float pensja;

} prac.reg;

struct

{

int id_zesp;

char nazwa[20];

char adres[30];

} zesp_rek;

EXEC SQL END DECLARE SECTION;

EXEC SQL CONNECT: uid;

EXEC SQL ALLOCATE: gener_cv;

for( ; ; )

{

printf (“ “)’

gets (temp);

tab_num = atoi(temp);

if (tab_num<=0) break;

EXEC SQL EXECUTE

BEGIN

IF :tab_num = 1 THEN

OPEN : gener_cv

FOR SELECT * FROM pracownik

ELSIF : tab_num = 2 THEN

OPEN: gener_cv;

FOR

SELECT * FROM zespół

END IF

END;

END_EXEC;

EXEC SQL CLOSE : gener_cv

}

}

Podstawowe mechanizmy obiektowe w Oraclu 8. Można budować własne typy.

CREATE TYPE Osoba AS OBJECT

(nazwisko varchar2(20),

imię varchar2(10),

wiek number(2);

Tym można się posłużyć, by stworzyć tabelę uczniów.

Tabela obiektów

CREATE TABLE UCZEN OF osoba;

INSERT INTO UCZEN VALUES

(‘KOWALSKI’, ‘JAN’, 15);

Można się odwołać w klasyczny sposób

SELECT * FROM uczeń;

SELECT VALUE (u) FROM uczen u;

u traktowany jest jako alias

CREATE TABLE STUDENT

(stud Osoba, stan_cywilny varchar2(10);

INSERT INTO STUDENT VALUES

(osoba (‘NOWAK’, ‘PIOTR’, 21), ‘wolny’);