PROJEKTOWANIE BAZ DANYCH

Uniwersytet Przyrodniczy w Poznaniu - Instytut Inżynierii Biosystemów - Zakład Informatyki Stosowanej PROJEKTOWANIE BAZ DANYCH Ćwiczenia T-SQL - SQL Server 2008 / 2012 Prowadzący: dr inż. Radosław J. Kozłowski email: rjk@up.poznan.pl www: http://www.up.poznan.pl/~rjk

Logowanie do serwera baz danych SQL Server 2008/2012. 1. Otwieramy aplikację SQL Management Studio. 2. Wybieramy typ serwera: Database Engine 3. Wpisujemy adres serwera: 150.254.152.XXX 4. Wybieramy typ uwierzytelniania: SQL Server Authentication 5. Wpisujemy nazwę użytkownika oraz hasło: student/student 2

Tworzenie i usuwanie bazy danych (niezbędne prawa administratora) Polecenie CREATE DATABASE służy do utworzenie nowej bazy danych. CREATE DATABASE student; Bazę danych możemy usunąć wydając polecenie: DROP DATABASE student; Bazę można też utworzyć podając parametry dotyczące pliku bazy: CREATE DATABASE Studenci ON ( NAME = Studenci_dat, FILENAME = 'c:\studenci.mdf', SIZE = 10MB, MAXSIZE = 50MB, FILEGROWTH = 5MB ) LOG ON ( NAME = 'studenci_log', FILENAME = 'c:\studenci.ldf', SIZE = 5MB, MAXSIZE = 25MB, FILEGROWTH = 5MB ) 3

Wyświetlanie dostępnych dla danego użytkownika baz danych SELECT * FROM sys.databases; EXEC sp_msforeachdb 'PRINT ''?'''; 4

Podłączenie do istniejącej bazy Aby możliwe było zarządzanie tabelami (tworzenie, edycja, aktualizacja danych itp.) musimy najpierw podłączyć się do wybranej (z dostępnych dla danego użytkownika) bazy danych. USE student; 5

Przeglądanie dostępnych tabel SELECT * FROM student.information_schema.tables; SELECT * FROM master.information_schema.tables; SELECT * FROM student..sysobjects WHERE xtype = 'U'; 6

Tworzenie tabel CREATE TABLE CREATE TABLE table_name ( column_name data_type [ ( size ) ] [ NULL NOT NULL ] [, column2_name data_type [ ( size ) ] [ NULL NOT NULL ] [,... ] ] [, CONSTRAINT multifieldindex [,... ] ] ) table_name: Parametr definiujący nazwę tworzonej tabeli. column_name: Parametry definiujące nazwy dodawanych kolumn. data_type: Parametr defiuniujący typ danych dla danej kolumny NULL NOT NULL Ograniczenie określające czy dane pole musi bądź nie zawierać jakąś wartość CONSTRAINT multifieldindex Definiuje dalsze ograniczenia związane z danymi umieszczonymi w tabeli. 7

Tworzenie tabel CREATE TABLE Projektowanie baz danych CREATE TABLE klient ( imie VARCHAR(35), nazwisko VARCHAR(35), telefon DECIMAL(10,0), email CHAR(30), kid INT NOT NULL IDENTITY(1,1), PRIMARY KEY (kid) ); Proszę nadać tabeli nazwę składającą się z dwóch członów - słowa klient i po 'podkreślniku' inicjałów autora, autorów np. dla Jana Kowalskiego klient_jk parametr definiujący autonumerację Usuwanie tabel - DROP TABLE DROP TABLE klient; klauzulę dla klucza podstawowego można umieścić także bezpośrednio za nazwą kolumny. 8

Tworzenie tabel tymczasowych #nazwa_tabeli Bardzo przydatna funkcja do tworzenia tablic aktywnych tylko w czasie aktualnej sesji. Po zakończeniu sesji tablica zostaje usunięta. CREATE TABLE #klient_tymczasowy ( kid INT, nazwisko VARCHAR(35), imie VARCHAR(35) ); 9

Tworzenie kopii tabel SELECT... INTO Można do nowej tablicy przekopiować wszystkie kolumny: SELECT * INTO nowa_tablica [IN baza_zewnetrzna] FROM stara_tablica lub tylko wybrane kolumny: SELECT kolumna1, kolumna2 INTO nowa_tablica [IN baza_zwenętrzna] FROM stara_tablica Przykład: SELECT * INTO klient_staly FROM klient; 10

Podgląd struktury tabel SELECT * FROM student.information_schema.columns WHERE TABLE_NAME = 'klient'; exec sp_columns 'klient' Pozyskanie nazwa kolumny - klucza podstawowego: SELECT column_name FROM information_schema.key_column_usage WHERE TABLE_NAME = 'klient' 11

Modyfikacja tabel - ALTER TABLE, procedury Strukturę tabel już istniejących (i wypełnionych danymi) można modyfikować. Możemy dodawać lub usuwać kolumny, zmienić ich definicję, zmienić nazwę tabeli itp. ALTER TABLE table { ADD { column_name data_type [ ( size ) ] [ DEFAULT value ] { [ NULL NOT NULL ] [ { PRIMARY KEY UNIQUE } ] } { [ CONSTRAINT constraint_name ] } } ALTER COLUMN column_name { data_type [ ( size ) ] [ ( precision [, scale ] ) ] [ NULL NOT NULL ] } DROP { COLUMN column_name [ CONSTRAINT ] constraint_name } } 12

Modyfikacja tabel - ALTER TABLE, procedury Dodanie 1 kolumny ALTER TABLE klient ADD wiek INT; Dodanie kilku kolumn ALTER TABLE klient ADD wysokosc INT, koczu VARCHAR(35); Modyfikacja parametrów istniejącej kolumny / kolumn ALTER TABLE klient ALTER COLUMN koczu INT; zmiana typu danych dla kolumny koczu z VARCHAR na INT 13

Modyfikacja tabel - ALTER TABLE, procedury Usunięcie kolumny ALTER TABLE klienci DROP COLUMN wiek, COLUMN wzrost, COLUMN waga, COLUMN koczu; Zmiana nazwy kolumny EXEC sp_rename 'klient.wysokosc', 'wzrost', 'COLUMN'; Zmiana nazwy tabeli EXEC sp_rename 'klient', 'klienci'; Brak możliwości zmiany pozycji kolumny zmieniamy pozostawiając swoje inicjały np. klienci_jk 14

Ograniczenia/właściwości kolumn - klauzula CONSTRAINT CONSTRAINT można używać w połączeniu z ALTER TABLE (lub CREATE TABLE) do dodawania, wyrzucania, nakładania oraz obchodzenia ograniczeń dotyczących istniejącej tabeli. CONSTRAINT constraint_name { PRIMARY KEY UNIQUE NOT NULL REFERENCES foreign_table [ ( foreign_field1, foreign_field2 ) ] } CONSTRAINT constraint_name { PRIMARY KEY ( primary1 [, primary2 [,... ] ] ) UNIQUE ( unique1 [, unique2 [,... ] ] ) NOT NULL ( notnull1 [, notnull2 [,... ] ] ) FOREIGN KEY ( ref1 [, ref2 [,... ] ] ) REFERENCES foreign_table [ ( foreign_field1 [, foreign_field2 [,... ] ] ) ] } 15

Ograniczenia/właściwości kolumn - klauzula CONSTRAINT W poniższym przykładzie unikalne ograniczenie CONSTRAINT jest dodane do kolumny 'nazwisko' z tabeli 'klienci': ALTER TABLE klienci ADD CONSTRAINT nazwisko_unikalne UNIQUE (nazwisko) Można łatwo wyrzucać ograniczenia z tabeli, używając wyrażenia: DROP CONSTRAINT. ALTER TABLE klienci DROP CONSTRAINT nazwisko_unikalne; 16

ZADANIA (1) 1. Utwórz następujące tabele (sam zdecyduj o typach kolumn i nazwach itp.): Tabela PRACOWNICY (dodaj na końcu nazwy tabeli swoje inicjały) z następującymi kolumnami: numer pracownika, nazwisko, imię, tytuł/stopień naukowy, telefon, email, płaca, data_zatrudnienia, numer etatu, numer zakładu. Tabela ETATY (dodaj na końcu nazwy tabeli swoje inicjały) z następującymi kolumnami: numer etatu, nazwa etatu, pensum. Tabela ZAKŁADY (dodaj na końcu nazwy tabeli swoje inicjały) z następującymi kolumnami: numer zakładu, nazwa, adres, numer kierownika (odpowiada numerowi pracownika z tabeli PRACOWNICY). 2. Wprowadź ograniczenie pozwalające na zachowanie unikalnych wartości po połączeniu kolumn nazwisko i imię z tabeli PRACOWNICY.

Dodawanie rekordów - INSERT INTO Pojedynczy rekord: INSERT INTO target [(field1[, field2[,...]])] VALUES (value1[, value2 [,...]) Kilka rekordów: INSERT INTO target [IN externaldatabase] [(field1[, field2[,...]] SELECT [source.] field1[, field2[,...] FROM tableexpression INSERT INTO klienci VALUES ( 'Jan', 'Kowalski', 618666666, 'jkowal@o2.pl'); 18

Dodawanie rekordów - INSERT INTO Przy wstawianiu nowych rekordów należy pamiętać o tym, aby podać liczbę danych równą liczbie pól w tabeli. W przeciwnym wypadku otrzymamy komunikat o błędzie: INSERT INTO klienci VALUES ('Jan'); Column name or number of supplied values does not match table definition. Podobnie stanie się, jeśli będziemy próbowali wstawić więcej wartości niż jest pól w tabeli. Dodatkowo należy pamiętać o kolejności podawania danych - wartości należy wprowadzać zgodnie z kolejnością pól. Jeśli chcemy wypełnić tylko niektóre z kolumn, możemy zadeklarować pola, które mają być wypełnione wartościami. Robimy to tak jak poniżej: INSERT INTO klienci (imie, nazwisko) VALUES ('Marek', 'Nowak'); (1 row(s) affected) 19

Wstawianie rekordów - REPLACE INTO W mysql instrukcja ta zachowywała się podobnie jak INSERT z tą różnicą, że pozwalała podmienić rekord z unikalnym kluczem podstawowym na nowy. W T-SQL brak instrukcji REPLACE INTO. Można ją zastąpić stosując UPDATE po wcześniejszym sprawdzeniu czy w bazie istnieje rekord z unikalnym kluczem prywatnym, którego dane chcemy zmienić. Przykładowy kod: IF EXISTS (SELECT * FROM [tabela] WHERE Id = X) UPDATE [tabela] SET... ELSE INSERT INTO [tabela] 20

ZADANIA (2) 1. Wypełnij utworzone na poprzednich zajęciach tabele PRACOWNICY, ETATY, ZAKŁADY następującymi danymi: Tabela PRACOWNICY pid nazwisko imie tytul/stopien telefon email płaca zatrudniony eid zid 1 Wazny Feliks prof. dr hab. 8513421 brak danych 2250 1975-09-15 1 4 2 Janke Anna dr inz. 8543421 ajanke@wz.pl 1750 1990-06-01 2 1 3 Wolny Marian prof. dr hab. 8574532 mwolny@wz.pl 2250 1975-09-15 1 3 4 Tylman Jan mgr inz. 8543212 jtylman@wz.pl 1400 1982-02-01 3 5 5 Kopytko Witold prof. dr hab. 8543212 wkopytko@wz.pl 2250 1982-01-01 1 1 6 Malwa Ryszard prof. dr hab. 8574312 rmalwa@wz.pl 2250 1980-04-01 1 5 7 Remis Jolanta prof. dr hab. 8542313 jremis@wz.pl 2250 1980-06-01 1 2 8 Mikrus Witold mgr inz. 8514432 mwitold@wz.pl 900 2002-05-01 4 6 9 Nowy Marian dr inz. 8578765 mnowy@wz.pl 1750 2001-09-20 2 3 10 Sytke Adrian mgr inz. 8514532 asytke@wz.pl 1400 1990-06-01 3 4 11 Rym Agnieszka dr inż. 8543421 arym@wz.pl 1750 1975-09-15 2 2 12 Tom Marcin prof. dr hab. 8515453 mtom@wz.pl 2250 1980-09-01 1 6 Tabela ZAKŁADY zid nazwa adres kierownik 1 Informatyki Stosowanej ul. Prosta 23 5 2 Cybernetyki ul. Prosta 23 7 3 Maszynoznawstwa ul. Polna 5 3 4 Maszyn i Urzadzen Rolniczych ul. Warstwowa 13 1 5 Obslugi Technicznej ul. Polna 5 6 6 Roslin Straczkowych ul. Warstwowa 13 12 Tabela ETATY eid nazwa pensum 1 PROFESOR 210 2 ADIUNKT 240 3 ASYSTENT 240 4 DOKTORANT 90

Wybieranie rekordów - SELECT Wszystkich rekordów z tablicy: SELECT * FROM klienci; +--------+----------+-----------+-------------------+-----+ imie nazwisko telefon email kid +--------+----------+-----------+-------------------+-----+ Jan Kowalski 618666666 jkowal@o2.pl 1 Jacek Nowak 2 +--------+----------+-----------+-------------------+-----+ (2 row(s) affected) 22

Wybieranie rekordów - SELECT Wszystkich rekordów z wybranych kolumn: SELECT imie, email FROM klienci; +--------+-------------------+ imie email +--------+-------------------+ Jan jkowal@o2.pl Jacek +--------+-------------------+ (2 row(s) affected) 23

Wybieranie rekordów - operator WHERE Wszystkich rekordów z tablicy dla których pole imię ma wartość 'Jan': SELECT * FROM klienci WHERE imie = 'Jan'; +--------+----------+-----------+-------------------+-----+ imie nazwisko telefon email kid +--------+----------+-----------+-------------------+-----+ Jan Kowalski 618666666 jkowal@o2.pl 1 +--------+----------+-----------+-------------------+-----+ (1 row(s) affected) Wszystkich rekordów z wybranych kolumn dla których pole imię ma wartość 'Jan': SELECT imie, nazwisko FROM klienci WHERE imie = 'Jan'; +--------+----------+ imie nazwisko +--------+----------+ Jan Kowalski +--------+----------+ (1 row(s) affected) 24

Wybieranie rekordów - operator WHERE - ograniczenia = równe <>,!= różne < mniejsze > większe <= mniejsze lub równe >= większe lub równe SELECT * FROM klienci WHERE kid < 2; +--------+----------+-----------+-------------------+-----+ imie nazwisko telefon email kid +--------+----------+-----------+-------------------+-----+ Jan Kowalski 618666666 jkowal@o2.pl 1 +--------+----------+-----------+-------------------+-----+ (1 row(s) affected) 25

Wybieranie rekordów - operator WHERE + LIKE SELECT * FROM klienci WHERE imie LIKE '%Ja%'; +--------+----------+-----------+-------------------+-----+ imie nazwisko telefon email kid +--------+----------+-----------+-------------------+-----+ Jan Kowalski 618666666 jkowal@o2.pl 1 Jacek Nowak 2 +--------+----------+-----------+-------------------+-----+ (2 row(s) affected) Znak % oznacza dowolny ciąg znaków SELECT * FROM klienci WHERE nazwisko LIKE '%wal%'; +--------+----------+-----------+-------------------+-----+ imie nazwisko telefon email kid +--------+----------+-----------+-------------------+-----+ Jan Kowalski 618666666 jkowal@o2.pl 1 +--------+----------+-----------+-------------------+-----+ (1 row(s) affected) 26

Wybieranie rekordów - operator WHERE + LIKE SELECT * FROM klienci WHERE imie LIKE '_an'; +--------+----------+-----------+-------------------+-----+ imie nazwisko telefon email kid +--------+----------+-----------+-------------------+-----+ Jan Kowalski 618666666 jkowal@o2.pl 1 +--------+----------+-----------+-------------------+-----+ (1 row(s) affected) Znak _ oznacza dokładnie jeden znak SELECT * FROM klienci WHERE nazwisko LIKE '_owa%'; +--------+----------+-----------+-------------------+-----+ imie nazwisko telefon email kid +--------+----------+-----------+-------------------+-----+ Jan Kowalski 618666666 jkowal@o2.pl 1 Jacek Nowak 2 +--------+----------+-----------+-------------------+-----+ (2 row(s) affected) 27

Indeksy - mechanizm wspomagający wyszukiwanie Jedynym powodem tworzenia indeksów jest poprawa wydajności bazy danych. Indeksy w bazie danych pełnią funkcję zbliżoną do skorowidzów w książce. Zamiast szukać jakiegoś terminu w całej książce, znacznie szybciej i łatwiej jest znaleźć go w posortowanym alfabetycznie skorowidzu. Składnia instrukcji tworzącej indeks jest bardzo prosta: CREATE INDEX klienci_indeks ON klienci (nazwisko); Indeks można także utworzyć przy tworzeniu tablicy podając słowo kluczowe INDEX pod koniec definicji CREATE TABLE. Tak utworzony indeks możemy wykorzystać w zapytaniu: SELECT * FROM klienci WHERE nazwisko = 'Kowalski'; 28

ZADANIA (3) Wszystkie zadania należy wykonać na własnych tabelach Pracownicy, Zakłady i Etaty 1. Wyświetl wszystkie dane z tabeli pracownicy. 2. Wyświetl tylko imię, nazwisko oraz tytuł naukowy wszystkich pracowników. 3. Wyświetl pracowników począwszy od pracownika z numerem 4. 4. Pokaż wszystkich pracowników którzy mają imię rozpoczynające się od litery J. 5. Pokaż zakłady, które swoją siedzibę mają na ulicy Prostej. 6. Pokaż pracowników, których płaca przekracza 2 tyś złotych. 7. Pokaż pracowników, którzy mają numer telefonu zawierający liczbę 54. 8. Pokaż wszystkich pracowników na stanowisku adiunkta. 9. Wyświetl etaty których pensum jest różne od 240 godzin.

Wybieranie rekordów - operator konkatenacji + Operator konkatenacji + pozwala na połączenie ze sobą danych z kilku kolumn w jeden ciąg. Jest to szczególnie przydatne w tabelach, które przechowują dane personalne. SELECT imie + ' ' + nazwisko AS klient, email FROM klienci; +--------------+--------------+ klient email +--------------+--------------+ Jan Kowalski jkowal@o2.pl Jacek Nowak +--------------+--------------+ (2 row(s) affected) 30

Usuwanie rekordów - DELETE Wszystkich rekordów z tablicy: DELETE FROM klienci; Wybranych rekordów z tablicy dla których pole imię ma wartość 'Jacek': DELETE FROM klienci WHERE imie = 'Jacek'; (1 row(s) affected) 31

Modyfikacje danych - UPDATE UPDATE klienci SET telefon = 618555555 WHERE imie = 'Jan'; (1 row(s) affected) UPDATE klienci SET telefon = 618555555, email = 'jkowal@o2.pl' WHERE imie = 'Jan'; (1 row(s) affected) UPDATE klienci SET telefon = 618555555, email = 'jkowal@o2.pl' WHERE imie = 'Jan' AND nazwisko='kowalski'; (1 row(s) affected) 32

Selekcja rekordów - wyrażenia logiczne AND, OR, NOT Przygotowanie tabeli - wprowadzany klika dodatkowych rekordów INSERT INTO klienci VALUES ('Jacek', 'Nowak', 618546234, 'jnowak@o2.pl'); INSERT INTO klienci VALUES ( 'Marek', 'Wielki', 618456123, 'mwielki@o2.pl'); Tabela klienci zawiera teraz następujące rekordy: +-------+----------+-----------+---------------+-----+ imie nazwisko telefon email kid +-------+----------+-----------+---------------+-----+ Jan Kowalski 618555555 jkowal@o2.pl 1 Jacek Nowak 618546234 jnowak@o2.pl 3 Marek Wielki 618456123 mwielki@o2.pl 4 +-------+----------+-----------+---------------+-----+ 33

Selekcja rekordów - wyrażenia logiczne AND, OR, NOT AND SELECT * FROM klienci WHERE imie = 'Marek' AND nazwisko = 'Wielki'; +-------+----------+-----------+---------------+-----+ imie nazwisko telefon email kid +-------+----------+-----------+---------------+-----+ Marek Wielki 618456123 mwielki@o2.pl 4 +-------+----------+-----------+---------------+-----+ (1 row(s) affected) Operacja ta wyświetli wszystkie rekordy zawierające w polu imie wartość "Marek" i (AND) w polu nazwisko wartość "Wielki". 34

Selekcja rekordów - wyrażenia logiczne AND, OR, NOT OR SELECT * FROM klienci WHERE imie = 'Marek' OR imie = 'Jacek'; +-------+----------+-----------+---------------+-----+ imie nazwisko telefon email kid +-------+----------+-----------+---------------+-----+ Jacek Nowak 618546234 jnowak@o2.pl 3 Marek Wielki 618456123 mwielki@o2.pl 4 +-------+----------+-----------+---------------+-----+ (2 row(s) affected) 35

Selekcja rekordów - wyrażenia logiczne AND, OR, NOT NOT SELECT * FROM klienci WHERE NOT telefon = 618546234; +-------+----------+-----------+---------------+-----+ imie nazwisko telefon email kid +-------+----------+-----------+---------------+-----+ Jan Kowalski 618555555 jkowal@o2.pl 1 Marek Wielki 618456123 mwielki@o2.pl 4 +-------+----------+-----------+---------------+-----+ (2 row(s) affected) 36

ZADANIA (4) Wszystkie zadania należy wykonać na własnych tabelach Pracownicy, Zakłady i Etaty 1. Połącz imiona i nazwiska pracowników w jeden łańcuch oraz wyświetl pracowników, numer telefonu oraz email. 2. Uaktualnij email dla pracownika Ważny Feliks - fwazny@wz.pl. 3. Wyświetl pracowników, którzy mają na imię Witold i nazwisko Mikrus. 4. Wyświetl pracowników, którzy mają na imię Witold lub nazwisko Mikrus. 5. Wyświetl pracowników z imieniem Witold oraz Ryszard. 6. Wyświetl zakłady, które swoją siedzibę mają na ulicy Prostej oraz Polnej. 7. Wyświetl pracowników, którzy nie są profesorami. 8. Wyświetl pracowników zakładu Informatyki Stosowanej lub Obsługi Technicznej. 9. Wyświetl pracowników których pensja nie jest równa 2250 i pracują w zakładzie Maszynoznawstwa.

Selekcja rekordów - grupowanie tych samych wyrażeń logicznych - IN Zamiast podawać kilku wyrażeń logicznych: SELECT * FROM klienci WHERE kid=1 OR kid=2 OR kid=3; Można posłużyć się słowem kluczowym IN: SELECT * FROM klienci WHERE kid IN (1,2,3); +-------+----------+-----------+---------------+-----+ imie nazwisko telefon email kid +-------+----------+-----------+---------------+-----+ Jan Kowalski 618555555 jkowal@o2.pl 1 Jacek Nowak 618546234 jnowak@o2.pl 3 +-------+----------+-----------+---------------+-----+ 38

Selekcja rekordów - określenie zakresu - BETWEEN Zamiast stosowania operatorów : SELECT * FROM klienci WHERE kid >= 2 AND kid <= 4; Można wykorzystać możliwości BETWEEN: SELECT * FROM klienci WHERE kid BETWEEN 2 AND 4; +-------+----------+-----------+---------------+-----+ imie nazwisko telefon email kid +-------+----------+-----------+---------------+-----+ Jacek Nowak 618546234 jnowak@o2.pl 3 Marek Wielki 618456123 mwielki@o2.pl 4 +-------+----------+-----------+---------------+-----+ 39

Selekcja rekordów - pomijanie duplikatów - DISTINCT Dodamy sobie do bazy drugą osobę z imieniem Jan. INSERT INTO klienci VALUES ('Jan', 'Malwa', 618453124, 'jmalwa@o2.pl'); SELECT imie FROM klienci; SELECT DISTINCT imie FROM klienci; +-------+ imie +-------+ Jan Jacek Marek +-------+ Pokazuje tylko unikalne rekordy +-------+ imie +-------+ Jan Jacek Marek Jan +-------+ 40

Sortowanie rekordów ORDER BY SELECT * FROM klienci ORDER BY imie; +-------+----------+-----------+---------------+-----+ imie nazwisko telefon email kid +-------+----------+-----------+---------------+-----+ Jacek Nowak 618546234 jnowak@o2.pl 3 Jan Kowalski 618555555 jkowal@o2.pl 1 Jan Malwa 618456124 jmalwa@o2.pl 5 Marek Wielki 618456123 mwielki@o2.pl 4 +-------+----------+-----------+---------------+-----+ SELECT * FROM klienci ORDER BY imie, telefon; +-------+----------+-----------+---------------+-----+ imie nazwisko telefon email kid +-------+----------+-----------+---------------+-----+ Jacek Nowak 618546234 jnowak@o2.pl 3 Jan Kowalski 618555555 jkowal@o2.pl 1 Jan Malwa 618456124 jmalwa@o2.pl 5 Marek Wielki 618456123 mwielki@o2.pl 4 +-------+----------+-----------+---------------+-----+ 41

Sortowanie danych ORDER BY - ASC A->Z sortowanie rosnące SELECT * FROM klienci ORDER BY nazwisko ASC; +-------+----------+-----------+---------------+-----+ imie nazwisko telefon email kid +-------+----------+-----------+---------------+-----+ Jan Kowalski 618555555 jkowal@o2.pl 1 Jan Malwa 618456124 jmalwa@o2.pl 5 Jacek Nowak 618546234 jnowak@o2.pl 3 Marek Wielki 618456123 mwielki@o2.pl 4 +-------+----------+-----------+---------------+-----+ 42

Sortowanie danych ORDER BY - DESC Z->A sortowanie malejące SELECT * FROM klienci ORDER BY nazwisko DESC; +-------+----------+-----------+---------------+-----+ imie nazwisko telefon email kid +-------+----------+-----------+---------------+-----+ Marek Wielki 618456123 mwielki@o2.pl 4 Jacek Nowak 618546234 jnowak@o2.pl 3 Jan Malwa 618456124 jmalwa@o2.pl 5 Jan Kowalski 618555555 jkowal@o2.pl 1 +-------+----------+-----------+---------------+-----+ 43

Ograniczanie liczy rekordów zwróconych przez zapytanie - TOP W mysql do wykonania tego zadania wystarczyło wykorzystać komendę LIMIT. Niestety brak jej na platformie SQL Server. Istnieje jednak możliwość uzyskania podobnych jednak ograniczonych efektów z wykorzystaniem słowa kluczowego TOP. Poniższe zapytanie zwraca dokładnie dwa pierwsze rekordy: SELECT TOP 2 * FROM klienci; +-------+----------+-----------+---------------+-----+ imie nazwisko telefon email kid +-------+----------+-----------+---------------+-----+ Jan Kowalski 618555555 jkowal@o2.pl 1 Jacek Nowak 618546234 jnowak@o2.pl 3 +-------+----------+-----------+---------------+-----+ Niestety brak możliwości określenia innego rekordu startowego, od którego chcemy rozpocząć ograniczanie liczby wierszy. 44

Ograniczanie liczy rekordów zwróconych przez zapytanie - TOP Jeżeli chcemy pobrać dwa rekordy rozpoczynając od drugiego rekordu możemy posłużyć dość złożoną sztuczką: mysql> SELECT * FROM klienci LIMIT (1,2) select * from ( select top 2 * from ( select top 3 * from klienci order by kid asc ) as A order by kid desc ) as B order by kid asc WITH temp AS ( SELECT *, ROW_NUMBER() OVER (ORDER BY kid) AS wiersz FROM klienci) SELECT * FROM temp WHERE wiersz BETWEEN 2 AND 3 45

Połączenie funkcji - Sortowanie + limitowanie SELECT TOP 2 * FROM klienci ORDER BY nazwisko ASC; +-------+----------+-----------+---------------+-----+ imie nazwisko telefon email kid +-------+----------+-----------+---------------+-----+ Jan Kowalski 618555555 jkowal@o2.pl 1 Jan Malwa 618453124 jmalwa@o2.pl 5 +-------+----------+-----------+---------------+-----+ 46

Funkcje obsługi łańcuchów Określenie liczby znaków w komórce - LEN() SELECT LEN(nazwisko) FROM klienci; +----------------+ No column name +----------------+ 8 5 5 6 +----------------+ 47

ZADANIA (5) Wszystkie zadania należy wykonać na własnych tabelach Pracownicy, Zakłady i Etaty 1. Wykorzystując funkcję grupującą wyświetl pracowników z zakładu 2,4 i 6. 2. Wyświetl pracowników, których płaca mieści się w przedziale od 1 do 2 tyś złotych. 3. Wyświetl listę adresową zakładów, pomiń powtarzające się dane. 4. Posortuj pracowników rosnąco i malejąco względem płacy. 5. Wyświetl tylko 3 pierwsze zakłady. 6. Wyświetl 2 pracowników począwszy od pracownika z numerem 4. 7. Oblicz liczbę znaków dla danych o pracownikach zapisanych w kolumnie nazwisko. 8. Wyświetl listę pracowników (posortowaną rosnąco wg nazwiska) wprowadzając następujące ograniczenia: - maksymalna liczba rekordów 4, - maksymalna płaca pracownika 2 tyś złotych, - miejsce pracy: zakład mieszczący się na ulicy Prostej, - zatrudniony po 1980 roku.

Filtrowanie, wyszukiwanie danych spełniających kryteria zadanego wzorca Język T-SQL nie oferuje natywnej obsługi wyrażeń regularnych. Jedynie możemy symulować ich możliwości poprzez zastosowanie LIKE lub PATINDEX. Niestety możliwości ich są bardzo ograniczone. SELECT nazwisko FROM klienci WHERE nazwisko LIKE '%owa%'; +----------+ nazwisko +----------+ Kowalski Nowak +----------+ 2 rows in set SELECT nazwisko FROM klienci WHERE PATINDEX('%owa%', nazwisko) > 0; 49

Filtrowanie, wyszukiwanie danych spełniających kryteria zadanego wzorca Łańcuch zawiera dwa różne znaki: SELECT nazwisko FROM klienci WHERE nazwisko LIKE '%[ok]%'; +----------+ nazwisko +----------+ Kowalski Nowak Wielki +----------+ 50

Filtrowanie, wyszukiwanie danych spełniających kryteria zadanego wzorca Łańcuch rozpoczyna się od wybranego znaku: SELECT imie FROM klienci WHERE imie LIKE 'J%' Collate Polish_CS_AS; +-------+ imie +-------+ Jan Jacek Jan +-------+ 51

Filtrowanie, wyszukiwanie danych spełniających kryteria zadanego wzorca Łańcuch zaczyna się od wskazanego znaku następnie zawiera dokładnie jeden znak i kończy się wskazanym znakiem: SELECT imie FROM klienci WHERE imie LIKE 'J_n' Collate Polish_CS_AS; +------+ imie +------+ Jan Jan +------+ 53

Filtrowanie, wyszukiwanie danych spełniających kryteria zadanego wzorca Łańcuch nie zawiera wskazanego znaku: SELECT imie FROM klienci WHERE imie NOT LIKE '%j%'; +-------+ imie +-------+ Marek +-------+ 54

ZADANIA (6) Wszystkie zadania należy wykonać na własnych tabelach Pracownicy, Zakłady i Etaty 1. Wyświetl pracowników, których nazwisko zawiera znaki 'a' lub 'i'. 2. Pokaż wszystkich pracowników których imię rozpoczynające się od litery 'M' a kończy na 'n'. 3. Wyświetl pracowników których numer telefony ma przynajmniej dwie cyfry '5'. 4. Wyświetl zakłady których nazwa ma więcej niż jedną spację. 5. Sprawdź jakie zakłady spełniają wymagania filtra, który dopuszcza wykorzystanie tylko znaków (małych i dużych) oraz cyfr. 6. Zaproponuj wyrażenie regularne sprawdzające poprawność wprowadzenia daty w tabeli z pracownikami, zakładając że elementami oddzielającymi mogą być tylko myślnik, kropka lub dwukropek. 7. Zaproponuj filtr dla kolumny z płacami pracowników. 8. Korzystając z przykładu praktycznego do sprawdzania poprawności maili sprawdź czy w tabeli pracownicy wszystkie maile wprowadzone są poprawnie.

Łączenie tabel (relacje) Na zajęciach z łączenia tabel (tworzenia relacji) wykorzystamy następujące tablice: wcześniej utworzoną tabelę z klientami np. klienci_jk, +-------+----------+-----------+---------------+-----+ imie nazwisko telefon email kid +-------+----------+-----------+---------------+-----+ Jan Kowalski 618555555 jkowal@o2.pl 1 Jacek Nowak 618546234 jnowak@o2.pl 3 Marek Wielki 618456123 mwielki@o2.pl 4 Jan Malwa 618453124 jmalwa@o2.pl 5 +-------+----------+-----------+---------------+-----+ utworzymy nową tabelę zamówień np. zamowienia_jk, nową tabelę produktów np. produkty_jk, oraz tablicę pośrednią pomiędzy zamówieniami i produktami np. zam_prod_jk. 57

Łączenie tabel (relacje) 58

Łączenie tabel (relacje) - utworzenie tabel roboczych CREATE TABLE zamowienia ( zid INT NOT NULL IDENTITY(1,1), kid INT, koszt DECIMAL(6,2), data DATE, PRIMARY KEY (zid) ); INSERT INTO zamowienia VALUES (5, 64.98, '20020210'); INSERT INTO zamowienia VALUES (5, 34.98, '20020218'); INSERT INTO zamowienia VALUES (1, 39.99, '20020219'); INSERT INTO zamowienia VALUES (3, 14.97, '20020301'); INSERT INTO zamowienia VALUES (5, 24.99, '20020304'); INSERT INTO zamowienia VALUES (4, 79.98, '20020306'); INSERT INTO zamowienia VALUES (1, 24.95, '20020312'); 59

Łączenie tabel (relacje) - utworzenie tabel roboczych CREATE TABLE produkty ( pid INT NOT NULL, cena DECIMAL(6,2), nazwa CHAR(20), PRIMARY KEY (pid) ); INSERT INTO produkty VALUES (1, 70.50, 'myszka'); INSERT INTO produkty VALUES (2, 2.90, 'szmatka'); INSERT INTO produkty VALUES (3, 11.15, 'podkladka'); INSERT INTO produkty VALUES (4, 35.60, 'klawiatura'); INSERT INTO produkty VALUES (5, 5.90, 'slizgacze'); INSERT INTO produkty VALUES (6, 8.90, 'kabel'); 60

Łączenie tabel (relacje) - utworzenie tabel roboczych CREATE TABLE zam_prod ( zid INT, pid INT, ilosc TINYINT ); INSERT INTO zam_prod VALUES (1, 3, 2); INSERT INTO zam_prod VALUES (2, 2, 1); INSERT INTO zam_prod VALUES (3, 1, 3); INSERT INTO zam_prod VALUES (4, 4, 1); INSERT INTO zam_prod VALUES (5, 1, 5); INSERT INTO zam_prod VALUES (6, 2, 2); INSERT INTO zam_prod VALUES (7, 3, 1); 61

Łączenie tabel (relacje) - podstawy W pewnych sytuacjach konieczne jest połączenie danych, zawartych w kilku tabelach, w celu uzyskania tabeli wynikowej. Proces taki nazywamy złączeniem (ang. join), ze względu na sposób łączenia dzieli się operacje złączeń na: złączenia krzyżowe, złączenia wewnętrzne, złączenia zewnętrzne, samozłączenia. Operacje łączenia tabel zawierają w trakcie ich realizacji wstępny etap utworzenia nowej tabeli, będącej iloczynem kartezjańskim wierszy z łączonych tabel. Najprostsze zapytanie, pozwalające się o tym przekonać, ma postać: SELECT * FROM tab1, tab2; 62

Łączenie tabel (relacje) - podstawy - złączenie krzyżowe W naszym przypadku najprostsze złączenie tabel dające w efekcie jedną dużą tabelę ma postać: SELECT * FROM klienci CROSS JOIN produkty; Powstała tabela będąca iloczynem kartezjańskim ma liczbę kolumn równą sumie liczby kolumn tabel źródłowych, a liczbę wierszy równą iloczynowi liczby wierszy tabel źródłowych. 63

Łączenie tabel (relacje) - podstawy Złączenie wewnętrzne Podstawowe, jak również najczęściej spotykane są złączenia wewnętrzne. Opierają się one na ograniczeniu iloczynu kartezjańskiego dwóch tabel źródłowych w oparciu o pewne relacje kolumn z tych tabel. Najczęściej pojawia się tu ograniczenie, oparte o relację pomiędzy kluczem głównym jednej z tabel, a odpowiednim kluczem obcym z drugiej tabeli. 64

Złączenie wewnętrzne cel zapytania: Pokaż datę i koszt wszystkich zamówień. SELECT klienci.nazwisko, zamowienia.data, zamowienia.koszt FROM klienci, zamowienia WHERE zamowienia.kid = klienci.kid; 65

Złączenie wewnętrzne - aliasy tabel cel zapytania: Pokaż datę i koszt wszystkich zamówień. SELECT k.nazwisko, z.data, z.koszt FROM klienci k, zamowienia z WHERE k.kid = z.kid; 66

Złączenie wewnętrzne cel zapytania: Pokaż poszczególne zamówienia, produkt oraz liczbę produktów. SELECT klienci.nazwisko, produkty.nazwa, zam_prod.ilosc FROM klienci, zamowienia, zam_prod, produkty WHERE zamowienia.kid = klienci.kid AND zam_prod.zid = zamowienia.zid AND produkty.pid = zam_prod.pid; 67

Złączenie wewnętrzne - klauzula NATURAL JOIN Złączenie wewnętrzne - klauzula USING 68

Złączenie wewnętrzne - klauzula ON cel zapytania: Pokaż datę i koszt wszystkich zamówień. SELECT klienci.nazwisko, zamowienia.data, zamowienia.koszt FROM klienci JOIN zamowienia ON klienci.kid = zamowienia.kid; 69

ZADANIA (7) Wszystkie zadania należy wykonać na własnych tabelach Pracownicy, Zakłady i Etaty Wykonaj złączenia, które odpowiedzą na poniższe pytania: 1. Kto pracuje w poszczególnych zakładach? 2. Na jakim etacie pracują poszczególni pracownicy? 3. Kto jest kierownikiem poszczególnych zakładów? 4. Ile godzin wynikających z pensum musi przepracować każdy z pracowników? 5. Kto z pracowników ma tytuł profesora i ile godzin wynikających z pensum musi przepracować? 6. Jaki jest adres pod którym można znaleźć każdego z pracowników? 7. Jaki tytuł/stopień naukowy mają kierownicy wszystkich zakładów? 8. Jaki etat zajmują kierownicy wszystkich zakładów? 9. Jaka jest data zatrudnienia pracowników na stanowisku adiunkta?

Łączenie tabel (relacje) - podstawy Złączenie zewnętrzne Drugim typem złączeń są złączenia zewnętrzne. Są one pewnego rodzaju rozszerzeniem pojęcia złączenia wewnętrznego. Podczas gdy w złączeniu wewnętrznym w tabeli wynikowej umieszczane były wiersze, spełniające pewne kryterium, w złączeniu zewnętrznym dodatkowo dodawane są wiersze z jednej z tabel (a nawet obu), które zostałyby odrzucone w złączeniu wewnętrznym, ze względu na nie spełnienie kryterium złączenia, po odpowiednim uzupełnieniu wierszy wynikowych wartościami pustymi. Złączenia zewnętrzne dzielimy na trzy kategorie: lewostronne, prawostronne, pełne. 71

Złączenie zewnętrzne - przygotowanie tabel Aby zobaczyć efekt działania złączenia zewnętrznego musimy dodać kilka nowych rekordów do naszych tabel. 1. Wstawiamy klientów którzy nic nie kupili: INSERT INTO klienci VALUES ('Robert', 'Konrad', 618431567, 'rkonrad@o2.pl'); INSERT INTO klienci VALUES ('Hubert', 'Mocny', 618561263, 'hmocny@o2.pl'); INSERT INTO klienci VALUES ('Grzegorz', 'Wolny', 618317538, 'gwolny@o2.pl'); 2. Wstawiamy zamówienia z błędami (brak przypisanych klientów): INSERT INTO zamowienia VALUES (NULL, 32.45, '20020321'); INSERT INTO zamowienia VALUES (NULL, 12.95, '20020316'); INSERT INTO zamowienia VALUES (NULL, 21.31, '20020315'); 72

Złączenie zewnętrzne lewostronne cel zapytania: Pokaż dane zamówień dla wszystkich klientów. SELECT klienci.nazwisko, zamowienia.data, zamowienia.koszt FROM klienci LEFT JOIN zamowienia ON klienci.kid = zamowienia.kid ORDER BY koszt DESC; Przy złączeniu wewnętrznym osoby te zostaną pominięte 73

Złączenie zewnętrzne prawostronne cel zapytania: Pokaż dane zamówień dla wszystkich klientów. SELECT klienci.nazwisko, zamowienia.data, zamowienia.koszt FROM klienci RIGHT JOIN zamowienia ON klienci.kid = zamowienia.kid ORDER BY nazwisko DESC; Widzimy błędy w bazie? Zamówienia nie są przypisane do żadnego z naszych klientów. 74

Złączenie wyników - operator UNION Operator UNION służy do zsumowania wierszy z dowolnej liczby tabel. Za pomocą operatora UNION możemy dodać wyniki poszczególnych zapytań (czyli zwiększyć liczbę wierszy wyniku. Złączenia JOIN zwiększały liczbę kolumn, złączenie UNION zwiększa liczbę wierszy). Łączone wyniki muszą składać się z takiej samej liczby kolumn, a poszczególne kolumny muszą być tego samego typu, poza tym konieczne jest, aby występowały one w tej samej kolejności w obu wynikach 75

Złączenie wyników - operator UNION SELECT nazwisko FROM klienci UNION SELECT nazwa FROM produkty; Operator UNION domyślnie pomija identyczne wpisy jeżeli chcemy pokazać wszystkie musimy użyć klauzuli UNION ALL. 76

ZADANIA (8) Wszystkie zadania należy wykonać na własnych tabelach Pracownicy, Zakłady i Etaty Wykonaj złączenia, które odpowiedzą na poniższe pytania: 1. Czy w bazie znajdują się pracownicy bez przypisanych zakładów? 2. Czy w bazie są osoby z niezdefionowanym pensum?

Funkcje agregujące Funkcje agregujące służą do uzyskiwania informacji statystycznych na podstawie wartości zawartych w tabelach. Funkcje agregujące występujące w języku SQL to: MIN(nazwa_kolumny) wyznacza najmniejszą wartości w kolumnie, MAX(nazwa_kolumny) wyznacza największą wartości w kolumnie, SUM(nazwa_kolumny) sumuje wartości w danej kolumnie, COUNT(nazwa_kolumny) zlicza liczbę wierszy w kolumnie, COUNT(*) - zlicza liczbę zwróconych przez zapytanie wierszy, AVG(nazwa_kolumny) oblicza średnią, VAR(nazwa_kolumny) - oblicza wariancję, STD(nazwa_kolumny) - oblicza odchylenie standardowe. 78

Funkcje agregujące - SUM cel zapytania: Ile każdy z klientów wydał na zakupy. SELECT nazwisko + SPACE(1) + imie AS klient, SUM(koszt) AS wydatki FROM klienci JOIN zamowienia ON klienci.kid = zamowienia.kid GROUP BY nazwisko, imie; Utworzenie aliasu dla powstałej kolumny 79

Funkcje agregujące - SUM + ORDER BY cel zapytania: Ile każdy z klientów wydał na zakupy. SELECT nazwisko + SPACE(1) + imie AS klient, SUM(koszt) AS wydatki FROM klienci JOIN zamowienia ON klienci.kid = zamowienia.kid GROUP BY nazwisko, imie ORDER BY wydatki DESC; 80

Funkcje agregujące - MAX + ORDER BY cel zapytania: Jakie było najdroższe zamówienie klienta. SELECT nazwisko + SPACE(1) + imie AS klient, MAX(koszt) AS najdrozsze FROM klienci JOIN zamowienia ON klienci.kid = zamowienia.kid GROUP BY nazwisko, imie ORDER BY najdrozsze DESC; 81

Funkcje agregujące - AVG + ORDER BY cel zapytania: Jaka jest średnia z zamówień danego klienta. SELECT nazwisko + SPACE(1) + imie AS klient, AVG(koszt) AS srednia FROM klienci JOIN zamowienia ON klienci.kid = zamowienia.kid GROUP BY nazwisko, imie ORDER BY srednia DESC; 82

Funkcje agregujące - COUNT + ORDER BY cel zapytania: Jaka jest liczba zamówień danego klienta. SELECT nazwisko + SPACE(1) + imie AS klient, COUNT(zID) AS lzamowien FROM klienci JOIN zamowienia ON klienci.kid = zamowienia.kid GROUP BY nazwisko, imie ORDER BY lzamowien DESC; 83

Funkcje agregujące + klauzula HAVING Dyrektywa HAVING zawsze występuje za dyrektywą GROUP BY. cel zapytania: Jaka jest liczba zamówień danego klienta uwzględniając tylko klientów, którzy mają więcej niż 2 zamówienia. SELECT nazwisko + SPACE(1) + imie AS klient, COUNT(zID) AS lzamowien FROM klienci JOIN zamowienia ON klienci.kid = zamowienia.kid GROUP BY nazwisko, imie HAVING COUNT(zID) > 1 ORDER BY lzamowien DESC; T-SQL nie pozwala na wykorzystanie w tym miejscu aliasów kolumn 84

Funkcje agregujące + klauzula WITH ROLLUP Dodaje jeden dodatkowy rekord sumujący wszystkie wyświetlone wyżej rekordy cel zapytania: Pokaż listę produktów, liczbę sprzedanych sztuk oraz sumę ich ceny. Dodatkowo pokaż sumę dwóch ostatnich kolumn. SELECT nazwa, SUM(cena) as koszt, COUNT(ilosc) as ilosc FROM zam_prod JOIN produkty ON zam_prod.pid = produkty.pid GROUP BY nazwa WITH ROLLUP; 85

ZADANIA (9) Wszystkie zadania należy wykonać na własnych tabelach Pracownicy, Zakłady i Etaty Wykonaj złączenia, które odpowiedzą na poniższe pytania: 1. Ilu pracowników ma każdy z zakładów? 2. Ile osób pracuje na poszczególnych etatach? 3. Jaka jest liczba godzin (wynikających z pensum) dla poszczególnych zakładów? 4. Który z zakładów ma najwięcej pracowników? 5. Na jakim etacie pracuje najmniej osób? 6. Ilu pracowników ma pensję powyżej 2 tyś złotych? 7. Ilu pracowników ma adres email w domenie 'wz.pl'? 8. Jak zebrać dane pozwalające na narysowanie prostego histogramu pokazującego liczbę pracowników z wybranym stopniem/tytułem naukowym?

Podzapytania Podzapytania lub zapytania zagnieżdżone to instrukcje SELECT umieszczone wewnątrz innych instrukcji SELECT. Podzapytanie może być użyte w dowolnej klauzuli w klauzuli FROM będziemy ich używać jako źródeł danych, w klauzuli SELECT jako odpowiedników zmiennych lub funkcji, w klauzuli WHERE do wybierania danych itd. Podzapytania dzielą się na: powiązane i niepowiązane, podzapytania zwracające jeden wiersz i zwracające wiele wierszy. 87

Podzapytania niepowiązane SELECT * FROM ( SELECT imie, nazwisko, email FROM klienci ) AS dane WHERE imie = 'Jan'; W kwerendzie najpierw zostało wykonane zapytanie wewnętrzne a następnie odczytane zostały wiersze spełniające warunek 88

Podzapytania powiązane - podzapytania z operatorem EXISTS, NOT EXISTS Podzapytania powiązane wykonywane są dla każdego wiersza wyniku zapytania zewnętrznego i mogą być z nim porównywane. cel zapytania: Wyświetlenie klientów którzy mają to samo imię ale różne kid, co może wskazywać np. na błędne wypełnienie bazy. SELECT kid, imie, nazwisko FROM klienci AS lista1 WHERE EXISTS ( SELECT kid FROM klienci AS lista2 WHERE lista1.imie = lista2.imie AND lista1.kid!= lista2.kid ); 89

Podzapytania zwracające jeden wiersz Podzapytania tego typu można traktować jak zwykłe wyrażenia. W szczególności podzapytania tego typu mogą być używane ze standardowymi operatorami porównań. cel zapytania: Pokaż produkty, których cena jest mniejsza od ceny średniej. SELECT nazwa, cena FROM produkty WHERE cena < ( SELECT AVG(cena) FROM produkty ); 90

Podzapytania zwracające wiele wierszy cel zapytania: Pokaż zamówienia złożone przed danego klienta. SELECT * FROM zamowienia WHERE kid = ( SELECT kid FROM klienci WHERE nazwisko = 'Kowalski' ); 91

ZADANIA (10) Wszystkie zadania należy wykonać na własnych tabelach Pracownicy, Zakłady i Etaty Korzystając z podzapytań: 1. Wyświetl tylko tych pracowników, którzy pracują na stanowisku profesora. 2. Wyświetl pracowników z tym samym tytułem/stopniem naukowym ale innymi telefonami. 3. Pokaż pracowników których zarobki są mniejsze od średniej z zarobków. 4. Pokaż zakłady które mają mniej niż 2 pracowników. 5. Pokaż etaty na których pracuje więcej niż 1 pracownik.

Transakcje Transakcje są grupami instrukcji języka SQL, traktowanymi z punktu widzenia ich przetwarzania jako jedna całość. BEGIN TRANSACTION; zapytanie1; zapytanie2;...... zapytanien; COMMIT; > Zmiany zostają zatwierdzone BEGIN TRANSACTION; zapytanie1; zapytanie2;...... zapytanien; ROLLBACK; > Zmiany zostają odwołane Jeżeli w trakcie wykonywania transakcji wystąpi jakiś błąd, całą sekwencję operacji można odwołać, przywracając bazę do stanu sprzed rozpoczęcia tej sekwencji. Instrukcje tworzące, usuwające i modyfikujące tabele nie są transakcyjne nie można ich wycofać. 93

Transakcje - blokowanie dostępu Z wykorzystaniem transakcji wiąże się wiele niebezpieczeństw w szczególności związanych z wielozadaniowością systemu baz danych. Aby zapobiec ew. problemom można przy wykonaniu transakcji skorzystać z rożnych poziomów izolacji. SET TRANSACTION ISOLATION LEVEL SERIALIZABLE READ UNCOMMITED - najniższy poziom, zezwala na czytanie niepotwierdzonych danych, READ COMMITED - aplikacja może odczytywać tylko potwierdzone dane, właściwy poziom izolacji np. dla procedur raportujących, dla których istotny jest chwilowy stan bazy, REAPEATABLE READ - blokuje dostęp do wszystkich odczytanych danych, właściwy poziom izolacji dla procedur odczytu i aktualizacji danych, SERIALIZABLE - blokuje dostęp do tabeli, właściwy poziom izolacji dla procedur odczytu i aktualizacji danych. 94

Transakcje - przykład Wykonamy proste połączenie kilku zapytań z klauzulą SELECT. BEGIN TRANSACTION SELECT * FROM klienci WHERE imie = 'Jan'; SELECT * FROM zamowienia ORDER BY koszt; SELECT nazwa, cena FROM produkty WHERE cena > 5; COMMIT; 95

Transakcje - przywrócenie stanu pierwotnego ROLLBACK Komenda ROLLBACK odwołuje transakcję. Polecenie to odwołuje wszystkie modyfikacje jakie zostały dokonane podczas trwania transakcji poprzez przywrócenie stanu danych sprzed transakcji. BEGIN TRANSACTION UPDATE klienci SET imie='john' WHERE imie ='Jan' IF @@ERROR = 0 BEGIN RAISERROR ('Operacja udana!', 16, -1) ROLLBACK TRANSACTION END COMMIT; 96

Widoki (perspektywy) Widok jest predefiniowanym, zapisanym po stronie serwera zapytaniem, którego wynik może być wielokrotnie odczytywany. Z perspektywy użytkownika widok nie różni się niczym od tabeli - użytkownik do obu obiektów odwołuje się tak samo. Widoki wykorzystuje się w wielu celach np.: ułatwienie realizacji zapytań odwołujących się do wielu tabel, ułatwienie realizacji zapytań wykonujących obliczenia na zapisanych w tabelach danych, zabezpieczenie przed dostępem do poufnych danych, ukrycie przed użytkownikiem struktury bazy, ułatwienie zarządzaniem prawami dostępu, oddzielić i uniezależnić aplikację kliencką od zmian tabel baz danych. W bazie zapamiętane zostają tylko definicje poszczególnych kolumn widoków, nie zaś wartości! 97

Widoki Projektowanie baz danych CREATE VIEW klienci_kontakt AS SELECT imie, nazwisko, telefon FROM klienci; Proszę nadać widokowi nazwę składającą się z dwóch członów - słowa klient_kontakt i po 'podkreślniku' inicjałów autora, autorów np. klienci_kontakt_jk Tak utworzony widok można używać jak zwykłej tabeli: SELECT * FROM klienci_kontakt WHERE imie LIKE '%Ja%'; +--------+----------+-----------+ imie nazwisko telefon +--------+----------+-----------+ Jan Kowalski 618555555 Jacek Nowak 618546234 Jan Malwa 618453124 +--------+----------+-----------+ Widoki umożliwiają prezentowanie danych w sposób najbardziej wygodny dla użytkowników, niezależnie od struktury tabel fizycznych. 98

Widoki - przykład Tworzymy widok zawierający poszczególne zamówienia porządkowane wg klienta CREATE VIEW klienci_zam AS SELECT klienci.nazwisko, produkty.nazwa, zam_prod.ilosc FROM klienci, zamowienia, zam_prod, produkty WHERE zamowienia.kid = klienci.kid AND zam_prod.zid = zamowienia.zid AND produkty.pid = zam_prod.pid; cel zapytania: Pokaż wszystkie zamówienia Kowalskiego: SELECT * FROM klienci_zam WHERE nazwisko = 'Kowalski'; W języku SQL widoki mogą odczytywać dane nie tylko z tabel bazowych, ale również z innych widoków. 99

Widoki a zmiana - zmiany w tabeli bazowej uwzględniane są w widokach Zmienimy nazwisko Kowalski na Kowal UPDATE klienci SET nazwisko = 'Kowal' WHERE nazwisko = 'Kowalski'; Ponownie uruchamiamy zapytanie SELECT * FROM klienci_zam WHERE nazwisko = 'Kowalski'; Zapytanie nic nie zwraca. Zmieniamy więc warunek: SELECT * FROM klienci_zam WHERE nazwisko = 'Kowal'; 100

Widoki modyfikowalne - zmiany w widokach powodują zmiany w tabelach bazowych Kontynuujemy zmiany, przywrócimy nazwisko Kowalski ale tym razem za pomocą widoku: UPDATE klienci_zam SET nazwisko = 'Kowalski' WHERE nazwisko = 'Kowal'; Tak jak się spodziewaliśmy spowodowało to zmianę Kowal na Kowalski : SELECT * FROM klienci; Zaleca się ostrożność przy zmianach wprowadzanych poprzez widoki, zmiany te mogą naruszyć więzy integralności. 101

Widoki niemodyfikowalne Nie wszystkie widoki są modyfikowalne. Niemodyfikowalne z założenia są widoki, które wykorzystują wraz z SELECT klauzule UNION, UNION ALL, DISTINCT, DISTINCTROW. Widoki także nie mogą zawierać podzapytań. Usuwanie wierszy z widoków: Niekiedy z widoków modyfikowalnych można usuwać wiersze mianowicie wtedy, gdy SQL potrafi "przetłumaczyć" zapytanie usuwające wiersze z widoku na zapytanie (zapytania) usuwające wiersze z tabeli bazowej. DELETE FROM klienci_zam WHERE nazwisko = 'Kowalski'; View or function 'klienci_zam' is not updatable because the modification affects multiple base tables. 102

Widoki - modyfikowanie struktury Możemy zmienić definicję widoku przez wykonanie instrukcji ALTER VIEW. Utworzymy widok z listą produktów, ich ceną i liczbą sztuk: CREATE VIEW prod AS SELECT nazwa, SUM(cena) as koszt, COUNT(ilosc) as liczba FROM zam_prod JOIN produkty ON zam_prod.pid = produkty.pid GROUP BY nazwa; Zmodyfikujemy widok tak aby pokazywał tylko drogie produkty: ALTER VIEW prod AS SELECT nazwa, SUM(cena) as koszt, COUNT(ilosc) as liczba FROM zam_prod JOIN produkty ON zam_prod.pid = produkty.pid GROUP BY nazwa HAVING SUM(cena) > 20; 103

Widoki - usuwanie Niepotrzebne widoki mogą zostać usunięte z bazy danych. Ponieważ usunięcie tabeli bazowej nie powoduje automatycznego usunięcia powiązanych z nią widoków, z reguły wykonuje się te operacje razem. DROP VIEW klienci_zam; DROP VIEW prod; 104

ZADANIA (11) Wszystkie zadania należy wykonać na własnych tabelach Pracownicy, Zakłady i Etaty 1. Utwórz widok pokazujący numer, imię, nazwisko, etat i zakład pracownika. Korzystając z tego widoku wyświetl: a) zakłady mające w swojej nazwie 'ow', b) pracowników pracujących na etacie asystenta, c) zakłady w których pracuje najwięcej adiunktów. 2. Popraw widok dodając do niego informacje o płacy oraz dacie zatrudnienia. Korzystając ze zmodyfikowanego widoku wyświetl: a) zakłady, które wydają najwięcej na płace, b) średnią płacę dla każdego z zakładów, c) zakłady w których pracuje najwięcej pracowników zatrudnionych po 2000 roku.

Procedury składowe (stored procedures) Stosuje się je do wykonywania powtarzających się, logicznie takich samych operacji na (bazie) danych, nie wymagających ingerencji ze strony użytkownika. Rozpoczniemy od definicji procedury: CREATE PROCEDURE promocja @produkt CHAR(20) AS UPDATE produkty SET cena = cena * 0.9 WHERE nazwa = @produkt; 106

Procedury składowe I teraz możemy ją wywołać podając wartość parametru - produkt w promocji: EXEC promocja 'myszka' W efekcie wywołaliśmy procedurę, która spowodowała obniżenie ceny produktu. 107

Procedury składowe wyświetlenie listy SELECT * FROM sys.procedures WHERE name NOT LIKE 'sp_%'; Procedury składowe wyświetlenie zawartości sp_helptext promocja; Procedury składowe - usuwanie DROP PROCEDURE promocja; 108

Procedury składowe IF ELSE Definiujemy procedurę: CREATE PROCEDURE ocena_ceny(@cena INT) AS IF (@cena > 20)SELECT 'drogie'; ELSE SELECT 'tanie'; Podobnie jak przy tablicach dodajemy swoje inicjały Uruchamiamy procedurę podając wprost cenę produktu: EXEC ocena_ceny 10; 109

Procedury składowe IF ELSE Możemy też utworzyć na podstawie naszych tablic lokalną zmienną i sprawdzić jaka jest cena w danej komórce. Tworzymy zmienną: DECLARE @cena INT SELECT @cena=cena FROM produkty WHERE pid=1; Sprawdzamy procedurą jej wielkość: EXEC ocena_ceny @cena; 110

Procedury składowe CASE CASE @zmienna WHEN przypadek1 zadanie(a) WHEN przypadek2 zadanie(a) ELSE zadanie(a) END Rozpoczynamy od utworzenia procedury: CREATE PROCEDURE fajne_imie @imie VARCHAR(30) AS SELECT CASE @imie WHEN 'Jan' THEN 'TAK' ELSE 'NIE' END; Sprawdzamy jej działanie: DECLARE @cena INT SELECT @cena=cena FROM produkty WHERE pid=1; EXEC ocena_ceny @cena; 111

Procedury składowe WHILE CREATE PROCEDURE petla @i INT AS WHILE (@i < 5) BEGIN SELECT * FROM klienci WHERE kid = @i SET @i=@i+1 END EXEC petla 1; 112

ZADANIA (12) Wszystkie zadania należy wykonać na własnych tabelach Pracownicy, Zakłady i Etaty

Wyzwalacze Wyzwalacze są procedurami uruchamianymi automatycznie na skutek zdarzeń zachodzących w bazie danych. Służą do oprogramowania więzów spójności i do oprogramowania stałych czynności, które powinny być wykonywane w każdej aplikacji korzystającej z bazy danych. Typ wyzwalacza zależy od tego, czy ma być wykonywany przed operacją (BEFORE), czy po operacji (AFTER). Wyzwalacze obu typów mogą być uruchamiane w wyniku następujących poleceń: INSERT (wstawianie), DELETE (usuwanie), UPDATE (modyfikacja). CREATE TRIGGER trigger_name ON { table view } [ WITH ENCRYPTION ] { { { FOR AFTER INSTEAD OF } { [ INSERT ] [, ] [ UPDATE ] [, ] [ DELETE ] } [ WITH APPEND ] [ NOT FOR REPLICATION ] AS {... } DROP TRIGGER nazwa_wyzwalacza; 114

Wyzwalacze Wyzwalacz wykonywana się automatycznie po zmianie zawartości wskazanej tabeli. CREATE TRIGGER DodanoKlienta ON klienci FOR INSERT AS DECLARE @klient VARCHAR(100) SELECT @klient =(SELECT nazwisko FROM INSERTED) PRINT 'KLIENT ' + @klient + ' ZOSTAŁ DODANY DO BAZY'; Podczas dodawania nowego klienta otrzymujemy stosowny komunikat: INSERT INTO klienci VALUES('Marian', 'Janczuk', 618343851, 'mjanczuk@o2.pl'); 115

Kursory Kursor jest to tymczasowa struktura służąca do pobierania wyniku zapytania SQL. Kursor umożliwia pobieranie rekordów sekwencyjnie, po jednym lub więcej na raz, a także przemieszczanie się po wynikach zapytania. Kursor może być zdefiniowany i działać po stronie serwera baz danych, jak i po stronie klienta. Ten drugi typ kursora jest rodzajem iteratora umożliwiającego poruszanie się po poszczególnych rekordach zwróconych przez serwer klientowi. DECLARE PobierzKlientów CURSOR SCROLL FOR SELECT * FROM klienci ORDER BY nazwisko OPEN PobierzKlientów FETCH FIRST FROM PobierzKlientów WHILE @@Fetch_Status =0 BEGIN FETCH NEXT FROM PobierzKlientów END 116

Kursory declare @imie varchar(30) declare @nazwisko varchar(30) DECLARE wynik CURSOR FOR SELECT imie, nazwisko FROM klienci OPEN wynik FETCH NEXT FROM wynik INTO @imie, @nazwisko PRINT '' + CAST(@@FETCH_STATUS AS VARCHAR) WHILE @@FETCH_STATUS = 0 BEGIN SELECT * FROM klienci WHERE nazwisko = @nazwisko; FETCH NEXT FROM wynik INTO @imie, @nazwisko END CLOSE wynik DEALLOCATE wynik 117

Klucze obce (foregin key) Powiązanie indeksowanej kolumny danej tabeli z indeksowaną kolumną innej tabeli, co pozwala na automatyczne dokonywanie zmian w powiązanych tabelach. FOREIGN KEY (nazwa_kolumny_indeksowanej,...) REFERENCES nazwa_tabeli (nazwa_kolumny_indeksowanej,...) [ON DELETE {RESTRICT CASCADE SET NULL NO ACTION}] [ON UPDATE {RESTRICT CASCADE SET NULL NO ACTION}] Dodajemy klucz obcy to tablicy zam_prod pozwoli to na automatyczną aktualizację numerów zamówień i produktów przy zmianie ich w tabelach macierzystych: ALTER TABLE zam_prod ADD FOREIGN KEY (pid) REFERENCES produkty(pid) ON UPDATE CASCADE; 118

Klucze obce (foregin key) Sprawdzamy, czy rzeczywiście dane są aktualizowane zmieniając numer produktu w tabeli macierzystej. Zawartość tabel przed zmianami: Tabela produkty Tabela zam_prod 119