Pobierz prezentację
Pobieranie prezentacji. Proszę czekać
1
Projektowanie Aplikacji Internetowych
Artur Niewiarowski Wydział Fizyki, Matematyki i Informatyki Politechnika Krakowska
2
Baza danych
3
Baza danych Baza danych - zbiór wzajemnie powiązanych danych, przechowywanych w pamięci komputerów i wykorzystywanych przez programy użytkowe instytucji lub organizacji wraz z oprogramowaniem umożliwiającym definiowanie, wykorzystywanie i modyfikowanie tych danych. źródło: Encyklopedia PWN innymi słowy… Baza danych jest to zbiór logicznie powiązanych danych, zarządzany przez system zarządzania bazą danych (SZBD), który działa w interakcji z użytkownikiem i jego programami.
4
Co umożliwiają bazy danych i systemy zarządzające nimi?
5
łatwość składowania dużych ilości danych
przejrzystość danych dzięki odpowiednim strukturom jakimi są tabele i relacjom pomiędzy nimi szybki dostęp do danych współdzielenie danych przez wielu użytkowników zabezpieczenia przed utratą danych
6
dostarczają środowiska programistycznego
współpraca z wieloma platformami programistycznymi dostarczają licznych specjalistycznych funkcji zaimplementowana polityka bezpieczeństwa
7
Projektujemy własną bazę danych
8
Odpowiedzi na następujące pytania:
Jak zaprojektować schemat bazy danych? Jak budować poprawnie tabele? Jakie mamy typy relacji pomiędzy tabelami? Jakich typów danych używać? Czym są postacie normalne w bazach danych? Co to jest nadmiarowość danych i jak jej unikać? Co to są anomalie: modyfikacji, usunięć?
9
Jak zaprojektować schemat bazy danych?
10
Jak poprawnie budować tabele?
Tabele w bazie danych należy budować z zachowaniem pewnych norm, dzięki którym baza będzie spójna, czytelna, a dane nie będą zajmowały zbędnego miejsca na dysku.
11
Jak projektować schemat bazy danych?
Normalizacja baz danych jest procesem mającym na celu zlikwidowanie danych niepotrzebnie powtarzających się w relacyjnej bazie danych. Dzięki normalizacji zmniejsza się ryzyko powstawania: nadmiarowości danych, anomalii modyfikacji oraz anomalii usunięć.
12
Nadmiarowość danych ma miejsce wtedy, kiedy dana wartość niepotrzebnie jest powielana w krotkach danego atrybutu (kolumny). Kiedy podczas dodawania kolejnego wiersza, użytkownik popełni błąd w wartości powielanej danej, to baza traci spójność.
13
Anomalia modyfikacji – chęć zmiany powielanej informacji wymusza zmianę tej informacji we wszystkich krotkach. Pominięcie choćby jednej krotki powoduje utratę spójności danych. Uaktualnianie powielanej danej zabiera niepotrzebnie dużo czasu i zajmuje proces. Chcemy uaktualnić nazwę miejscowości „Krynica Zdrój” na „Krynica-Zdrój”
14
Anomalia usunięć – ma miejsce wtedy, gdy usuniemy wiersz, który przechowywał istotną informację, która w konsekwencji została niepotrzebnie utracona.
15
Kiedy powielane informacje nie są wynikiem błędnego projektu?
16
Kiedy powielane informacje nie są wynikiem błędnego projektu?
17
Prosty przepis na poprawny projekt bazy danych:
Wypunktować to co powinna przechowywać baza danych. Pogrupować w tabelę powyższe dane tak, aby jednoznacznie charakteryzowały dany obiekt. Każda tabela powinna zawierać kolumnę jednoznacznie identyfikującą wiersze w pozostałych kolumnach (tzw. klucz główny) – 2 postać normalna Poszczególne kolumny powinny zawierać dane atomowe, np. kolumna adres powinna zostać rozbita na kolumny przechowujące: nazwę ulicy, numer domu, numer mieszkania, miasto, kod pocztowy itd. – 1 postać normalna
18
Prosty przepis na poprawny projekt bazy danych:
Wyeliminować zależności przechodnie, czyli wykluczyć takie kolumny, których wartości nie są bezpośrednio zależne od klucza głównego, ale od innej kolumny – 3 postać normalna Jeżeli jest taka możliwość, to połączyć kolumny w danej tabeli z kolumnami jednoznacznie identyfikującym wiersze w tabeli pokrewnej. przykład →
19
W praktyce wygląda to następująco:
temat przykładowego zadania: zaprojektować bardzo prosty schemat bazy danych przechowujący informacje o klientach supermarketu i ich zakupach
20
Jakie informacje będzie przechowywała nasza baza danych?
Jak je pogrupować? Klienci: imię, nazwisko, miejsce zamieszkania Produkty: nazwa, typ produktu, producent, cena Typy produktów: nazwa Producenci: nazwa, adres firmy Historia zakupów: produkt, klient, data zakupu
21
3. Każda tabela powinna zawierać klucz główny.
Klienci: ID_klient, imie, nazwisko, miejsce_zamieszkania Produkty: ID_produkt, nazwa, typ roduktu, producent, cena Typy produktów: ID_typ_produktu, nazwa Producenci: ID_producent, nazwa, adres_firmy Historia zakupów: ID_historia, produkt, klient, cena, data_zakupu
22
4. Poszczególne kolumny powinny zawierać dane atomowe.
Klienci: ID_klient, imie, nazwisko, zam_miejscowosc, zam_ulica, zam_nr_domu, zam_nr_mieszkania, zam_kod_pocztowy, zam_kraj Produkty: ID_produkt, nazwa, typ produktu, producent, cena Typy produktów: ID_typ_produktu, nazwa Producenci: ID_producent, nazwa, adres_miejscowosc, adres_ulica, adres_nr_domu, adres_nr_mieszkania, adres_kod_pocztowy, adres_kraj Historia zakupów: ID_historia, produkt, klient, cena, data_zakupu
23
5. Wyeliminować zależności przechodnie w tabelach.
Jeżeli w danej tabeli występują kolumny, których wartości nie są bezpośrednio zależne od klucza głównego, ale od innej kolumny, to należy je wykluczyć poprzez utworzenie dodatkowej tabeli przechowującej tą inną kolumnę jako klucz główny i wartości bezpośrednio zależne od niej.
24
5. Wyeliminować zależności przechodnie w tabelach.
Klienci: ID_klient, imie, nazwisko, zam_ID_miejscowosc, zam_ulica, zam_nr_domu, zam_nr_mieszkania, zam_kod_pocztowy Produkty: ID_produkt, nazwa, ID_typ_produktu, ID_producent, cena Typy produktów: ID_typ_produktu, nazwa Producenci: ID_producent, nazwa, adres_ID_miejscowosc, adres_ulica, adres_nr_domu, adres_nr_mieszkania, adres_kod_pocztowy Historia zakupów: ID_historia, ID_produkt, ID_klient, cena, data_zakupu Województwa: … Kraje: … itd. itp.
25
Baza danych MySQL
26
Charakterystyka bazy danych MySQL
jeden z najpopularniejszych systemów zarządzania relacyjnymi bazami danych posiada wiele mechanizmów zapewniających bezpieczeństwo danych, w tym m.in.: odzyskanie spójności danych po awarii autoryzację dostępu do danych możliwość łączenia się z bazą poprzez sieć komunikacja użytkownika z SZBD poprzez język zapytań SQL (ang. Structured Query Language)
27
Charakterystyka bazy danych MySQL
każda tabela jest obsługiwana przez silnik bazodanowy (ang. engine), który przydziela użytkownik według potrzeb najpopularniejsze silniki to: MyISAM – posiada algorytmy w celu szybkiego wyszukiwania danych w tabeli InnoDB – posiada algorytmy obsługujące transakcje bazodanowe FEDERATED – umożliwia połączenie z konkretną tabelą w konkretnej bazie danych na innym serwerze
28
Instalacja i konfiguracja systemu bazodanowego MySQL
29
Windows…
30
Instalacja i konfiguracja bazy danych MySQL
1.1. Pobranie ze strony internetowej: odpowiedniej instalacji bazy danych względem systemu operacyjnego. Przykład:
31
Instalacja i konfiguracja bazy danych MySQL
1.2. Pobranie ze strony internetowej: odpowiedniej instalacji bazy danych względem systemu operacyjnego. Przykład:
32
Instalacja i konfiguracja bazy danych MySQL
1.3. Pobranie ze strony internetowej: odpowiedniej instalacji bazy danych względem systemu operacyjnego. Przykład:
33
Instalacja i konfiguracja bazy danych MySQL
Przykład:
34
Instalacja i konfiguracja bazy danych MySQL
Przykład:
35
Instalacja i konfiguracja bazy danych MySQL
Przykład:
36
Instalacja i konfiguracja bazy danych MySQL
Przykład:
37
Instalacja i konfiguracja bazy danych MySQL
Przykład:
38
Instalacja i konfiguracja bazy danych MySQL
Przykład:
39
Instalacja i konfiguracja bazy danych MySQL
Przykład:
40
Instalacja i konfiguracja bazy danych MySQL
Przykład:
41
Linux - RedHat
42
Instalacja i konfiguracja bazy danych MySQL
~]# yum install mysql php-mysql
43
Instalacja i konfiguracja bazy danych MySQL
~]# more /etc/sysconfig/iptables | grep 3306 -A INPUT -s / p tcp -m tcp --dport j ACCEPT -A INPUT -p tcp -m tcp --dport j DROP
44
Logowanie do systemu bazodanowego MySQL
45
Logowanie do MySQL Zarządzanie serwisem.
46
Logowanie do MySQL Zarządzanie serwisem.
~]# ps -A | grep -i mysql 5957 ? :27:40 mysqld ~]# service mysqld start Uruchamianie mysqld: [ OK ] ~]# service mysqld stop ~]# service mysqld restart ~]# service mysqld status mysqld (pid 5957) jest uruchomiony...
47
Logowanie do MySQL Polecenie służące do zalogowania się do bazy danych: mysql –u uzytkownik –p nazwa_bazy_danych –h IP/host omówienie parametrów: -u – nazwa użytkownika -p – wymuszenie poproszenia przez system o wpisanie hasła przez użytkownika -h – adres komputera, na którym działa baza. Jeżeli jest to localhost, to parametr nie jest wymagany
48
Logowanie do MySQL z poziomu wiersza poleceń
Przykład:
49
Logowanie do MySQL z poziomu programu Navicat
50
Logowanie do MySQL z poziomu programu Navicat
51
Tunelowanie - Putty
52
Tworzenie kopii zapasowej bazy danych
~]$ mysqldump Usage: mysqldump [OPTIONS] database [tables] OR mysqldump [OPTIONS] --databases [OPTIONS] DB1 [DB2 DB3...] OR mysqldump [OPTIONS] --all-databases [OPTIONS] For more options, use mysqldump --help
53
Tworzenie kopii zapasowej bazy danych
~]$ mysqldump Usage: mysqldump [OPTIONS] database [tables] OR mysqldump [OPTIONS] --databases [OPTIONS] DB1 [DB2 DB3...] OR mysqldump [OPTIONS] --all-databases [OPTIONS] For more options, use mysqldump --help 0 0 * * * mysqldump -u root --all-databases –password=haslo > "/root/kopie_mysql/dump`date`.sql"
54
Podstawowe polecenia języka SQL
55
Czym jest język SQL? Język SQL (ang. Structured Query Language) jest językiem używanym do komunikacji użytkownika z system zarządzania bazą danych Obecnie każdy popularny system bazodanowy posiada zaimplementowany interpreter języka SQL z zachowaniem pewnego standardu Język SQL umożliwia tworzenie skomplikowanych zapytań do bazy danych w celu otrzymania wyniku
56
Za pomocą języka SQL można:
tworzyć: bazy danych, użytkowników, tabele zarządzać prawami dostępu do baz, do poszczególnych poleceń wydawanych przez użytkowników zarządzać danymi w tabelach (umieszczać, usuwać, uaktualniać, wyszukiwać) tworzyć funkcje, wyzwalacze (triggery), itd. i wiele innych…
57
Tworzenie i zarządzanie bazami danych. Uprawnienia.
58
Tworzenie nowej bazy danych.
create database [if not exists] nazwa; Więcej informacji na stronie internetowej: Lista wszystkich baz danych: show databases; Usunięcie bazy danych. drop database [if exists] nazwa;
59
Tworzenie nowego użytkownika.
create user Więcej informacji na stronie internetowej: Usunięcie użytkownika. drop [, itd];
60
Uprawnienia użytkowników.
Uprawnienia względem wybranej bazy danych: grant [all,select,create,…] on nazwa_bazy.* to Uprawnienia globalne: grant [all,select,create,…] on *.* to
61
Uprawnienia użytkowników.
Uprawnienia względem wybranej tabeli w bazie danych: grant [all,select,insert,…] on nazwa_bazy.tabela to Uprawnienia względem wybranych kolumn danej tabeli w bazie danych: grant [all(kolumna1, kolumna2),select(kolumna1, kolumna2),insert(kolumna),…] on nazwa_bazy.tabela to
62
Uprawnienia użytkowników.
Odbieranie uprawnień: revoke zdarzenie on baza.* from uzytkownik; revoke zdarzenie on baza.tabela from uzytkownik; revoke zdarzenie (kolumna1, kolumna2,…) on baza.* from
63
Uprawnienia – operacje na tabelach systemowych
| Tables_in_mysql | | columns_priv | | db | | event | | func | | general_log | | help_category | | help_keyword | | help_relation | | help_topic | | host | | ndb_binlog_index | | plugin | | proc | | procs_priv | | proxies_priv | | servers | | slow_log | | tables_priv | | time_zone | | time_zone_leap_second | | time_zone_name | | time_zone_transition | | time_zone_transition_type | | tmp_db | | tmp_user | | user | mysql> use mysql; Database changed mysql> show tables;
64
Uprawnienia – operacje na tabelach systemowych
mysql> desc user; | Field | Type | Null | Key | Default | Extra | | Host | char(60) | NO | PRI | | | | User | char(16) | NO | PRI | | | | Password | char(41) | NO | | | | | Select_priv | enum('N','Y') | NO | | N | | | Insert_priv | enum('N','Y') | NO | | N | | | Update_priv | enum('N','Y') | NO | | N | | | Delete_priv | enum('N','Y') | NO | | N | | | Create_priv | enum('N','Y') | NO | | N | | | Drop_priv | enum('N','Y') | NO | | N | | | Reload_priv | enum('N','Y') | NO | | N | | | Shutdown_priv | enum('N','Y') | NO | | N | |
65
Uprawnienia – operacje na tabelach systemowych
mysql> desc db; | Field | Type | Null | Key | Default | Extra | | Host | char(60) | NO | PRI | | | | Db | char(64) | NO | PRI | | | | User | char(16) | NO | PRI | | | | Select_priv | enum('N','Y') | NO | | N | | | Insert_priv | enum('N','Y') | NO | | N | | | Update_priv | enum('N','Y') | NO | | N | | | Delete_priv | enum('N','Y') | NO | | N | | | Create_priv | enum('N','Y') | NO | | N | | | Drop_priv | enum('N','Y') | NO | | N | |
66
Uprawnienia – operacje na tabelach systemowych
mysql> flush privileges; Query OK, 0 rows affected (0.00 sec)
67
Hasła. Nadawanie i zmiana haseł:
set password for = password('haslo'); set password = password('haslo');
68
Pozostałe polecenia SQL
69
1. Tworzenie tabel – polecenie create table
Przykład: CREATE TABLE `Klienci` ( ID_klient int(11) unsigned NOT NULL AUTO_INCREMENT, imie varchar(20) NOT NULL, nazwisko varchar(80) NOT NULL, PESEL varchar(11) DEFAULT 'brak', rok_urodzenia date NOT NULL, PRIMARY KEY (ID_klient), UNIQUE KEY uniq_Klienci (imie,nazwisko,PESEL) USING BTREE ) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8;
70
1. Tworzenie tabel – polecenie create table
Przykład: CREATE TABLE `Pliki` ( `ID_pliki` int(10) unsigned NOT NULL AUTO_INCREMENT, `ID_klient` int(10) unsigned DEFAULT NULL, `nazwa` varchar(100) NOT NULL, `plik` blob, `timestamp` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP, PRIMARY KEY (`ID_pliki`), KEY `Klienci_pliki` (`ID_klient`) USING BTREE, CONSTRAINT `Klienci_pliki` FOREIGN KEY (`ID_klient`) REFERENCES `Klienci` (`ID_klient`) ON UPDATE CASCADE ) ENGINE=InnoDB AUTO_INCREMENT=4 DEFAULT CHARSET=utf8;
71
1. Tworzenie tabel – polecenie create table
Przykład: mysql> create table tmp_uzytkownicy select * from uzytkownicy; Query OK, 3 rows affected Records: 3 Duplicates: 0 Warnings: 0 mysql> desc uzytkownicy; | Field | Type | Null | Key | Default | Extra | | ID_uzytkownik | int(10) unsigned | NO | PRI | NULL | auto_increment | | login | varchar(20) | NO | UNI | NULL | | | imie | varchar(20) | NO | | NULL | | | nazwisko | varchar(80) | NO | | NULL | | | haslo | varchar(32) | NO | | NULL | | mysql> desc tmp_uzytkownicy; | Field | Type | Null | Key | Default | Extra | | ID_uzytkownik | int(10) unsigned | NO | | | | | login | varchar(20) | NO | | NULL | | | imie | varchar(20) | NO | | NULL | | | nazwisko | varchar(80) | NO | | NULL | | | haslo | varchar(32) | NO | | NULL | |
72
Wybrane typy danych w MySQL
Ciągowe typy danych: char varchar blob (przechowuje wartości binarne, np. pliki) text (przechowuje duże teksty) enum (umożliwia umieszczenie w kolumnie ciągu z listy podanych)
73
Wybrane typy danych w MySQL
Liczbowe typy danych: bit (przechowuje od 1 do 64 znaków) bool (przechowuje wartości: 0 lub 1) decimal(M,D) (M – wartość całkowita: od 1 do 65 znaków, D – wartość po przecinku: od 0 do 30 znaków) smallint [unsigned] (liczba całkowita od -128 do 127 znaków) int [unsigned] float [unsigned] double [unsigned]
74
Wybrane typy danych w MySQL
Typy danych związane z czasem i datą: datetime (przechowuje datę i czas, rok z przedziału: od 1000 do 9999) date (przechowuje wyłącznie datę) timestamp (przechowuje datę i czas, rok z przedziału: od 1 stycznia 1970 do 19 stycznia 2038) time (przechowuje wyłącznie czas) year (przechowuje wyłącznie rok)
75
2. Usuwanie tabel – polecenie drop table
Składnia polecenia: DROP TABLE [IF EXISTS] nazwa_tabeli; Przykład: DROP TABLE Klienci;
76
3. Zmiana struktury tabel – polecenie alter table
Składnia polecenia zmieniającego kolumnę: ALTER TABLE nazwa_tabeli CHANGE nazwa_kolumny nowa_nazwa_kolumny nowe parametry dla kolumny; Przykład: ALTER TABLE Klienci CHANGE imie imiona varchar(50) not null;
77
3. Zmiana struktury tabel – polecenie alter table
Składnia polecenia dodającego kolumnę: ALTER TABLE nazwa_tabeli ADD nazwa_kolumny parametry dla kolumny; Przykład: ALTER TABLE Klienci ADD drugie_imie varchar(12) default ' brak ';
78
3. Zmiana struktury tabel – polecenie alter table
Składnia polecenia usuwającego kolumnę: ALTER TABLE nazwa_tabeli DROP nazwa_kolumny; Przykład: ALTER TABLE Klienci DROP drugie_imie;
79
4. Umieszczanie danych w tabeli – polecenie insert into
Składnia polecenia: INSERT INTO nazwa_tabeli (kolumna_1, kolumna_2, … ) VALUES ('wartość_1', 'wartość_2'); Przykład: INSERT INTO Klienci (imie, nazwisko, PESEL, data_urodzenia) VALUES ('Jan', 'Kowalski', ' ', ' ');
80
4. Umieszczanie danych w tabeli – polecenie insert into
Przykład: mysql> insert into uzytkownicy select null,concat('tmp', login), imie, nazwisko, haslo from tmp_uzytkownicy; Query OK, 3 rows affected Records: 3 Duplicates: 0 Warnings: 0
81
5. Usuwanie danych z tabeli – polecenie delete from
Składnia polecenia: DELETE FROM nazwa_tabeli WHERE warunek; Przykład: DELETE FROM Klienci WHERE Nazwisko = 'Kowalski';
82
6. Uaktualnianie danych w tabeli – polecenie update
Składnia polecenia: UPDATE nazwa_tabeli SET nazwa_kolumny_1 = 'wartość' , nazwa_kolumny_2 = 'wartość' WHERE warunek; Przykład: UPDATE Klienci SET imie = ‘Michał’ WHERE Nazwisko = 'Kowalski' and Imie = 'Jan';
83
7. Odczytywanie danych z tabeli – polecenie select
Składnia polecenia: SELECT nazwa_kolumny_1, nazwa_kolumny_2, ... FROM nazwa_tabeli WHERE warunek Przykład: SELECT imie, nazwisko, PESEL FROM Klienci WHERE Nazwisko = 'Kowalski' and Imie = 'Jan';
84
7. Odczytywanie danych z tabeli – polecenie select
Składnia polecenia: SELECT * FROM nazwa_tabeli WHERE warunek Przykład: SELECT * FROM Klienci WHERE Nazwisko = 'Kowalski' and Imie = 'Jan';
85
7. Pozostałe polecenia SQL w SZBD MySQL
show tables – wyświetla listę zawierającą nazwy wszystkich tabel w aktualnej bazie danych describe nazwa_tabeli – opisuje szczegółowo wybraną tabelę use nazwa_bazy – przełącza się do innej bazy danych show create table nazwa_tabeli – wyświetla kod SQL tworzący daną tabelę exit – wylogowanie z bazy danych
86
Operatory i funkcje matematyczne
87
Operatory matematyczne
+ (dodawanie) - (odejmowanie) * (mnożenie) / (dzielenie) % (dzielenie modulo)
88
Operatory i funkcje matematyczne
89
Funkcje matematyczne abs() (oblicza wartość absolutną)
sin(), cos(), tan(), cot() (funkcje sinus, cosinus, itd.) pow() (funkcja potęgowa) sqrt() (obliczanie pierwiastka) pi() (zwraca wartość liczby pi, ) rand() (zwraca wartość losową)
90
Funkcje matematyczne log(), ln(), log2(), log10() (obliczanie logarytmów) degrees() (funkcja konwertująca radiany na stopnie) radians() (funkcje konwertująca stopnie na radiany) mod() (funkcja modulo) round() (zaokrąglanie wartości liczbowych) crc32() (cykliczny kod nadmiarowy)
91
Operatory i funkcje matematyczne
92
Operatory i funkcje matematyczne
93
Operatory i wybrane funkcje komparacji
94
Operatory i wybrane funkcje komparacji
between wartość1 and wartość2 (wartość pomiędzy) wartość1 = wartość2 (porównanie dwóch wartości) >, <, >=, <= (znaki: większości, mniejszości, …) <>, != (znaki różności) is, is not (wyrażenie: jeżeli, jeżeli nie) wartość1 like ‘%wartoś_2%’ (podobny) in() (zawiera się w …)
95
Operatory i funkcje matematyczne
96
Operatory i funkcje matematyczne
97
Funkcje agregujące
98
Funkcje agregujące avg() (funkcja obliczająca średnią)
Funkcje operują na wierszach w kolumnie: avg() (funkcja obliczająca średnią) count() (funkcja zliczająca liczbę wierszy) min() (funkcja zwracająca wartość minimalną) max() (funkcja zwracająca wartość maksymalną) sum() (funkcja sumująca wartości)
99
Funkcje agregujące
100
Funkcje agregujące
101
Funkcje agregujące Zadanie. Uaktualnić wiersze kolumny liczba w tabeli tab, mnożąc je przez 10. Pominąć wartości: minimalną i maksymalną. create table tab (liczba double); insert into tab values (1),(2),(3),(4),(5);
102
Operatory i funkcje matematyczne
Zadanie. Uaktualnić wiersze kolumny liczba w tabeli tab, mnożąc je przez 10. Pominąć wartości: minimalną i maksymalną. create table tab (liczba double); insert into tab values (1),(2),(3),(4),(5); begin; min(liczba) from max(liczba) from tab); update tab set liczba = liczba*10 where liczba and liczba commit; update tab set liczba = liczba*10 where liczba <> (select min(liczba) from (select liczba from tab) c) and liczba <> (select max(liczba) from (select liczba from tab) c);
103
Wybrane funkcje operujące na ciągach
104
Wybrane funkcje operujące na ciągach
concat() (łączy znaki w ciąg) hex() (oblicza wartość heksalną na podstawie zadanego parametru) instr() (szuka jednego ciągu w drugim) lcase(), lower() (zamieniają duże litery na małe) left() (wycina znaki od lewej strony ciągu) length() (zwraca długość podanego ciągu) ltrim() (usuwa spacje po lewej stronie zadanego ciągu) mid(), substring() (wycina środek ciągu) position(), locate() (zwraca pozycję ciągu w zadanym ciągu)
105
Wybrane funkcje operujące na ciągach
repeat() (powtarza n razy podany ciąg) replace() (zamienia ciąg na inny w zadanym ciągu) reverse() (zamienia kolejnośc liter w ciągu) right() (wycina znaki od prawej strony ciągu) rtrim() (usuwa spacje po prawej stronie zadanego ciągu) soundex(), ... sounds like ... (zwraca w postaci ciągu brzmienie w języku angielskim podanego wyrazu) space() (tworzy spacje) trim() (usuwa po obu stronach ciągu spacje) ucase(), upper() (zamienia małe na duże litery w zadanym ciągu)
106
Wybrane funkcje operujące na ciągach
107
Wybrane funkcje operujące na ciągach
108
Wybrane funkcje operujące na ciągach
109
Wybrane funkcje operujące na ciągach
110
Wybrane funkcje daty i czasu
111
Wybrane funkcje daty i czasu
adddate() (zwraca datę utworzoną poprzez dodanie lub odjęcie dni) addtime() (zwraca czas utworzony poprzez dodanie lub odjęcie czasu) curdate() (zwraca aktualną datę) curtime() (zwraca aktualny czas) date() (zwraca datę z podanego ciągu) datediff() (oblicza różnicę dat i zwraca ją w dniach) now() (zwraca aktualną datę i czas) day(), month(), year() (na podstawie ciągu zwracają odpowiednio: dzień, miesiąc, rok) dayname() (zwraca nazwę dnia w j. angielskim na podstawie daty)
112
Wybrane funkcje daty i czasu
dayofmonth(), dayofweek(), dayofyear() (na podstawie daty zwracają odpowiednio: numer dnia w miesiącu, dnia w tygodniu i dnia w roku) hour(), minute(), second() (na podstawie daty zwracają odpowiednio godzinę, minuty, sekundy) monthname() (nazwa miesiąca podanej daty) sysdate() (zwraca aktualną datę i czas w momencie wywołania funkcji) sec_to_time() (zamienia sekundy na czas) time() (zwraca czas z podanej daty i czasu) timediff() (oblicza różnicę czasów) time_to_sec() (zamienia czas na sekundy)
113
Wybrane funkcje daty i czasu
114
Wybrane funkcje daty i czasu
115
Relacje pomiędzy tabelami
116
Relacje pomiędzy tabelami
Relacjami pomiędzy tabelami nazywamy logiczne połączenia danych rozmieszonych w tych tabelach ostatecznie tworzące pewien rodzaj całości. Mamy następujące typy relacji: jeden-do-jednego – relacja rzadko spotykana, tabela pierwsza może mieć tylko jeden rekord dopasowany z drugiej tabeli, i również druga tabela może mieć tylko jeden rekord dopasowany z tabeli pierwszej. jeden-do-wielu – powszechny typ relacji. Rekord z tabeli pierwszej może mieć wiele dopasowań rekordów z tabeli drugiej, natomiast rekord z tabeli drugiej może mieć tylko jedno dopasowanie rekordu z tabeli pierwszej. wiele-do-wielu – wiele rekordów z tabeli pierwszej może być dopasowanych do wielu rekordów z tabeli drugiej, i na odwrót. W rzeczywistości tworzona jest trzecia tabela, która odpowiednio tworzy most pomiędzy tabelami (tzw. tabela łącza). Tabela łącza posiada dwa klucze obce – z tabeli pierwszej i z tabeli drugiej.
117
Referencje pomiędzy kluczami
118
Referencje pomiędzy kluczami
Schemat tworzenia klucza obcego: * [CONSTRAINT [symbol]] FOREIGN KEY [index_name] (index_col_name, ...) REFERENCES tbl_name (index_col_name,...) [ON DELETE reference_option] [ON UPDATE reference_option] reference_option: RESTRICT | CASCADE | SET NULL | NO ACTION create table table_name (ID int, …,…, ID_fk int, *); alter table table_name add *; alter table table_name drop foreign key constr_name_fk;
119
Referencje pomiędzy kluczami
Tworzenie klucza obcego z referencjami - SQL Przykład:
120
Referencje pomiędzy kluczami
Tworzenie klucza obcego z referencjami w programie Navicat
121
Podzapytania
122
Podzapytania Przykład: Mamy następujące tabele: select * from Klienci;
Mamy następujące tabele: select * from Klienci; | ID_klient | imie | nazwisko | PESEL | | | Jan | Kowalski | | | | Anna | Nowakowska | | | | Katarzyna | Nowicka | | | | Andrzej | Bachleda | | select * from Koszyk; | ID_koszyk | ID_klient | nazwa_produktu | | | | chleb | | | | maslo | | | | szynka | | | | chleb | | | | jablko | | | | jogurt | | | | proszek do prania | | | | plyn do naczyn |
123
Podzapytania Podzapytania – zapytania zagnieżdżone w innych zapytaniach. Przykłady: select * from Klienci where ID_klient = (select max(ID_klient) from Klienci); select imie, nazwisko, PESEL, (select count(*) from Koszyk where Koszyk.ID_klient = Klienci.ID_klient) as liczba_zakupionych_towarow from Klienci; select imie, nazwisko, PESEL from (select * from Klienci) as tabelka; select P numer_pesel from (select nazwisko, PESEL P from (select * from Klienci) T) T2;
124
Podzapytania Operator ANY(). Warunek w zapytaniu będzie spełniony, jeżeli porównywana wartość będzie spełniała warunek z przynajmniej jedną wartością zwróconą w podzapytaniu umieszczonych w operatorze. W podzapytaniu może zostać zwrócona wyłącznie jedna kolumna. Przykłady: select * from Studenci where indeks = any (select indeks from Absolwenci); select * from Klienci where ID_klient = any (select ID_klient from Koszyk); select PESEL = any (select PESEL from Absolwenci), PESEL from Studenci; select * from Klienci where not ID_klient = any (select ID_klient from Koszyk); select * from Klienci where ID_klient <> any (select ID_klient from Koszyk);
125
Podzapytania Operator ALL(). Warunek w zapytaniu będzie spełniony, jeżeli porównywana wartość będzie spełniała warunek ze wszystkimi zwróconymi w pozapytaniu umieszczonym w operatorze. W podzapytaniu może zostać zwrócona wyłącznie jedna kolumna. Przykłady: select * from Klienci where ID_klient <> all (select ID_klient from Koszyk);
126
Podzapytania Operator/funkcja EXISTS(). Jeżeli podzapytanie umieszczone w funkcji zwraca przynajmniej jeden wiersz, to funkcja zwraca wartość true, w przeciwnym przypadku false. Przykłady: select * from Klienci where exists (select * from Koszyk); select exists(select * from Koszyk where Koszyk.ID_klient = Klienci.ID_klient) as zakup, imie, nazwisko, PESEL from Klienci;
127
Podzapytania Operator IN(). Umożliwia sprawdzenie zawierania się wartości w wartościach wierszy danej kolumny, zwróconych przez podzapytanie. W podzapytaniu może zostać zwrócona wyłącznie jedna kolumna. Przykłady: select * from Klienci where ID_klient in (select ID_klient from Koszyk where year(data_zakupu) = ' 2011 '); select imie, nazwisko, PESEL from Studenci where not PESEL in (select PESEL from Absolwenci);
128
Unie - Union
129
Unie - Union Unia – służą do łączenia wyników wielu zapytań w jeden wynik. Podczas łączenia zapytań należy zachować jednakową liczbę kolumn w poszczególnych wynikach. Schemat: SELECT ... UNION [ALL | DISTINCT] SELECT ... [UNION [ALL | DISTINCT] SELECT ...]
130
Unie - Union Przykład: select imie from Klienci union
select nazwisko from Klienci union select nazwa_produktu from Koszyk;
131
Unie - Union Przykład: select imie from Klienci union
| imie | | Jan | | Anna | | Karolina | | Andrzej | | Kowalski | | Nowakowska | | Nowicka | | Bachleda | | chleb | | maslo | | szynka | | jablko | | jogurt | | proszek do prania | | plyn do naczyn | select imie from Klienci union select nazwisko from Klienci union select nazwa_produktu from Koszyk;
132
Unie - Union Przykład: select ID_klient from Klienci union
| ID_klient | | | | | | | | | | | | | | | | | select ID_klient from Klienci union select ID_koszyk from Koszyk union select ID_klient from Koszyk;
133
Unie - Union Przykład: select ID_klient, nazwisko from Klienci union
select ID_koszyk, nazwa_produktu from Koszyk union select ID_klient, imie from Klienci; | ID_klient | nazwisko | | | Kowalski | | | Nowakowska | | | Nowicka | | | Bachleda | | | chleb | | | maslo | | | szynka | | | chleb | | | jablko | | | jogurt | | | proszek do prania | | | plyn do naczyn | | | Jan | | | Anna | | | Karolina | | | Andrzej |
134
Unie - Union Przykład: select * from (select ID_klient, nazwisko from Klienci union select ID_koszyk, nazwa_produktu from Koszyk union select ID_klient, imie from Klienci) c where ID_klient = 1; | ID_klient | nazwisko | | | Kowalski | | | chleb | | | Jan |
135
Przykład – dane z różnych baz i serwerów:
Unie - Union Przykład – dane z różnych baz i serwerów: CREATE TABLE `uzytkownicy` ( `ID_uzytkownicy` int(11) NOT NULL AUTO_INCREMENT, `login` varchar(60) NOT NULL, PRIMARY KEY (`ID_uzytkownicy`) ) ENGINE=FEDERATED DEFAULT CHARSET=utf8 CREATE TABLE `users` ( `ID_users` int(11) NOT NULL AUTO_INCREMENT, `login` varchar(60) NOT NULL, PRIMARY KEY (`ID_users`) ) ENGINE=InnoDB DEFAULT CHARSET=utf8 select login from uzytkownicy union all select login from users;
136
Złączenia - Join
137
Złączenia - Join Złączanie tabel daje możliwość zwracania w jednym wyniku zapytania, rekordów pochodzących z różnych tabel. Wyróżniamy następujące typy złączeń: INNER JOIN – najczęściej używane, łączy kolumny pod odpowiednim warunkiem zgodności par wierszy. EQUI-JOIN – nie używa operatorów: mniejszości (<), większości (>) i różności (<>). NATURAL JOIN – podobne do EQUI-JOIN, używa do złączenia domyślnie tych samych nazw kolumn z dwóch różnych tabeli, wyświetla w wyniku odpowiednio jedną kolumnę z pary. CROSS JOIN – zwraca produkt kartezjański, czyli kombinację każdego wiersza z pierwszej tabeli z każdym wierszem z drugiej tabeli.
138
Złączenia - Join OUTER JOIN – ten typ złączenia nie wymaga, aby tabela pierwsza miała odpowiedniki w postaci wierszy w drugiej tabeli (i na odwrót), by wiersze zostały wyświetlone. LEFT OUTER JOIN – złączenie lewostronne. Zawsze wyświetla wszystkie wiersze z lewej tabeli i odpowiednio (według warunku) złącza wiersze z prawej tabeli. Jeżeli nie ma odpowiadających wierszy w prawej tabeli, wiersze żądanych kolumn prawej tabeli wypełniane są wartościami NULL. RIGHT OUTER JOIN – złączenie prawostronne. Zawsze wyświetla wszystkie wiersze z prawej tabeli i odpowiednio (według warunku) złącza wiersze z lewej tabeli. Jeżeli nie ma odpowiadających wierszy w lewej tabeli, wiersze żądanych kolumn lewej tabeli wypełniane są wartościami NULL. FULL OUTER JOIN – złączenie obustronne. Wyświetlone zostaną wszystkie wiersze z lewej jak i z prawej tabeli i odpowiednio (według analogii do dwóch poprzednich przykładów) nieistniejące wiersze wypełniane są wartościami NULL. SELF-JOIN – łączy wiersze kolumn tej samej tabeli.
139
Złączenia - Join Uproszczony schemat złączenia tabel:
table_references: table_reference [, table_reference] ... table_reference: join_table join_table: table_reference [INNER | CROSS] JOIN table_factor [join_condition] | table_reference {LEFT|RIGHT} [OUTER] JOIN table_reference join_condition | table_reference NATURAL [{LEFT|RIGHT} [OUTER]] JOIN table_factor join_condition: ON conditional_expr | USING (column_list)
140
Złączenia - Join Przykład: Mamy następujące tabele:
Mamy następujące tabele: select * from Klienci; | ID_klient | imie | nazwisko | PESEL | | | Jan | Kowalski | | | | Anna | Nowakowska | | | | Katarzyna | Nowicka | | | | Andrzej | Bachleda | | select * from Koszyk; | ID_koszyk | ID_klient | nazwa_produktu | | | | chleb | | | | maslo | | | | szynka | | | | chleb | | | | jablko | | | | jogurt | | | | proszek do prania | | | | plyn do naczyn |
141
Złączenia - Join Przykład: - inner join:
- inner join: select * from Koszyk inner join Klienci on Klienci.ID_klient = Koszyk.ID_klient; | ID_koszyk | ID_klient | nazwa_produktu | ID_klient | imie | nazwisko | PESEL | | | | chleb | | Jan | Kowalski | | | | | szynka | | Jan | Kowalski | | | | | proszek do prania | | Anna | Nowakowska | | | | | plyn do naczyn | | Anna | Nowakowska | | | | | maslo | | Katarzyna | Nowicka | | | | | chleb | | Katarzyna | Nowicka | | | | | jablko | | Andrzej | Bachleda | | | | | jogurt | | Andrzej | Bachleda | |
142
Złączenia - Join Przykład: - inner join:
- inner join: select * from Koszyk, Klienci where Koszyk.ID_klient = Klienci.ID_klient; | ID_koszyk | ID_klient | nazwa_produktu | ID_klient | imie | nazwisko | PESEL | | | | chleb | | Jan | Kowalski | | | | | szynka | | Jan | Kowalski | | | | | proszek do prania | | Anna | Nowakowska | | | | | plyn do naczyn | | Anna | Nowakowska | | | | | maslo | | Katarzyna | Nowicka | | | | | chleb | | Katarzyna | Nowicka | | | | | jablko | | Andrzej | Bachleda | | | | | jogurt | | Andrzej | Bachleda | |
143
Złączenia - Join Przykład: - inner join:
- inner join: select * from Koszyk, Klienci where Koszyk.ID_klient <> Klienci.ID_klient; | ID_koszyk | ID_klient | nazwa_produktu | ID_klient | imie | nazwisko | PESEL | | | | chleb | | Anna | Nowakowska | | | | | chleb | | Katarzyna | Nowicka | | | | | chleb | | Andrzej | Bachleda | | | | | maslo | | Jan | Kowalski | | | | | maslo | | Anna | Nowakowska | | | | | maslo | | Andrzej | Bachleda | | | | | szynka | | Anna | Nowakowska | | | | | szynka | | Katarzyna | Nowicka | | | | | szynka | | Andrzej | Bachleda | | | | | chleb | | Jan | Kowalski | | | | | chleb | | Anna | Nowakowska | | | | | chleb | | Andrzej | Bachleda | | | | | jablko | | Jan | Kowalski | | | | | jablko | | Anna | Nowakowska | | | | | jablko | | Katarzyna | Nowicka | | | | | jogurt | | Jan | Kowalski | | | | | jogurt | | Anna | Nowakowska | | | | | jogurt | | Katarzyna | Nowicka | | | | | proszek do prania | | Jan | Kowalski | | | | | proszek do prania | | Katarzyna | Nowicka | | | | | proszek do prania | | Andrzej | Bachleda | | | | | plyn do naczyn | | Jan | Kowalski | | | | | plyn do naczyn | | Katarzyna | Nowicka | | | | | plyn do naczyn | | Andrzej | Bachleda | |
144
Złączenia - Join Przykład: - equi-join:
- equi-join: select * from Koszyk inner join Klienci using(ID_klient); | ID_klient | ID_koszyk | nazwa_produktu | imie | nazwisko | PESEL | | | | chleb | Jan | Kowalski | | | | | szynka | Jan | Kowalski | | | | | proszek do prania | Anna | Nowakowska | | | | | plyn do naczyn | Anna | Nowakowska | | | | | maslo | Katarzyna | Nowicka | | | | | chleb | Katarzyna | Nowicka | | | | | jablko | Andrzej | Bachleda | | | | | jogurt | Andrzej | Bachleda | |
145
Złączenia - Join Przykład: - natural join:
- natural join: select * from Koszyk natural join Klienci; | ID_klient | ID_koszyk | nazwa_produktu | imie | nazwisko | PESEL | | | | chleb | Jan | Kowalski | | | | | szynka | Jan | Kowalski | | | | | proszek do prania | Anna | Nowakowska | | | | | plyn do naczyn | Anna | Nowakowska | | | | | maslo | Katarzyna | Nowicka | | | | | chleb | Katarzyna | Nowicka | | | | | jablko | Andrzej | Bachleda | | | | | jogurt | Andrzej | Bachleda | |
146
Złączenia - Join Przykład: - cross join:
- cross join: select * from Koszyk cross join Klienci; select * from Koszyk, Klienci; | ID_koszyk | ID_klient | nazwa_produktu | ID_klient | imie | nazwisko | PESEL | | | | chleb | | Jan | Kowalski | | | | | chleb | | Anna | Nowakowska | | | | | chleb | | Katarzyna | Nowicka | | | | | chleb | | Andrzej | Bachleda | | | | | maslo | | Jan | Kowalski | | | | | maslo | | Anna | Nowakowska | | | | | maslo | | Katarzyna | Nowicka | | | | | maslo | | Andrzej | Bachleda | | | | | szynka | | Jan | Kowalski | | | | | szynka | | Anna | Nowakowska | | | | | szynka | | Katarzyna | Nowicka | | | | | szynka | | Andrzej | Bachleda | | | | | chleb | | Jan | Kowalski | | | | | chleb | | Anna | Nowakowska | | | | | chleb | | Katarzyna | Nowicka | | | | | chleb | | Andrzej | Bachleda | | | | | jablko | | Jan | Kowalski | | | | | jablko | | Anna | Nowakowska | | | | | jablko | | Katarzyna | Nowicka | | | | | jablko | | Andrzej | Bachleda | | | | | jogurt | | Jan | Kowalski | | | | | jogurt | | Anna | Nowakowska | | | | | jogurt | | Katarzyna | Nowicka | | | | | jogurt | | Andrzej | Bachleda | | | | | proszek do prania | | Jan | Kowalski | | | | | proszek do prania | | Anna | Nowakowska | | | | | proszek do prania | | Katarzyna | Nowicka | | | | | proszek do prania | | Andrzej | Bachleda | | | | | plyn do naczyn | | Jan | Kowalski | | | | | plyn do naczyn | | Anna | Nowakowska | | | | | plyn do naczyn | | Katarzyna | Nowicka | | | | | plyn do naczyn | | Andrzej | Bachleda | |
147
Złączenia - Join Przykład: - left outer join:
- left outer join: select * from Koszyk left outer join Klienci on Klienci.ID_klient=Koszyk.ID_klient; | ID_koszyk | ID_klient | nazwa_produktu | ID_klient | imie | nazwisko | PESEL | | | | chleb | | Jan | Kowalski | | | | | maslo | | Katarzyna | Nowicka | | | | | szynka | | Jan | Kowalski | | | | | chleb | | Katarzyna | Nowicka | | | | | jablko | | Andrzej | Bachleda | | | | | jogurt | | Andrzej | Bachleda | | | | | proszek do prania | | Anna | Nowakowska | | | | | plyn do naczyn | | Anna | Nowakowska | |
148
Złączenia - Join Przykład: - left outer join:
- left outer join: select * from Koszyk left outer join Klienci on Klienci.ID_klient=Koszyk.ID_klient; | ID_koszyk | ID_klient | nazwa_produktu | ID_klient | imie | nazwisko | PESEL | | | | chleb | | Jan | Kowalski | | | | | maslo | | Katarzyna | Nowicka | | | | | szynka | | Jan | Kowalski | | | | | chleb | | Katarzyna | Nowicka | | | | | jablko | | Andrzej | Bachleda | | | | | jogurt | | Andrzej | Bachleda | | | | | proszek do prania | | Anna | Nowakowska | | | | | plyn do naczyn | | Anna | Nowakowska | | Po wykonaniu polecenia: update Koszyk set ID_klient = 5 where ID_klient = 1; | | | chleb | NULL | NULL | NULL | NULL | | | | szynka | NULL | NULL | NULL | NULL |
149
Złączenia - Join Przykład:
Składnia full outer join nie jest obsługiwana przez MySQL, natomiast można zastąpić ją następującym podejściem: select * from Koszyk left outer join Klienci on Klienci.ID_klient=Koszyk.ID_klient union select * from Koszyk right outer join Klienci on Klienci.ID_klient = Koszyk.ID_klient; | ID_koszyk | ID_klient | nazwa_produktu | ID_klient | imie | nazwisko | PESEL | | | | chleb | NULL | NULL | NULL | NULL | | | | maslo | | Katarzyna | Nowicka | | | | | szynka | NULL | NULL | NULL | NULL | | | | chleb | | Katarzyna | Nowicka | | | | | jablko | | Andrzej | Bachleda | | | | | jogurt | | Andrzej | Bachleda | | | | | proszek do prania | | Anna | Nowakowska | | | | | plyn do naczyn | | Anna | Nowakowska | | | NULL | NULL | NULL | | Jan | Kowalski | |
150
Złączenia - Join Przykład: - self-join:
- self-join: select * from Koszyk K1, Koszyk K2 where K1.ID_klient = K2.ID_klient; | ID_koszyk | ID_klient | nazwa_produktu | ID_koszyk | ID_klient | nazwa_produktu | | | | chleb | | | chleb | | | | szynka | | | chleb | | | | maslo | | | maslo | | | | chleb | | | maslo | | | | chleb | | | szynka | | | | szynka | | | szynka | | | | maslo | | | chleb | | | | chleb | | | chleb | | | | jablko | | | jablko | | | | jogurt | | | jablko | | | | jablko | | | jogurt | | | | jogurt | | | jogurt | | | | proszek do prania | | | proszek do prania | | | | plyn do naczyn | | | proszek do prania | | | | proszek do prania | | | plyn do naczyn | | | | plyn do naczyn | | | plyn do naczyn |
151
Widoki
152
Widoki Widok – jest to wirtualna tabela stworzona na podstawie zapytań, najczęściej zawierających złączenia wielu tabel. Widok nie przechowuje danych, natomiast pokazuje dane z tabel wchodzących w jego budowę. Przy założeniu jednoznaczności odwołań do danych, dane, które reprezentuje widok można edytować i usuwać odwołując się bezpośrednio do widoku, tak jak do tabeli.
153
Widoki Uproszczony schemat tworzenia widoku: CREATE [OR REPLACE]
VIEW view_name [(column_list)] AS select_statement Przykład: create or replace view Historia_odwiedzin as select imie, nazwisko, login, dataiczas, IP from Uzytkownicy left join Historia_logowania using(ID_uzytkownika);
154
Widoki Uproszczony schemat usuwania widoku:
DROP VIEW [IF EXISTS] view_name Przykład: drop view if exists Historia_odwiedzin;
155
Widoki Uproszczony schemat zmiany struktury widoku:
ALTER VIEW view_name [(column_list)] AS select_statement Ostateczny efekt jest taki sam jak polecenia create or replace view.
156
Widoki Informacje o widoku:
Szczegóły widoków znajdują się w tabeli: information_schema.views Wyświetlenie ciała widoku: show create table nazwa_widoku
157
Procedury
158
Procedury Procedura – jest to zestaw sekwencji poleceń do wykonania. Procedura może zwracać wartości wyprowadzone poprzez zmienne. W procedurze mogą zostać zawarte polecenia SQL (w przeciwieństwie do funkcji). Wyświetlanie listy procedur: show procedure status [like '%nazwa%'] Wyświetlanie ciała procedury: show create procedure [nazwa] Tabela opisująca procedury i funkcje: information_schema.routines
159
Procedury Uproszczony schemat tworzenia procedury: CREATE
PROCEDURE sp_name ([proc_parameter[,...]]) routine_body proc_parameter: [ IN | OUT | INOUT ] param_name type type: Any valid MySQL data type routine_body: Valid SQL routine statement
160
Procedury Przykład: delimiter | drop procedure if exists procedura |
create procedure procedura (out p1 int, out p2 int, in vnazwisko varchar(40)) begin set p1=1; select 'Wynik dzialania procedury.' as info; select * from Klienci where lower(nazwisko) = lower(vnazwisko); select count(*) into p2 from Klienci where nazwisko like concat('%', vnazwisko, '%'); select p2; end | delimiter ;
161
Procedury Przykład cd:
'Kowal'); - wywołanie procedury select wyświetlenie zmiennych zwróconych przez procedurę
162
Procedury Przykład 2 - rekurencja: Efekt: delimiter |
create procedure liczby (in liczba int) begin set liczba = liczba -1; select liczba; if liczba > 0 then call liczby(liczba); end if; end | delimiter ; Efekt: mysql> call liczby(4); | liczba | | | 1 row in set | | | | | | Query OK, 0 rows affected
163
Procedury – program Navicat
164
Procedury – program Navicat
165
Procedury – program Navicat
166
Procedury – program Navicat
mysqli_query($link, "call dodaj_uzytkownika('jan','tajne_haslo');");
167
Funkcje
168
Funkcje Funkcja – podobnie jak procedura, jest to zestaw sekwencji poleceń do wykonania. W odróżnieniu od procedury, funkcja zwraca wartość nie poprzez zmienną będącą składową parametrów, ale standardowo – jak w innych językach programowania. Funkcja nie posiada możliwości wykonywania zapytań SQL. Wyświetlenie listy funkcji: show function status [like '%nazwa%'] Wyświetlenie ciała funkcji: show create function [nazwa] Tabela opisująca procedury i funkcje: information_schema.routines
169
Funkcje Uproszczony schemat tworzenia funkcji: CREATE
FUNCTION sp_name ([func_parameter[,...]]) RETURNS type routine_body func_parameter: param_name type type: Any valid MySQL data type routine_body: Valid SQL routine statement
170
Funkcje Przykład: Wywołanie funkcji:
delimiter | drop function if exists nazwiska_klientow | create function nazwiska_klientow (vnazwisko varchar(40)) returns int begin declare zm int; select count(*) into zm from Klienci where lower(nazwisko)=lower(vnazwisko); return zm; end | delimiter ; Wywołanie funkcji: select nazwiska_klientow('Kowalski');
171
Funkcje – program Navicat
172
Funkcje – program Navicat
173
Elementy języka programowania
174
Elementy języka programowania
Loop While Do If Iterate Leave Case
175
Triggery - wyzwalacze
176
Triggery - wyzwalacze Trigger – służy do automatycznego wykonania poleceń proceduralnych, po zajściu danego zdarzenia na tabeli w bazie danych. Uproszczony schemat tworzenia triggera: CREATE TRIGGER trigger_name trigger_time trigger_event ON tbl_name FOR EACH ROW trigger_body trigger_time: before, after trigger_event: insert, update, delete
177
Triggery - wyzwalacze Przykład: delimiter |
create trigger t_Klienci_insert before insert on Klienci for each row begin if lower(NEW.imie) = NEW.imie then set NEW.imie = Upper(NEW.imie); end if; end | delimiter ;
178
Triggery - wyzwalacze Schemat usuwania triggera:
DROP TRIGGER [IF EXISTS] [schema_name.]trigger_name Przykład: drop trigger if exists t_Klienci_insert;
179
Triggery - wyzwalacze SIGNAL SQLSTATE '45000'
SET MESSAGE_TEXT = 'Nie mogę dodać wartości';
180
Transakcje
181
Transakcje Transakcja – jest to zbiór operacji, który ma za zadanie wykonać się w całości lub wcale. Transakcję charakteryzują zasady ACID: Atomicity – Atomowość Consistency – Spójność Isolation – Izolacja Durability – Trwałość
182
Transakcje Transakcja składa się z trzech etapów:
rozpoczęcia transakcji, polecenia: start transaction lub begin wykonywanie sekwencji poleceń. Istnieje możliwość przerwania transakcji lub ewentualnego cofnięcia do wcześniej zapisanego stanu za pomocą polecenia savepoint nazwa zakończenia transakcji, polecenia: commit (zatwierdzenie nowego stanu danych), rollback (cofnięcie transakcji) lub rollback to nazwa, cofnięcie się do punktu zapisu. Zerwane połączenie z bazą danych anuluje wprowadzone zmiany.
183
Transakcje Automatyczne kończenie transakcji ma miejsce po następujących poleceniach: alter table, create index, create table, drop database, drop table, lock tables, rename table, set autocommit = 1, truncate, unlock tables.
184
Transakcje Parametry ograniczające dostęp do danych:
klauzula for update – wywoływana jest w poleceniu select, blokuje tabelę do momentu zatwierdzenia lub cofnięcia transakcji. Inna transakcja nie może założyć blokady; klauzula lock in share mode – wywoływana jest w poleceniu select, działa podobnie jak blokada omawiana powyżej, natomiast umożliwia innym transakcjom założenie blokady na tą samą tabelę. poziomy (stopnie) izolacji – umożliwiają określenie domyślnej izolacji transakcji od innych transakcji oraz wolnych poleceń SQL.
185
Transakcje Poziomy izolacji transakcji:
READ UNCOMMITTED – zmiany wykonywane przez polecenia wewnątrz transakcji są na bieżąco widoczne poza nią, pomimo nie zatwierdzenia poleceniem commit. READ COMMITTED – zmiany wykonane przez polecenia wewnątrz transakcji są widoczne dopiero po zatwierdzeniu poleceniem commit. REPEATABLE READ – zmiany wykonane przez polecenia wewnątrz jednej transakcji nie są widoczne w drugiej transakcji, nawet pomimo zatwierdzenia ich poleceniem commit. Tryb domyślnie używany przez silnik InnoDB. SERIALIZABLE – działa tak samo jak REPEATABLE READ i dodatkowo blokuje wiersze odczytywane przez pierwszą transakcję – tak jak klauzula lock in share mode.
186
Transakcje Poziomy izolacji transakcji:
Sprawdzanie aktualnego poziomu izolacji: mysql> select | | | REPEATABLE-READ |
187
Transakcje Poziomy izolacji transakcji: Ustawienie poziomu izolacji:
mysql> set session transaction isolation level read uncommitted; Query OK, 0 rows affected (0.00 sec) mysql> set session transaction isolation level repeatable read;
188
Transakcje Przykład: begin; select * from Klienci for update;
insert into Klienci (imie, nazwisko, PESEL) values ('Jan','Kowalski',' '); commit;
189
Transakcje Przykład: delimiter | drop procedure pr11 |
create procedure pr11() begin start transaction; select * from Klienci for update; savepoint pierwszy_insert; insert into Klienci (imie, nazwisko, PESEL) values ('Jan','Kowalski',' '); savepoint drugi_insert; insert into Klienci (imie, nazwisko, PESEL) values ('Anna','Nowak',' '); (select count(*) from Klienci where nazwisko = 'Nowak'); then rollback to savepoint drugi_insert; end if; commit; end | delimiter ;
190
Transakcje Przykład fragmentu aplikacji
191
Transakcje Read uncommitted
Niezatwierdzony odczyt (dirty reads) - transakcje mają dostęp do modyfikacji wprowadzonych przez inne transakcje, nawet jeszcze nie zatwierdzone. Odczytywane są niezatwierdzone dane. Niepowtarzalny odczyt (nonrepeatable (fuzzy) reads) - każdy kolejny odczyt danych przez jedną transakcję może zwrócić inne wyniki. Dane zostały w międzyczasie zmodyfikowane przez równoległą, zatwierdzoną transakcję. Fantomy (phantom reads) - każdy kolejny odczyt danych przez jedną transakcję, może zwrócić inne wyniki. Dane zostały w międzyczasie dodane przez równoległą, zatwierdzoną transakcję.
192
Transakcje Read committed
Niezatwierdzony odczyt (dirty reads) - transakcje mają dostęp do modyfikacji wprowadzonych przez inne transakcje, nawet jeszcze nie zatwierdzone. Odczytywane są niezatwierdzone dane. Niepowtarzalny odczyt (nonrepeatable (fuzzy) reads) - każdy kolejny odczyt danych przez jedną transakcję może zwrócić inne wyniki. Dane zostały w międzyczasie zmodyfikowane przez równoległą, zatwierdzoną transakcję. Fantomy (phantom reads) - każdy kolejny odczyt danych przez jedną transakcję, może zwrócić inne wyniki. Dane zostały w międzyczasie dodane przez równoległą, zatwierdzoną transakcję.
193
Transakcje
194
Transakcje Read uncommitted – przykład fragmentu aplikacji
mysql> set session transaction isolation level read uncommitted; Query OK, 0 rows affected mysql> select * from pliki; | ID_pliki | nazwa | zawartosc_binarna | | | obrazek | | | | program | | | | tekst | | 3 rows in set mysql> select * from uzytkownicy_pliki; | ID_uzytkownicy | ID_pliki | | | | | | | | | | mysql> set session transaction isolation level read uncommitted; Query OK, 0 rows affected mysql> select * from pliki; | ID_pliki | nazwa | zawartosc_binarna | | | obrazek | | | | program | | | | tekst | | 3 rows in set mysql> select * from uzytkownicy_pliki; | ID_uzytkownicy | ID_pliki | | | | | | | | | |
195
Transakcje Read uncommitted – przykład fragmentu aplikacji
mysql> begin; Query OK, 0 rows affected mysql> delete from uzytkownicy_pliki where ID_uzytkownicy = 2 and ID_pliki = 2; Query OK, 1 row affected mysql> select * from uzytkownicy_pliki; | ID_uzytkownicy | ID_pliki | | | | | | | 2 rows in set mysql> rollback; mysql> mysql> begin; Query OK, 0 rows affected mysql> select * from uzytkownicy_pliki; | ID_uzytkownicy | ID_pliki | | | | | | | 2 rows in set mysql> insert into uzytkownicy_pliki values (2,2); --tutaj SZBD czeka! Duplicate entry '2-2' for key 'PRIMARY' mysql>
196
Transakcje Read committed – przykład fragmentu aplikacji
mysql> set session transaction isolation level read committed; Query OK, 0 rows affected mysql> begin; mysql> select * from uzytkownicy; | ID_uzytkownicy | login | haslo | | | ala | 1b95538f3035f4cba fd96173c | | | jan | 1b95538f3035f4cba fd96173c | | | michal | 1b95538f3035f4cba fd96173c | | | edyta | ccb44feb4d7dadca005ce29a64 | 4 rows in set mysql> insert into uzytkownicy values (null, 'alex', ''); Query OK, 1 row affected mysql> commit; mysql> mysql> set session transaction isolation level read committed; Query OK, 0 rows affected mysql> begin; mysql> select * from uzytkownicy; | ID_uzytkownicy | login | haslo | | | ala | 1b95538f3035f4cba fd96173c | | | jan | 1b95538f3035f4cba fd96173c | | | michal | 1b95538f3035f4cba fd96173c | | | edyta | ccb44feb4d7dadca005ce29a64 | 4 rows in set | | alex | | 5 rows in set mysql> commit;
197
Transakcje Read committed – przykład fragmentu aplikacji
mysql> set session transaction isolation level read committed; Query OK, 0 rows affected mysql> begin; mysql> select * from uzytkownicy; | ID_uzytkownicy | login | haslo | | | ala | 1b95538f3035f4cba fd96173c | | | jan | 1b95538f3035f4cba fd96173c | | | michal | 1b95538f3035f4cba fd96173c | | | edyta | ccb44feb4d7dadca005ce29a64 | 4 rows in set mysql> insert into uzytkownicy values (null, 'alex',''); Query OK, 1 row affected mysql> rollback; mysql> set session transaction isolation level read committed; Query OK, 0 rows affected mysql> begin; mysql> select * from uzytkownicy; | ID_uzytkownicy | login | haslo | | | ala | 1b95538f3035f4cba fd96173c | | | jan | 1b95538f3035f4cba fd96173c | | | michal | 1b95538f3035f4cba fd96173c | | | edyta | ccb44feb4d7dadca005ce29a64 | 4 rows in set mysql> insert into uzytkownicy values (null, 'alex',''); --tutaj SZBD czeka!!!! Query OK, 1 row affected mysql> commit;
198
Transakcje Repeatable read
Niezatwierdzony odczyt (dirty reads) - transakcje mają dostęp do modyfikacji wprowadzonych przez inne transakcje, nawet jeszcze nie zatwierdzone. Odczytywane są niezatwierdzone dane. Niepowtarzalny odczyt (nonrepeatable (fuzzy) reads) - każdy kolejny odczyt danych przez jedną transakcję może zwrócić inne wyniki. Dane zostały w międzyczasie zmodyfikowane przez równoległą, zatwierdzoną transakcję. Fantomy (phantom reads) - każdy kolejny odczyt danych przez jedną transakcję, może zwrócić inne wyniki. Dane zostały w międzyczasie dodane przez równoległą, zatwierdzoną transakcję.
199
Transakcje Repeatable read
Niezatwierdzony odczyt (dirty reads) - transakcje mają dostęp do modyfikacji wprowadzonych przez inne transakcje, nawet jeszcze nie zatwierdzone. Odczytywane są niezatwierdzone dane. Niepowtarzalny odczyt (nonrepeatable (fuzzy) reads) - każdy kolejny odczyt danych przez jedną transakcję może zwrócić inne wyniki. Dane zostały w międzyczasie zmodyfikowane przez równoległą, zatwierdzoną transakcję. Fantomy (phantom reads) - każdy kolejny odczyt danych przez jedną transakcję, może zwrócić inne wyniki. Dane zostały w międzyczasie dodane przez równoległą, zatwierdzoną transakcję. MySQL ->
200
Transakcje Repeatable read – przykład fragmentu aplikacji [1]
mysql> set session transaction isolation level repeatable read; Query OK, 0 rows affected mysql> begin; mysql> select * from uzytkownicy; | ID_uzytkownicy | login | haslo | | | ala | 1b95538f3035f4cba fd96173c | | | jan | 1b95538f3035f4cba fd96173c | | | michal | 1b95538f3035f4cba fd96173c | | | edyta | ccb44feb4d7dadca005ce29a64 | | | alex | | 5 rows in set mysql> delete from uzytkownicy where ID_uzytkownicy = 8; Query OK, 1 row affected mysql> insert into uzytkownicy values (null, 'monika', ''); mysql> set session transaction isolation level repeatable read; Query OK, 0 rows affected mysql> begin; mysql> select * from uzytkownicy; | ID_uzytkownicy | login | haslo | | | ala | 1b95538f3035f4cba fd96173c | | | jan | 1b95538f3035f4cba fd96173c | | | michal | 1b95538f3035f4cba fd96173c | | | edyta | ccb44feb4d7dadca005ce29a64 | | | alex | | 5 rows in set
201
Transakcje Repeatable read – przykład fragmentu aplikacji [2]
mysql> select * from uzytkownicy; | ID_uzytkownicy | login | haslo | | | ala | 1b95538f3035f4cba fd96173c | | | jan | 1b95538f3035f4cba fd96173c | | | michal | 1b95538f3035f4cba fd96173c | | | edyta | ccb44feb4d7dadca005ce29a64 | | | monika | | 5 rows in set mysql> commit; Query OK, 0 rows affected mysql> select * from uzytkownicy; | ID_uzytkownicy | login | haslo | | | ala | 1b95538f3035f4cba fd96173c | | | jan | 1b95538f3035f4cba fd96173c | | | michal | 1b95538f3035f4cba fd96173c | | | edyta | ccb44feb4d7dadca005ce29a64 | | | alex | | 5 rows in set mysql> insert into uzytkownicy values (null, 'monika', ''); -- tutaj SZBD czeka! Duplicate entry 'monika' for key 'uniq_uzytkownicy_login' mysql> commit; Query OK, 0 rows affected | | monika | |
202
Transakcje Repeatable read – przykład fragmentu aplikacji
mysql> begin; Query OK, 0 rows affected mysql> select * from uzytkownicy; | ID_uzytkownicy | login | haslo | | | ala | 1b95538f3035f4cba fd96173c | | | jan | 1b95538f3035f4cba fd96173c | | | michal | 1b95538f3035f4cba fd96173c | | | edyta | ccb44feb4d7dadca005ce29a64 | | | monika | | 5 rows in set mysql> insert into uzytkownicy values (null, 'franek', ''); Query OK, 1 row affected mysql> delete from uzytkownicy where login='monika'; mysql> commit; mysql> begin; Query OK, 0 rows affected mysql> select * from uzytkownicy; | ID_uzytkownicy | login | haslo | | | ala | 1b95538f3035f4cba fd96173c | | | jan | 1b95538f3035f4cba fd96173c | | | michal | 1b95538f3035f4cba fd96173c | | | edyta | ccb44feb4d7dadca005ce29a64 | | | franek | | 5 rows in set
203
Transakcje Serializable
Niezatwierdzony odczyt (dirty reads) - transakcje mają dostęp do modyfikacji wprowadzonych przez inne transakcje, nawet jeszcze nie zatwierdzone. Odczytywane są niezatwierdzone dane. Niepowtarzalny odczyt (nonrepeatable (fuzzy) reads) - każdy kolejny odczyt danych przez jedną transakcję może zwrócić inne wyniki. Dane zostały w międzyczasie zmodyfikowane przez równoległą, zatwierdzoną transakcję. Fantomy (phantom reads) - każdy kolejny odczyt danych przez jedną transakcję, może zwrócić inne wyniki. Dane zostały w międzyczasie dodane przez równoległą, zatwierdzoną transakcję.
204
Transakcje Repeatable read – przykład fragmentu aplikacji
mysql> set session transaction isolation level serializable; Query OK, 0 rows affected mysql> begin; mysql> select * from uzytkownicy; | ID_uzytkownicy | login | haslo | | | ala | 1b95538f3035f4cba fd96173c | | | jan | 1b95538f3035f4cba fd96173c | | | michal | 1b95538f3035f4cba fd96173c | | | edyta | ccb44feb4d7dadca005ce29a64 | 4 rows in set mysql> commit; -- tutaj SZBD czeka! | | monika | | | | franek | | mysql> set session transaction isolation level serializable; Query OK, 0 rows affected mysql> begin; mysql> select * from uzytkownicy; | ID_uzytkownicy | login | haslo | | | ala | 1b95538f3035f4cba fd96173c | | | jan | 1b95538f3035f4cba fd96173c | | | michal | 1b95538f3035f4cba fd96173c | | | edyta | ccb44feb4d7dadca005ce29a64 | 4 rows in set mysql> insert into uzytkownicy values (null, 'monika', ''); --tutaj SZBD czeka! Query OK, 1 row affected mysql> insert into uzytkownicy values (null, 'franek', ''); mysql> commit;
205
PHP i Transakcje Istotne funkcje: mysqli_autocommit($link,FALSE);
mysqli_commit($link); mysqli_rollback($link) mysqli_query($link, "SET autocommit=0;"); mysqli_query($link, "commit;") mysqli_query($link, "rollback;") mysqli_insert_id($link);
206
PHP i Transakcje Przykładowe fragmenty funkcjonalności aplikacji do rozważenia rejestracja użytkownika – umieszczenie danych w kilku tabelach, np. takich jak: użytkownicy, pliki użytkowników, kilku użytkowników w jednym czasie chce zarejestrować ten sam login
207
PHP i Transakcje Przykładowe fragmenty funkcjonalności aplikacji do rozważenia koszyk zakupów – nie można zamówić produktu, jeżeli nie ma go na stanie magazynu. W trakcie wyboru produktu był jeszcze na stanie i jednocześnie w koszyku innego użytkownika jako ostatni egzemplarz.
208
PHP i Transakcje Przykładowe fragmenty funkcjonalności aplikacji do rozważenia rezerwacja przedmiotów wybieralnych przez studentów z poziomu systemu. Limity na przedmiot o danej godzinie.
209
PHP i Transakcje Przykładowe fragmenty funkcjonalności aplikacji do rozważenia rezerwacja biletów lotniczych, wybór biletu rezerwuje go na czas trwania sesji. Oprogramować moment wyboru biletu z uwzględnieniem wielu użytkowników dokonujących tej samej rezerwacji w danej chwili.
210
PHP i Transakcje Przykładowe fragmenty funkcjonalności aplikacji do rozważenia przelew bankowy – wykonywany przez dwóch współwłaścicieli konta w jednakowym czasie, z różnych komputerów, z uwzględnieniem debetu.
211
C. D. N.
Podobne prezentacje
© 2024 SlidePlayer.pl Inc.
All rights reserved.