Wykład 4_5

Bazy danych
Język SQL
dr Lidia Stępień
1
●
●
Structured Query Language (SQL) – strukturalny język zapytań
Umożliwia wykonywanie operacji na relacyjnych bazach danych
takich, jak :

DDL – język definiowania danych, instrukcje
definiowania struktury danych

DML – język manipulacji danymi, instrukcje
pobierania i modyfikowania danych

DCL – język kontroli danych, instrukcje kontroli
dostępu do danych
Czym jest SQL?
●
Polecenia SQL mogą być rozmieszczone w kilku wierszach.
●
Koniec polecenia SQL musi być zakończy średnikiem.
●
●
●
Dobrym zwyczajem jest umieszczanie klauzul od nowych
linii.
Nie wolno dzielić słowa pomiędzy wiersze.
Dozwolone jest używanie małych lub wielkich liter, chyba
że sprawdzamy zawartość pola.
Uwagi
create table nazwa_tabeli (
nazwa_atrybutu typ (rozmiar)
[default wartość domyślna]
[ [ constraint nazwa_ogr.] ograniczenie_atr ],
…,
[ [ constraint nazwa_ogr.] ograniczenie_rel,…]
);
drop table nazwa_tabeli;
Tworzenie tabeli
null
wartości puste;
not null
bez wartości pustych;
unique
klucz unikalny relacji;
primary key
klucz podstawowy relacji
(nie występuje przy ograniczeniu
unique i odwrotnie);
foreign key | references
referencja do klucza podstawowego lub
unikatowego innej relacji ( do definicji
klucza obcego);
Ograniczenia
check( warunek)
warunek, który musi być spełniony przez
wszystkie wartości atrybutu;
Warunek buduje się używając operatorów:
●
=, < , !=,
●
is NULL, is not NULL,
●
like 'wzorzec', ('%' - łańcuch o długości >= 0; '_' - pojedynczy znak),
●
between … and … ,
●
in (…),
●
and, or, not.
Ograniczenia cd.
●
cena > 0
●
imie like '_ _ a%'
●
data between '1956-10-12' and '2011-12-31'
●
etat in ('adiunkt', 'profesor', 'asystent')
●
norma in (1, 2, 3);
Przykłady warunków
create table Port(
nazwa varchar(20) primary key,
ocean varchar(10) check ( ocean in ( 'Atlantyk',
'Pacyfik', 'Indyjski'),
szerokosc_geo char(4) NOT NULL,
dlugosc_geo char(4) NOT NULL
);
Przykład 1
create table Regaty(
nazwa varchar(20),
rok char(4),
liczba_uczestn INT2 NOT NULL,
constraint kl_gl_Regaty primary key (nazwa, rok)
);
Przykład 2
create table Trasa(
regaty varchar(20),
rok char(4),
port varchar(20),
kolejnosc INT2 NOT NULL,
constraint kl_gl_Trasa primary key (regaty, rok, port),
foreign key (port) references Port(nazwa),
foreign key (regaty, rok) references Regaty (nazwa, rok)
);
Przykład 3
ALTER TABLE nazwa_tabeli
ADD nazwa_atrybutu typ (rozmiar) [default wartość domyślna]
[ [constraint nazwa_ogr] ograniczenie_atr ];
ADD [ constraint nazwa_ogr] ograniczenie_atr;
MODIFY nazwa_atrybutu typ (rozmiar)
[default wartość domyślna][ null | not null ];
DISABLE | ENABLE unique | primary key | constraint
nazwa_ogr [cascade];
DROP unique | primary key | constraint nazwa_ogr [cascade];
Rozszerzanie i modyfikowanie
schematu tabeli
alter table dydaktycy
add etat varchar2(20);
alter table dydaktycy
add constraint dyd_etat check (etat in ('dyrektor', 'profesor', 'adiunkt',
'asystent','wykladowca',));
alter table dydaktycy
modify tytuł varchar2(8) default 'mgr' not null;
alter table dydaktycy
alter table dydaktycy
disable constraint dyd_etat;
drop constraint dyd_etat;
Przykład 4
rename stara_nazwa to nowa_nazwa;
drop table nazwa_tabeli [cascade constraint];
describe nazwa_tabeli;
Operacje na tabeli
INSERT INTO nazwa_tabeli [(kolumna, kolumna,...)]
VALUES (wartość, wartość, ...);
Wstawianie wiersza do tabeli
CREATE TABLE osoby(
id_osoby number(5) NOT NULL,
imie VARCHAR2(15),
nazwisko VARCHAR2(15),
wiek NUMBER(3),
CONSTRAINT id_pk PRIMARY KEY (id_osoby)
);
Przykład 5
INSERT INTO osoby VALUES (1, 'Adam', 'Nowak', 19);
INSERT INTO osoby VALUES (1, 'Adam', 'Nowak', 22);
INSERT INTO osoby VALUES (2, 'Iwona', 'Kowalska', 56);
INSERT INTO osoby VALUES (3, 'Lech', 'Nowakowski', 56);
INSERT INTO osoby (id_osoby, imie, nazwisko, wiek)
VALUES (4, 'Kazimierz', 'Kot', 6);
Przykład 6
INSERT INTO osoby (imie) VALUES ('Kazimierz');
INSERT INTO osoby (id_osoby,imie) VALUES (5, 'Jan');
INSERT INTO osoby (id_osoby,nazwisko)
VALUES (6, 'Niezbędny');
INSERT INTO osoby (id_osoby, wiek) VALUES (7, 41);
Przykład 7
ALTER TABLE osoby
ADD plec char(1) check (plec in ('K', 'M'));
INSERT INTO osoby VALUES(8, 'Joanna', 'Wyzwolona', 29, 'F');
INSERT INTO osoby VALUES(8, 'Joanna', 'Wyzwolona', 29, 'K');
Przykład 8
ALTER TABLE osoby
ADD data_ur date DEFAULT sysdate;
INSERT INTO osoby
VALUES(9, 'Zenon', 'Laskowik', 26, 'M', '81-APR-12');
INSERT INTO osoby
VALUES(10, 'Helena', 'Lis', 2, 'K', DEFAULT);
Przykład 9
UPDATE nazwa_tabeli
SET kolumna[,kolumna] = {wyrażenie | podzapytanie}
[WHERE warunek];
Update
DELETE FROM nazwa_tabeli [WHERE warunek];
Usuniecie wierszy spełniających warunek;
DELETE FROM osoby WHERE plec = 'K';
Usunięcie wszystkich wierszy:
DELETE FROM osoby;
DELETE
SELECT [DISTINCT] <lista kolumn/wyrażeń>
FROM <lista tablic>
[ WHERE <warunek> ]
[ GROUP BY <lista kolumn> ]
[ HAVING <warunek> ]
[ UNION/INTERSECT/MINUS <instrukcjaSELECT> ]
[ ORDER BY <lista kolumn / numerów> ];
22
• SELECT - określa, które kolumny z tablic podanych
we frazie FROM mają zostać włączone do
wyniku (projekcja). Dodatkowo, mogą
zostać włączone wyrażenia.
• DISTINCT - powoduje wyeliminowanie duplikatów
(wierszy powtarzających się).
• FROM - określa tablice, na jakich działa instrukcja
SELECT. Jeśli jest kilka tablic, dokonywany
jest produkt kartezjański tych tablic.
SELECT
23
• WHERE - określa warunki wyboru wierszy z tablic
wymienionych we frazie FROM (selekcja).
• GROUP BY - powoduje wiązanie wierszy wynikowych
w grupy o jednakowych wartościach we
wskazanych kolumnach, a następnie redukowanie
tych grup do pojedynczych wierszy.
• HAVING - określa warunki wyboru dla wierszy powstałych
w wyniku działania frazy GROUP BY.
SELECT
24
• UNION/INTERSECT/MINUS - oblicza
sumę/przecięcie/różnicę wyników dwóch instrukcji
SELECT, eliminując duplikaty.
• ORDER BY - porządkuje wiersze wynikowe rosnąco
lub malejąco według wartości wskazanych
kolumn/wyrażeń.
25
SELECT
SELECT [DISTINCT] <lista kolumn/wyrażeń>
FROM <nazwa tablicy>
[ WHERE <warunek> ];
Zapytanie proste przeprowadza kombinację projekcji i
selekcji (jeśli występuje fraza WHERE) w stosunku do
jednej tablicy.
Uwaga: <lista kolumn> może przybrać formę *
(co oznacza wybór wszystkich kolumn).
Zapytania proste
26
Wyświetlić zawartość wszystkich kolumn w tabeli
pracownik.
select * from pracownik;
27
Przykład 11
Wyświetlić wartości kolumny imie wszystkich wierszy
tabeli pracownik.
select imie from pracownik;
Wyświetlić unikalne wartości kolumny imie tabeli
pracownik.
select distinct imie from pracownik;
Przykład 12
28
literały – dowolny łańcuch znaków, data lub liczba; jest
dołączany automatycznie do każdego wyświetlanego
wiersza, zgodnie z umiejscowieniem w klauzuli
SELECT oraz do nagłówka kolumny, której
dotyczy.
Przykłady literałów: 'ala ma kota', 1234, '12.03.2011'
29
Literały w klauzuli select
Wypisać, rozdzielone napisem ' pracuje od ', nazwiska i datę
zatrudnienia wszystkich pracowników.
SELECT nazwisko, ' pracuje od ', pracuje_od
FROM pracownik;
30
Przykład 13
wyrażenia arytmetyczne - konstruowane są z nazw kolumn i
literałów numerycznych z użyciem operatorów:
●
potęgowania (^),
●
dodawania (+), odejmowania (-),
●
mnożenia (*) i dzielenia (/ ).
UWAGA: ^ ma najwyższy priorytet, * i / mają wyższy priorytet od +
i -; w przypadku operatorów o tej samej ważności wyrażenie
wartościowane jest od lewej do prawej lub za pomocą nawiasów.
Wyrażenia arytmetyczne w
klauzuli SELECT
31
Wyświetlić nazwisko oraz potrojoną wartość sumy płacy
minimalnej i maksymalnej z tabeli pracownik.
select nazwisko, (placa_min + placa_max)*3
from pracownik;
32
Przykład 14
funkcje – przekształcają wartości kolumn i literałów, do
których są stosowane.
Przykład 5: Wyświetlić nazwiska wszystkich pracowników
wraz z ich dzienną płaca podstawową, którą zaokrąglono
do 1 miejsca po przecinku.
select nawisko, round(placa_podst/31,1)
from pracownik;
Funkcje w klauzuli select
33
aliasy nazw atrybutów (kolumn) – alternatywna nazwa
kolumny, występuje bezpośrednio po nazwie kolumny.
Przykład 6
select nazwisko, (placa_min+placa_max)/2 srednia
from pracownik;
select nawisko, round(placa_podst/30,1) as dniowka
from pracownik;
Aliasy w klauzuli select
34
operator konkatenacji || (CONCAT())
umożliwia łączenie wyświetlanych wartości różnych atrybutów
w pojedyncze łańcuchy znaków.
select numer || ': ' || nazwisko || ' pracuje na etacie ' || etat from
pracownik;
select CONCAT(numer,': ',nazwisko,' pracuje na etacie ', etat)
from pracownik;
35
Operatory języka SQL występujące w wyrażeniach w klauzuli WHERE:
Operatory arytmetyczne:
^
potęgowanie,
*/
mnożenie, dzielenie,
+-
dodawanie, odejmowanie.
Operatory logiczne: NOT, AND, OR.
Operatory porównania: =, >, <, >=, <=, < > (!=).
Operatory specjalne: IN, BETWEEN, LIKE
Operatory porównania z wartością pustą: IS NULL, IS NOT NULL.
Wyrażenia
36
Funkcje agregujące:
COUNT() - zwraca liczbę wierszy wybranych w zapytaniu
AVG()
- oblicza średnią arytmetyczną w kolumnie numerycznej
SUM()
- sumuje wartości kolumn numerycznych
MIN()
- znajduje wartość minimalną w kolumnie znakowej,
numerycznej lub daty
MAX()
- znajduje wartość maksymalną w kolumnie znakowej,
numerycznej lub daty
37
Funkcje zależne od DBMS operujące na datach/godzinach, łańcuchach
znakowych, polach tekstowych, wielkich obiektach binarnych,...
Wypisać numery i nazwiska pracowników zatrudnionych na
etacie asystenta lub adiunkta.
SELECT numer, nazwisko
FROM pracownik
WHERE etat = 'asystent' OR etat = 'adiunkt';
jest równoważne
SELECT numer, nazwisko
FROM pracownik
WHERE etat in ('asystent', 'adiunkt');
Operator IN
38
Wypisać numery i nazwiska pracowników, których płaca
podstawowa mieści się w przedziale <1250, 2500>.
SELECT numer, nazwisko
FROM pracownik
WHERE placa_pod >= 1250 AND placa_pod <= 2500;
jest równoważne
SELECT numer, nazwisko
FROM pracownik
WHERE placa_pod BETWEEN 1250 AND 2500;
Operator BETWEEN...AND...
39
Porównuje zawartość kolumny znakowej z łańcuchem znaków, który
może zawierać symbole wieloznaczne. Łańcuch ze znakami
wieloznacznymi to wzorzec.
Symbole wieloznaczne:
_ (podkreślenie) - pasuje do dowolnego pojedynczego znaku,
% (procent)
- pasuje do dowolnego ciągu znaków.
40
Operator LIKE
Wypisać numery i nazwiska pracowników, którzy zatrudnieni
są na etacie zawierającym na 3 miejscu literkę d lub ich
nazwisko zawiera literę a na dowolnym miejscu.
SELECT numer, nazwisko
FROM pracownik
WHERE etat LIKE '__d%' OR nazwisko LIKE '%a%';
41
Operator LIKE
SELECT numer, nazwisko
FROM pracownik
WHERE upper(etat) LIKE upper('__d%') OR
lower(nazwisko) LIKE lower('%a%');
42
Operator LIKE (cd.)
1. COUNT(*) – zwraca liczbę wierszy w tablicy wynikowej
2. COUNT(DISTINCT <nazwa kolumny>) – zwraca liczbę
różnych wartości we wskazanej kolumnie.
43
Funkcje agregujące COUNT()
1. Na ilu różnych etatach zostali zatrudnieni pracownicy?
SELECT COUNT(DISTINCT etat)
FROM pracownik;
2. Ilu pracowników zatrudnionych jest na etacie profesora?
SELECT COUNT(*)
FROM pracownik
WHERE upper(etat) = upper('profesor');
Przykład 15
44
SUM([DISTINCT] <nazwa kolumny>)
MIN([DISTINCT] <nazwa kolumny>)
MAX([DISTINCT] <nazwa kolumny>)
AVG([DISTINCT] <nazwa kolumny>)
Zwracają odpowiednio: sumę, minimum, maksimum i średnią z wartości
podanej kolumny. Dla SUM() i AVG(), kolumna musi być numeryczna,
dla MIN() i MAX() kolumna może być też kolumną znakową lub daty.
Funkcje agregujące (cd.)
45
Podaj sumę, najmniejszą, największą i średnią płac podstawowych
pracowników zatrudnionych na etacie profesora.
SELECT SUM(placa_pod) SUMA, MIN(placa_pod) MIN,
MAX(placa_pod) MAX, AVG(placa_pod) SR
FROM pracownik
WHERE upper(etat) = upper('profesor');
46
Przykład 16
Bez frazy ORDER BY wyniki zapytania ukazują się w porządku
nieokreślonym (zwykle w porządku wstawienia ich do tablicy)
ORDER BY [[,]<nazwa kolumny/numer> [ASC/DESC]]
Uwagi:
1. Numer kolumny we frazie ORDER BY oznacza pozycję
kolumny na liście wyboru instrukcji SELECT. Trzeba go użyć, jeśli
porządkujemy wg wartości wyrażenia.
2. Domyślnie przyjmowany jest porządek rosnący (ASC).
47
Porządkowanie wyników
Wypisać numery i nazwiska pracowników zatrudnionych po
'1.01.2011' w malejącym porządku nazwisk.
SELECT numer, nazwisko
FROM pracownik
WHERE pracuje_od > '1.01.2011'
ORDER BY nazwisko DESC;
lub równoważnie
ORDER BY 2 DESC;
Przykład 17
48
Jeśli fraza FROM zawiera więcej niż jedną tablicę, instrukcja
SELECT wykonuje produkt kartezjański wskazanych tablic.
Jeśli dodatkowo występuje fraza WHERE, wykonywana jest
operacja relacyjnego złączenia (złączenie naturalne oparte na
równości klucza głównego jednej tabeli i odpowiadającego mu
klucza obcego drugiej tabeli).
49
SELECT - złączenia
Wypisać numery, nazwiska i nazwy zespołów pracowników
zatrudnionych na etacie adiunkta.
SELECT numer, nazwisko, nazwa
FROM pracownik, zespol
WHERE pracownik.id_zesp = zespol.id_zesp AND
lower(etat) = lower('adiunkt');
50
Przykład 18
Wypisać numery, nazwiska i nazwy zespołów pracowników
zatrudnionych na etacie adiunkta.
SELECT p.numer, p.nazwisko, z.nazwa
FROM pracownik p, zespol z
WHERE p.id_zesp = z.id_zesp AND
lower(etat) = lower('adiunkt');
Uwaga: p i z są aliasami tablic. W tym przykładzie służą tylko do
skrócenia zapisu.
Przykład 18 (wersja 2)
51
Złączenie tablicy z tą samą tablicą nazywamy samozłączeniem.
Samozłączenie umożliwia wiązanie ze sobą informacji zawartych
w różnych wierszach jednej tablicy. Do dokonania samozłączenia
konieczne jest zastosowanie aliasów (nazw korelacji).
52
SELECT – złączenie (cd.)
Dla każdego pracownika pokaż listę pracowników, którzy są jego
podwładnymi. Wynik uporządkuj rosnąco alfabetycznie wg nazwisk
szefów, a potem malejąco wg nazwisk podwładnych.
SELECT Szef.nazwisko, Szef.numer, 'jest szefem dla',
Podwladny.nazwisko, Podwladny.numer
FROM pracownik Podwladny, pracownik Szef
WHERE Podwladny.szef = Szef.numer
ORDER BY 1, 4 DESC;
53
Przykład 19
GROUP BY <nazwa kolumny>[, <nazwa kolumny> …]
[HAVING <warunek>]
Fraza ta powoduje powiązanie ze sobą wierszy wynikowych z instrukcji SELECT
w grupy wierszy, w których wskazane we frazie GROUP BY kolumny mają tę samą
wartość. Następnie każda grupa jest redukowana do pojedynczego wiersza. W tym
wierszu występują kolumny z frazy GROUP BY oraz ew. kolumny będące wynikiem
funkcji agregujących. Funkcje te wówczas działają na każdej grupie osobno. Następnie
eliminowane są wiersze nie spełniające warunku HAVING.
GRUPOWANIE
54
Uwaga 1. Każda kolumna występująca we frazie
GROUP BY musi wystąpić na liście wyboru
instrukcji SELECT.
Uwaga 2. W warunku HAVING może wystąpić funkcja
agregująca (ale nie w warunku WHERE!).
55
GRUPOWANIE
Pokazać ilu podwładnych ma pod sobą każdy szef. Wyniki
uporządkować malejąco według numerów szefów.
SELECT szef, COUNT(*)
FROM pracownik
GROUP BY szef;
56
Przykład 20
Dla każdego etatu oblicz średnią płacę podstawową. Pokaż tylko te
etaty, dla których ta średnia przekracza 1500. Wynik uporządkuj
malejąco wg średniej.
SELECT etat, AVG(placa_pod)
FROM pracownik
GROUP BY etat
HAVING AVG(placa_pod) > 1500
ORDER BY 2 DESC;
57
Przykład 21
Dla każdego etatu, zawierającego literkę 'd' na dowolnym miejscu,
oblicz średnią płacę podstawową. Pokaż tylko te etaty, dla których
ta średnia przekracza 1500. Wynik uporządkuj malejąco wg
średniej.
SELECT etat, AVG(placa_pod)
FROM pracownik
WHERE upper(etat) LIKE upper('%d%')
GROUP BY etat
HAVING AVG(placa_pod) > 1500
ORDER BY 2 DESC;
Przykład 22
58
<instrukcja SELECT>
UNION / INTERSECT / MINUS [ALL]
<instrukcja SELECT>
Cel: Realizacja operacji algebry relacji UNION/INTERSECT/MINUS w
stosunku do tablic będących wynikiem dwóch lub więcej instrukcji SELECT.
Tablice muszą być zgodne.
59
Operacje na tablicach
Uwagi:
1. Z tablicy wynikowej usuwane są wiersze powtarzające się (duplikaty),
chyba że występuje ALL.
2. Jeśli nazwy kolumn sumowanych, przecięcia lub różnicy tablic są
różne, tablica wynikowa przyjmuje nazwy kolumn z pierwszej tablicy.
3. Jeśli po UNION / INTERSECT / MINUS występuje fraza ORDER BY,
muszą w niej występować numery, a nie nazwy kolumn.
60
Operacje na tablicach (cd.)
Wypisz w porządku alfabetycznym nazwy zespołów, które nie
zatrudniają pracowników.
SELECT nazwa
FROM zespol
MINUS
SELECT distinct nazwa
FROM zespol z, pracownik p
WHERE z.id_zesp = p.id_zesp
61
ORDER BY 1;
Przykład 23
W złączeniu wewnętrznym w wyniku zwracane są zawsze wiersze
z obu tablic (lewej i prawej). Wiersze w jednej tablicy, które nie
mają swoich odpowiedników w drugiej tablicy, są odrzucane.
W dowolnym złączeniu zewnętrznym zwracane są wszystkie wiersze
zwracane przez odpowiednie złączenie wewnętrzne.
62
Złączenia zewnętrzne
lewe złączenie zewnętrzne – Dla każdego wiersza wybranego z
lewej tablicy, dla którego nie istnieje odpowiedni wiersz w prawej
tablicy, zamiast wiersza z prawej tablicy zwracany jest wiersz
złożony z wartości pustych. Innymi słowy: Zwracane są wszystkie
wiersze z lewej tablicy, nawet te, do których nie pasują żadne
wiersze z prawej tablicy.
63
Złączenia zewnętrzne (cd.)
Zespol
------------id_zesp
------------10
20
100
30
-------------
Pracownik
--------------------------------------------numer
|
id_zesp
--------------------------------------------1020
|
10
1010
|
20
1030
|
10
--------------------------------------------Wynik
--------------------------------------------------------------id_zesp
|
numer
|
id_zesp
--------------------------------------------------------------10
|
1020
|
10
10
|
1030
|
10
20
|
1010
|
20
100
|
?
|`
?
30
|
?
|
?
---------------------------------------------------------------
SQL:
SELECT *
FROM Zespol z LEFT JOIN Pracownik p ON z.id_zesp = p.id_zesp;
Przykład 24 (lewego złączenia zewnętrznego)
64
prawe złączenie zewnętrzne – Dla każdego wiersza wybranego z
prawej tablicy, dla którego nie istnieje odpowiedni wiersz w lewej
tablicy, zamiast wiersza z lewej tablicy zwracany jest wiersz
złożony z wartości pustych. Innymi słowy: Zwracane są wszystkie
wiersze z prawej tablicy, nawet te, do których nie pasują żadne
wiersze z lewej tablicy.
65
Złączenia zewnętrzne (cd.)
Pracownik
--------------------------------------------numer
|
etat
--------------------------------------------1020
|
adiunkt
1010
|
profesor
1030
|
dyrektor
1100
|
profesor
---------------------------------------------
Etat
------------------------nazwa
------------------------adiunkt
profesor
dyrektor
sekretarka
asystent
-------------------------
Wynik
--------------------------------------------------------------numer
|
etat
|
nazwa
--------------------------------------------------------------1020
|
adiunkt |
adiunkt
1010
|
profesor |
profesor
1030
|
dyrektor |
dyrektor
1100
|`
profesor |
profesor
?
|
?
|
sekretarka
?
|
?
|
asystent
---------------------------------------------------------------
SQL:
SELECT *
FROM Pracownik RIGHT JOIN Etat ON etat = nazwa;
Przykład 25 (prawego złączenia zewnętrznego)
66
pełne złączenie zewnętrzne – Zwraca wyniki lewego i prawego
złączenia zewnętrznego (czyli wynik operacji UNION dla wyników
lewego i prawego złączenia zewnętrznego).
Uwaga
1. DBMS może wprowadzać różne ograniczenia dotyczące złączeń
zewnętrznych. Szczegóły – w dokumentacji konkretnego DBMS.
2. Złączenia zewnętrzne nie są przemienne!
67
Złączenia zewnętrzne (cd.)
select …
from …
connect by prior …
start with …
order by …
Zapytanie hierarchiczne
Klauzula connect by określa sposób łączenia wierszy
relacji w drzewo. Na ogół występują po niej dwie
kolumny,
których
identyczność,
a
dokładniej
równość wartości w dwóch różnych wierszach,
powoduje, że wiersze te łączy bezpośrednia krawędź
konstruowanego drzewa.
connect by prior ...
Słowo kluczowe prior:
●
występuje przy jednej z dwu kolumn klauzuli connect by;
●
precyzuje sposób konstrukcji drzewa – kolumna, przy której
występuje jest uważana za nadrzędną;
●
w konstrukcji drzewa najpierw jest pobierana wartość kolumny
nadrzędnej, a następnie odszukiwane są wszystkie te wiersze,
dla których wartość tę przyjmuje również kolumna podrzędna;
●
w tworzonym drzewie wiersze te będą dziećmi wiersza,
z którego pobrano wartość atrybutu nadrzędnego.
connect by prior ...
●
W celu utworzenia drzewa wierszy jest konieczne
wskazanie jego korzenia – klauzula start with.
Po niej występuje warunek selekcjonujący wiersz, od
●
którego rozpocznie się proces konstrukcji drzewa.
start with ...
Tworzymy drzewo wierszy relacji pracownik, którego korzeniem
jest wiersz o pustej wartości atrybutu szef (klauzula start with), a
więc
wiersz
reprezentujący
pracownika
nie
posiadającego
przełożonego. Z wiersza pobierana jest wartość kolumny numer
(pracownika). Następnie są odszukiwane wszystkie wiersze-dzieci,
które spełniają warunek podany w klauzuli connect by. Proces ten
jest kontynuowany rekurencyjnie, aż do momentu utworzenia
pełnego drzewa. Na koniec wiersze drzewa są porządkowane
kolejno według kolumny id_zesp i pseudokolumny level.
Przykład 24
select lpad(' - ',3*(level-1)) || ' ' || nazwisko || ' ' || etat as
Drzewo
from pracownik
connect by prior numer = szef
start with szef IS NULL
order by id_zesp, level;
Przykład 24
Przykład 24 - wyniki
Najpierw zostanie odrzucony wiersz(-e) nie
●
spełniający warunku klauzuli where.
Następnie zostanie utworzone drzewo
●
odwzorowujące zależności służbowe, z
pominięciem poddrzewa wiersza nie spełniającego
warunku podanego po operatorze and w klauzuli
connect by.
Przykład 25
select id_zesp,numer,nazwisko
from pracownik
where nazwisko !='RAJSKI'
connect by prior numer=szef and
nazwisko !='PODGAJNY'
start with szef is null
order by id_zesp;
Przykład 25
By wygenerować ciąg liczb np. od 1 do 10 w
SQL można użyć hierarchicznego (CONNECT
BY) zapytania do wewnętrznej tablicy DUAL:
select rownum n
from dual
connect by level <= 10;
Przykład 26
Dual jest tablicą automatycznie tworzoną przez bazę
Oracle. Znajduje się w schemacie użytkownika SYS, ale
jest dostępna dla wszystkim użytkowników pod nazwą
DUAL. Zbudowana jest z jednej kolumny DUMMY
zdefiniowanej jako VARCHAR(1) i zawiera jeden
wiersz o wartości X. Tablica DUAL jest bardzo
przydatna w przypadku obliczeń stałych wartości.
Zawsze zwraca jeden wiersz.
DUAL
Dla dat:
select trunc(sysdate)+rownum-1 n
from dual
connect by level <= 10;
Przykład 27
I znaków:
select chr(ascii('A')+rownum-1) n
from dual
connect by level <= 10;
Przykład 28
select kol_A_1, kol_A_2,...
from relacja_A
where kol operator (
select kol_B_1, kol_B_2,...
from relacja_B
where warunek
);
Zagnieżdżanie zapytań
Tryb nieskorelowany
- porównania, np. =, >=, <;
- in;
- all – powoduje porównanie pojedynczej wartości z każdą
wartością wyznaczoną przez podzapytanie. Warunek selekcji
zapytania
zewnętrznego
jest
spełniony,
jeżeli
wszystkie
wartości listy spełniają ten warunek.
- any – powoduje porównanie pojedynczej wartości
(umieszczonej po jego lewej stronie) z każdą wartością
wyznaczoną przez podzapytanie. Warunek selekcji zapytania
zewnętrznego
jest
spełniony,
jeżeli
lista
wartości
wyznaczonych przez podzapytanie zawiera choć jeden element
spełniający ten warunek.
Operatory
- porównania, np. =, >=, <;
- in;
- all – powoduje porównanie pojedynczej wartości z każdą
wartością wyznaczoną przez podzapytanie. Warunek selekcji
zapytania
zewnętrznego
jest
spełniony,
jeżeli
wszystkie
wartości listy spełniają ten warunek.
- any – powoduje porównanie pojedynczej wartości
(umieszczonej po jego lewej stronie) z każdą wartością
wyznaczoną przez podzapytanie. Warunek selekcji zapytania
zewnętrznego
jest
spełniony,
jeżeli
lista
wartości
wyznaczonych przez podzapytanie zawiera choć jeden element
spełniający ten warunek.
Operatory
Liczba wartości wyznaczonych przez podzapytanie oraz ich typ
muszą być zgodne z liczbą i typem kolumn użytych
w warunku selekcji zapytania zewnętrznego.
UWAGA
select *
from ksiazka
where cena = (
select min(cena)
from ksiazka
);
Przykład 29
select id_ksiazki, cena
from ksiazka
where dziedzina = (
select dziedzina
from ksiazka
where autor = 7
);
Przykład 30
select *
from ksiazka
where (cena,autor) in (
select min(cena),autor
from ksiazka
group by autor
);
Przykład 31
select A.autor, count(*) B
from ( select autor
from ksiazka
where dziedzina between 1 and 3) A
group by A.autor
having B >= 2;
Przykład 32
●
●
●
Najpierw wykonywane jest zapytanie zewnętrzne, a dopiero
potem podzapytanie z nim skorelowane.
Podzapytanie wykonane zostaje dla każdego wiersza
przeglądanego przez zapytanie zewnętrzne.
W zapytaniu skorelowanym konieczne jest zastosowanie
aliasów relacji, na których operuje zapytanie zewnętrzne i
odwoływanie się do nich w podzapytaniu.
Zapytania zagnieżdżone
Tryb skorelowany
exists – sprawdza, czy podzapytanie
zwraca wartość.
not exists – sprawdza, czy podzapytanie
nie wyznacza żadnej wartości.
Tryb skorelowany - operatory
select id_ksiazki, cena, autor
from ksiazka p
where cena
> (
select avg(cena)
from ksiazka
where autor = p.autor
);
Przykład 33
select id_ksiazki, tytul, autor
from ksiazka p
where not exists (
select autor
from ksiazka
where autor = p.autor and
id_ksiazki != p.id_ksiazki)
order by 1;
Przykład 34
-
Podzapytania nieskorelowane są zawsze
wykonywane w kolejności od najbardziej
zagnieżdżonego do najbardziej zewnętrznego.
- Każde podzapytanie ograniczamy nawiasami
( ) i zagnieżdżamy po prawej stronie
warunku zapytania zewnętrznego (zapytania
umieszczonego
o
jeden
poziom
wyżej
w
strukturze zagłębienia).
Zagnieżdżanie wielopoziomowe
- liczba oraz typ kolumn występujących w klauzuli
select podzapytania musi być zgodna z liczbą i typem
kolumn użytych w warunku zapytania zewnętrznego
(zapytania wyższego poziomu zagnieżdżenia);
- w podzapytaniach nie używamy klauzuli order by;
- klauzula order by może wystąpić wyłącznie jako
ostatnia klauzula najbardziej zewnętrznego zapytania;
- w podzapytaniu można używać operatorów zbiorowych;
w warunkach zapytań zewnętrznych, poza operatorami
any i all, można stosować dowolne operatory języka
SQL*PLus.
Zagnieżdżanie wielopoziomowe
select id_ksiazki, tytul, autor, dziedzina, cena
from ksiazka
where cena > (
select min(cena)
from ksiazka
where autor in (
select id_autora
from autor
where imie like '%a%'
)
);
Przykład 35
Podzapytania mogą być zagnieżdżane w klauzuli having w celu
odrzucenia (przyjęcia) określonych grup krotek w zależności od
wyniku podzapytania.
UWAGA
- Jest swego rodzaju „oknem”, przez które odczytujemy lub
modyfikujemy dane z tabeli lub zbioru tabel, na których
została zdefiniowana.
- Ogranicza zakres dostępnych danych do kolumn i
wierszy określonych w definicji perspektywy;
- Jest definiowana na bazie w co najmniej jednej tabeli lub
innej perspektywy;
- Jest pamiętana w systemie wyłącznie w postaci swojej
definicji.
PERSPEKTYWA
Perspektywa nie ma własnych danych – każdorazowe
odwołanie się do niej powoduje konieczność zastosowania jej
definicji.
Perspektywy stosuje się w celu:
●
ograniczenia dostępu do tabeli bazy danych;
●
uproszczenia
zapytań
w
stosunku
kierowanych bezpośrednio do tabeli.
PERSPEKTYWY
do
zapytań
Udostępnia dane z pojedynczej tabeli, a w jej
definicji nie stosuje się operacji na zbiorach, funkcji
ani też grupowania wierszy. Przez perspektywę
prostą można pobierać i modyfikować dane.
Perspektywa prosta
Udostępnia dane wielu tabel oraz operacje na zbiorach, łączenie
tabel, funkcje i grupowanie wierszy.
Jeżeli ciało polecenia select wykorzystuje:
●
operatory zbiorowe,
●
funkcje,
●
klauzule group by, connect by, start with,
●
operator distinct,
to do perspektywy można kierować tylko polecenie select
Perspektywa złożona
Perspektywa złożona bazująca na wielu tabelach i
wykorzystująca operacje połączenia umożliwia w ograniczonym
zakresie wstawianie, modyfikowanie i usuwanie danych.
Polecenie jest możliwe tylko wówczas, gdy dotyczy ono danych
znajdujących się tylko w jednej tabeli.
Wstawianie wierszy do tabeli bazowej jest możliwe tylko wtedy,
gdy perspektywa umożliwia dostęp do wszystkich obowiązkowych
kolumn tabeli bazowej.
UWAGA
Create [or replace] view nazwa_perspektywy [(atr1, atr2, ...)]
as
select ciało_polecenia_select
[with check option];
Klauzula with check option uniemożliwia wstawianie i
modyfikowanie wierszy w sposób niezgodny z warunkami selekcji
perspektywy.
Tworzenie perspektywy
create or replace view programowanie as
select id_ksiazki, autor
from ksiazka
where dziedzina = 4 ;
select * from programowanie;
Przykład 36
create view
cena_dziedzina(nazwa, cena_min, cena_max, cena_avg)
as
select nazwa, min(cena), max(cena), avg(cena)
from ksiazka, dziedzina
where ksiazka.dziedzina = dziedzina.id_dziedziny
group by nazwa;
Przykład 37