IDZ DO
IDZ DO
PRZYKŁADOWY ROZDZIAŁ
PRZYKŁADOWY ROZDZIAŁ
Perl
SPIS TRE CI
SPIS TRE CI
Autor: Reuven M. Lerner
KATALOG KSIĄŻEK
KATALOG KSIĄŻEK
Tłumaczenie: M. Michalski, S. Dzieniszewski
ISBN: 83-7361-169-X
KATALOG ONLINE
KATALOG ONLINE
Tytuł oryginału: Core Perl
Format: B5, stron: 45
ZAMÓW DRUKOWANY KATALOG
ZAMÓW DRUKOWANY KATALOG
Przykłady na ftp: 61 kB
TWÓJ KOSZYK
TWÓJ KOSZYK
Ten kompletny przewodnik po Perlu szybko i wygodnie dostarcza do wiadczonym
DODAJ DO KOSZYKA
DODAJ DO KOSZYKA
programistom odpowiednich technik i ilustrujących je praktycznych przykładów kodu.
Lektura tej książki pozwoli Ci najpierw rozwinąć swoje dotychczasowe umiejętno ci,
a następnie zgłębić tajniki podstawowych technik programowania w Perlu. Książka
CENNIK I INFORMACJE
CENNIK I INFORMACJE
rozpoczyna się opisem podstawowej składni języka, przechodzi pó niej do obiektów,
struktur danych i zasad przetwarzania tekstu. Następnie wyja nia, jak korzystać
ZAMÓW INFORMACJE
ZAMÓW INFORMACJE
z dostarczonych przez Perl narzędzi umożliwiających pracę z plikami, działanie
O NOWO CIACH
O NOWO CIACH
programów w sieci czy współpracę z relacyjnymi bazami danych. Na koniec pokazuje,
jak wykorzystać pełnię możliwo ci Perla podczas tworzenia aplikacji WWW zarówno
ZAMÓW CENNIK
ZAMÓW CENNIK
prostych skryptów CGI, jak i w pełni zaawansowanych narzędzi obsługujących
witryny WWW.
Opisano między innymi:
CZYTELNIA
CZYTELNIA
" Typy danych i podstawowe funkcje Perla
FRAGMENTY KSIĄŻEK ONLINE
FRAGMENTY KSIĄŻEK ONLINE
" Zasady pisania i korzystania z modułów Perla
" Sposoby korzystania z plików tekstowych i plików DBM
" Interfejs DBI pozwalający na korzystanie z baz danych i integrowanie baz danych
ze stronami WWW
" Programy CGI, moduły mod_perl dla serwera Apache, cookie protokołu HTTP
oraz szablony HTML/Perla
" Mason: oparty na Perlu system tworzenia zaawansowanych witryn WWW
" Wykrywanie i usuwanie błędów, optymalizacja kodu oraz sprawy związane
z bezpieczeństwem
Od wielu już lat programi ci na całym wiecie doceniają Perla za jego prostotę, wygodę
i uniwersalną zdolno ć do rozwiązywania szerokiego zakresu problemów; począwszy
Wydawnictwo Helion od przetwarzania tekstu i administrowania systemem operacyjnym po komunikację
ul. Chopina 6
z bazami danych i tworzenie stron WWW. Książka Perl dostarcza programistom
44-100 Gliwice
wiedzy niezbędnej do tworzenia wszechstronnych, przejrzystych i bardzo wydajnych
tel. (32)230-98-63
programów niezależnie jakie będą zadania tworzonych przez niego aplikacji.
e-mail: helion@helion.pl
Spis treści
Przedmowa .................................................................................................................................................. 9
Rozdział 1. Czym jest Perl? ........................................................................................................................ 15
1.1. Czym jest Perl?...................................................................................................... 15
1.2. Do czego Perl się nie nadaje? ................................................................................. 17
1.3. Licencje ................................................................................................................ 17
1.4. Wersje i standardy Perla......................................................................................... 18
1.5. Wsparcie techniczne .............................................................................................. 18
1.6. Pobieranie i instalacja Perla.................................................................................... 19
1.7. Pobieranie modułów z CPAN ................................................................................... 22
1.8. Podsumowanie ...................................................................................................... 25
Rozdział 2. Pierwsze kroki ....................................................................................................................... 27
2.1. Najprostsze programy............................................................................................. 28
2.2. Kompilator czy interpreter? ..................................................................................... 29
2.3. Wyrażenia i bloki.................................................................................................... 30
2.4. Zmienne................................................................................................................ 31
2.5. Skalary ................................................................................................................. 32
2.6. Listy i tablice......................................................................................................... 41
2.7. Tablice asocjacyjne ................................................................................................ 48
2.8. Odwołania ............................................................................................................. 52
2.9. Zmienne leksykalne i globalne ................................................................................ 58
2.10. Podsumowanie .................................................................................................... 60
Rozdział 3. Kroki następne......................................................................................................................... 61
3.1. Podstawowe funkcje wyjścia ................................................................................... 62
3.2. Czas ..................................................................................................................... 64
3.3. Podstawowe funkcje wejścia................................................................................... 65
3.4. Operacje warunkowe .............................................................................................. 66
3.5. Operatory porównania ............................................................................................ 70
3.6. Operatory logiczne ................................................................................................. 72
3.7. Kolejność wykonywania operacji.............................................................................. 73
3.8. Pętle..................................................................................................................... 74
6 Perl
3.9. Sortowanie............................................................................................................ 79
3.10. Pliki .................................................................................................................... 81
3.11. Zmienne wewnętrzne............................................................................................ 85
3.12. Funkcje przekształcające dane .............................................................................. 87
3.13. Uruchamianie programów zewnętrznych ................................................................. 92
3.14. Funkcja fork......................................................................................................... 95
3.15. Funkcja eval ........................................................................................................ 97
3.16. Podsumowanie .................................................................................................... 99
Rozdział 4. Procedury ...............................................................................................................................101
4.1. Informacje podstawowe........................................................................................ 102
4.2. Wartości zwracane ............................................................................................... 102
4.3. Zmienne w procedurach ....................................................................................... 108
4.4. Argumenty procedur ............................................................................................. 112
4.5. Odwołania do procedur......................................................................................... 114
4.6. Bloki BEGIN i END................................................................................................ 116
4.7. Sygnały ............................................................................................................... 119
4.8. Podsumowanie .................................................................................................... 121
Rozdział 5. Wzorce tekstowe ..................................................................................................................123
5.1. Czym są wzorce tekstowe? ................................................................................... 124
5.2. Metaznaki ........................................................................................................... 126
5.3. Wyszukiwanie zakotwiczone .................................................................................. 129
5.4. Klasy znaków....................................................................................................... 130
5.5. Predefiniowane klasy znaków................................................................................ 131
5.6. Nawiasy .............................................................................................................. 133
5.7. Pobieranie części łańcucha................................................................................... 133
5.8. Podstawianie....................................................................................................... 136
5.9. Zachłanność........................................................................................................ 137
5.10. Opcje dopasowywania i podstawiania .................................................................. 137
5.11. Funkcja study .................................................................................................... 141
5.12. Obiekty wzorców ................................................................................................ 141
5.13. Operator tr/// ................................................................................................... 142
5.14. Zastępowanie tekstów w wielu plikach................................................................. 144
5.15. Funkcja grep...................................................................................................... 144
5.16. Podsumowanie .................................................................................................. 145
Rozdział 6. Moduły ....................................................................................................................................147
6.1. Pakiety................................................................................................................ 147
6.2. Moduły................................................................................................................ 152
6.3. Eksportowanie symboli......................................................................................... 155
6.4. Kilka przykładowych modułów ............................................................................... 157
6.5. Dokumentowanie modułów przy użyciu formatu POD ............................................... 161
6.6. Podsumowanie .................................................................................................... 164
Rozdział 7. Obiekty....................................................................................................................................165
7.1. Obiekty ............................................................................................................... 166
7.2. Metody ............................................................................................................... 167
7.3. Dziedziczenie....................................................................................................... 170
7.4. Tworzenie obiektów i praca z nimi ......................................................................... 174
7.5. Podsumowanie .................................................................................................... 182
Spis treści 7
Rozdział 8. Wiązanie .................................................................................................................................183
8.1. Wiązanie ............................................................................................................. 184
8.2. Wiązanie skalarów ............................................................................................... 185
8.3. Wiązanie tablic asocjacyjnych ............................................................................... 189
8.4. Wiązanie tablic .................................................................................................... 198
8.5. Podsumowanie .................................................................................................... 201
Rozdział 9. Praca z plikami .....................................................................................................................203
9.1. Podstawy pracy z plikami...................................................................................... 204
9.2. Sięganie do dowolnego miejsca w pliku ................................................................. 206
9.3. Uchwyty plików .................................................................................................... 208
9.4. Korzystanie ze znaków globalnych ......................................................................... 214
9.5. Identyfikatory rzeczywiste i identyfikatory efektywne................................................ 215
9.6. Uprawnienia plikowe ............................................................................................ 217
9.7. Programy suid i sgid............................................................................................. 219
9.8. Testowanie plików za pomocą operatorów unarnych................................................ 220
9.9. Funkcja stat ........................................................................................................ 224
9.10. Blokowanie plików ............................................................................................. 225
9.11. Katalogi ............................................................................................................ 227
9.12. Zmienianie nazw oraz usuwanie plików i katalogów............................................... 230
9.13. Powiązania ........................................................................................................ 232
9.14. Podsumowanie .................................................................................................. 233
Rozdział 10. Programy sieciowe i komunikacja między procesami....................................................235
10.1. Potoki ............................................................................................................... 236
10.2. Komunikacja poprzez sieć................................................................................... 243
10.3. Współpraca z protokołami internetowymi ............................................................. 250
10.4. Podsumowanie .................................................................................................. 261
Rozdział 11. Relacyjne bazy danych ........................................................................................................263
11.1. Czym właściwie jest relacyjna baza danych?......................................................... 264
11.2. Wprowadzenie do języka SQL .............................................................................. 265
11.3. Zapytanie SELECT.............................................................................................. 269
11.4. Złączenia .......................................................................................................... 274
11.5. Aktualizowanie i usuwanie rekordów .................................................................... 274
11.6. Indeksy ............................................................................................................. 275
11.7. Perl i bazy danych .............................................................................................. 275
11.8. Proste programy korzystające z DBI ..................................................................... 279
11.9. Podsumowanie .................................................................................................. 282
Rozdział 12. Tworzenie aplikacji dla baz danych...................................................................................283
12.1. Projektowanie bazy danych ................................................................................. 283
12.2. Pisanie aplikacji................................................................................................. 290
12.3. Usuwanie błędów w programach korzystających z DBI ........................................... 303
12.4. Podsumowanie .................................................................................................. 306
Rozdział 13. Naprawianie programów i zagadnienia bezpieczeństwa................................................307
13.1. Identyfikowanie problemów................................................................................. 308
13.2. Gdy pojawi się problem ...................................................................................... 312
13.3. Tryb analizy zagrożeń.......................................................................................... 314
8 Perl
13.4. Wykrywanie i usuwanie błędów w kodzie .............................................................. 316
13.5. Szacowanie wydajności kodu .............................................................................. 323
13.6. Podsumowanie .................................................................................................. 326
Rozdział 14. Pisanie programów CGI ......................................................................................................327
14.1. Dynamiczne strony WWW.................................................................................... 327
14.2. Interfejs CGI ...................................................................................................... 332
14.3. Komunikaty o błędach i wykrywanie błędów w kodzie programów CGI ..................... 336
14.4. Przekierowanie do innej strony ............................................................................ 338
14.5. Inne metody modułu CGI .................................................................................... 341
14.6. Podsumowanie .................................................................................................. 342
Rozdział 15. Bardziej złożone programy CGI .........................................................................................343
15.1. Rejestracja użytkowników ................................................................................... 344
15.2. Cookies ............................................................................................................ 349
15.3. Tworzenie grafiki................................................................................................ 354
15.4. Szablony ........................................................................................................... 358
15.5. Podsumowanie .................................................................................................. 361
Rozdział 16. Aplikacje WWW korzystające z baz danych .....................................................................363
16.1. Aktualizowanie kursów akcji................................................................................ 364
16.2. Kartki pocztowe ................................................................................................. 373
16.3. Personalizacja stron WWW z pomocą bazy danych ................................................ 378
16.4. Podsumowanie .................................................................................................. 388
Rozdział 17. mod_perl..............................................................................................................................389
17.1. Instalowanie i konfiguracja mod_perl ................................................................... 390
17.2. Dyrektywy konfiguracyjne .................................................................................... 392
17.3. Trzy proste moduły obsługujące........................................................................... 393
17.4. Moduł Apache::Registry...................................................................................... 399
17.5. Przydatne moduły............................................................................................... 400
17.6. Podsumowanie .................................................................................................. 406
Rozdział 18. Mason...................................................................................................................................409
18.1. Pakiet Mason .................................................................................................... 409
18.2. Komponenty autohandler i dhandler .................................................................... 417
18.3. Komponent autohandler ..................................................................................... 417
18.4. Zarządzanie sesją użytkownika............................................................................ 419
18.5. Podsumowanie .................................................................................................. 426
Dodatek A Bibliografia .............................................................................................................................427
A.1. Książki poświęcone Perlowi .................................................................................. 427
A.2. Periodyki ............................................................................................................. 429
A.3. Książki o sieci WWW ............................................................................................ 429
A.4. Książki o bazach danych....................................................................................... 430
A.5. Użyteczne witryny WWW........................................................................................ 431
Skorowidz ................................................................................................................................................433
Tworzenie aplikacji dla baz danych
W tym rozdziale:
Projektowanie bazy danych
Tworzenie aplikacji dla baz danych
Wykrywanie błą dów w programach
Poprzedni rozdział był wprowadzeniem do zagadnień związanych z bazami danych, a w szcze-
gólności do ją zyka SQL i modułu . W tym rozdziale wykorzystamy te narzą dzia do przy-
gotowania zestawu aplikacji obsługujących bazą danych.
Po drodze przyjrzymy sią projektowaniu bazy danych, co podobnie jak w przypadku
projektowania programu jest kluczową, ale czą sto niedocenianą czą ścią procesu pro-
gramowania. W szczególności omówimy proces normalizacji, który poprawia efektywność
bazy danych i czyni ją bardziej elastyczną, redukując jednocześnie możliwość pojawienia
sią błą dów.
Aplikacje, które stworzymy, bą dą wykorzystywać zarówno techniki opisane w poprzednim
rozdziale, jak i nowe typy danych SQL oraz metody interfejsu . Przyjrzymy sią bliżej
metodzie , która ułatwia wykrywanie błą dów w zapytaniach SQL.
Rozdział ten dostarcza podstawowej wiedzy na temat procesu pisania programów współ-
działających z bazą danych, włączając w to projektowanie tabel i wykrywanie błą dów w przy-
gotowanych programach.
12.1. Projektowanie bazy danych
Nasze zadanie polega na skomputeryzowaniu katalogu książek sprzedawanych w pewnej
ksią garni. Zbudujemy bazą danych ksią garni w systemie PostgreSQL i napiszemy w Perlu
aplikacje, które pozwolą nam na obsługą danych zawartych w bazie.
284 Perl
Pierwszym krokiem podczas tworzenia aplikacji bazy danych jest zawsze stworzenie tabel.
Opiszą tutaj proces tworzenia prostego projektu bazy danych, omawiając pokrótce proble-
my pojawiające sią w wią kszości aplikacji baz danych.
12.1.1. Tabela Books
Ponieważ ksią garni potrzebny jest katalog książek oferowanych do sprzedaży, trzeba za-
cząć od przygotowania tabeli , której wiersze bą dą przechowywać dane o poszczegól-
nych książkach (identyfikator książki, kod ISBN, tytuł, autora, wydawcą , liczbą stron, datą
wydania oraz ceną książki):
Nasza tabela wygląda podobnie jak tabele, które prezentowałem w rozdziale 11.,
niemniej pojawia sią parą typów danych oraz ograniczeń, których jeszcze nie omawialiśmy:
kolumna daty wydania jest typu (data). Jest to typ bardzo podobny
do typu (znacznik czasu), ale zawiera samą datą , bez informacji
o godzinie;
kolumna ceny została zdefiniowana jako kolumna typu
, co oznacza, że może zawierać sześciocyfrowe liczby posiadające
dwie cyfry po przecinku. Tak wią c możemy sprzedawać książki o cenie do 9999,99
dolarów;
kolumna przechowuje niepowtarzalny i niezmienny kod ISBN (ang.
International Standard Book Number), który mógłby pełnić funkcją klucza głównego.
Niemniej kody ISBN są dość długie, a zazwyczaj dobrze jest, aby klucz główny
był tak krótki, jak to tylko możliwe. Aby upewnić sią , że wartości w kolumnie
bą dą niepowtarzalne (choć nie są one kluczem głównym), możemy dodać
do definicji tabeli ograniczenie , które automatycznie utworzy indeks
dla podanej kolumny.
Z technicznego punktu widzenia zaprezentowana tutaj definicja tabeli jest w pełni
poprawna. Niemniej w momencie, gdy zaczniemy korzystać z tej tabeli, ujawnią sią pewne
istotne problemy.
Rozdział 12. Tworzenie aplikacji dla baz danych 285
Załóżmy, że ksią garnia chciałaby przygotować katalog książek wydawnictwa Prentice-Hall.
Przedstawione tu zapytanie powinno pobrać nazwy wszystkich książek wydanych przez
Prentice-Hall:
Co sią jednak stanie, jeśli jedna z książek bą dzie miała w kolumnie wydawcą
podanego jako zamiast ? Taka książka oczywiście nie bą dzie
spełniać wymogów stawianych przez nasze zapytanie i w związku z tym nie trafi do katalogu.
Podobne problemy pojawiają sią również podczas wyszukiwania książek napisanych przez
określonego autora. Jeśli osoba wpisująca książką do bazy przez pomyłką zle wpisze na-
zwisko autora, to książka ta nie pojawi sią w odpowiedzi na zapytanie pobierające
autora ( ) o określonym nazwisku.
12.3.2. Normalizacja tabeli Books
Rozwiązaniem tego problemu jest normalizacja danych, która pozwala upewnić sią , że dane
wpisywane bą dą do bazy w jeden tylko sposób. Znormalizowane bazy danych cechuje znacz-
nie mniejsze ryzyko pojawienia sią uszkodzonych lub niezsynchronizowanych danych. Bazy
takie są również znacznie wydajniejsze niż bazy, które nie zostały znormalizowane.
Aby znormalizować tabelą , przygotujemy dwie nowe tabele: (wydawcy)
i (autorzy). Tabele te bą dą pozwalały na wpisanie każdego autora i każdego wy-
dawcy do bazy danych tylko raz. Dodatkowo wykorzystamy mechanizm kluczy obcych
wskazujących na te wartości (patrz: sekcja 11.3.6):
286 Perl
Warto zauważyć, że tabele te nakładają ograniczenie unikatowości na nazwą wydawnictwa,
ale nie nakładają go na nazwiska autorów. Może sią w końcu zdarzyć kilku autorów o na-
zwisku John Smith, ale raczej nie powinno istnieć wią cej niż jedno wydawnictwo o nazwie
Prentice Hall.
Znormalizowane tabele gwarantują, że nazwiska autorów i nazwy wydawnictw bą dą wy-
stą powały w tej samej formie w całej bazie danych. Co wią cej, zmiana nazwy wydawnic-
twa wymagać bą dzie teraz aktualizacji tylko jednego wiersza w tabeli zamiast
wielu wierszy w tabeli . Jakby tych korzyści było jeszcze mało, tabela zmniej-
szy znacznie swoje rozmiary dzią ki zastąpieniu dwóch kolumn typu kolumnami typu
. Znormalizowane tabele zajmować bą dą mniej miejsca na dysku i w pamią ci, co
przyspieszy działanie bazy danych.
Obecnie nasze zapytanie pobierające książki wydawnictwa Prentice-Hall wymaga wykona-
nia złączenia:
Złączenie razem trzech tablic pozwoli na zdobycie listy wszystkich książek napisanych
przez określonego autora, takiego jak np. Paul Krugman:
12.1.3. Głębsza normalizacja
Przedstawiona przed chwilą wersja tabeli była niewątpliwie krokiem w dobrym kie-
runku. Co jednak, jeśli dana książka ma wią cej niż jednego autora? Dotychczasowa defini-
cja tabeli nie dopuszcza takiej sytuacji.
Rozdział 12. Tworzenie aplikacji dla baz danych 287
Jednym z możliwych rozwiązań tego problemu jest dodanie do tabeli kilku nowych
kolumn. Można na przykład zmienić kolumną na i dodać trzy ko-
lumny dopuszczające wartość ( , oraz ) przeznaczone
dla dodatkowych autorów.
To rozwiązanie jednak sztucznie ogranicza liczbą autorów, których może posiadać książka,
i prowadzi do niepotrzebnego marnotrawienia przestrzeni na dysku w przypadku każdej
książki, która bą dzie miała mniej autorów. Dodatkowo nadmiernie komplikuje wszystkie za-
pytania rozważmy na przykład listą książek napisanych przez Paula Krugmana:
Lepszym rozwiązaniem jest zupełne usunią cie informacji o autorze z tabeli . Zamiast
tego przygotujemy tabelą (autorzy książki) posiadającą dwie kolumny jedną
bą dzie klucz obcy do tabeli , a drugą klucz obcy do tabeli . A oto poprawiona
definicja tabeli wraz z tabelą :
Zarówno identyfikator książki ( ), jak i identyfikator autora ( ) mogą pojawić
sią w tabeli wielokrotnie. Powinniśmy jednak zagwarantować, żeby każdy autor w odniesie-
niu do konkretnej książki pojawiał sią tylko raz. Robimy to, stosując ograniczenie
łącznie na dwóch kolumnach zamiast na pojedynczej kolumnie.
288 Perl
Po dodaniu tabeli zapytanie odszukujące wszystkie książki napisane przez Paula
Krugmana wymagać bą dzie wykonania złączenia czterech tabel:
Z kolei nastą pne zapytanie zwraca książką o numerze ISBN , zwracając jeden
wiersz dla każdego autora książki:
Jak widać, prawidłowo zaprojektowana baza danych pozwala na uzyskanie odpowiedzi na
wiele różnych pytań nawet jeśli nie uwzglą dnialiśmy ich podczas projektowania bazy.
12.1.4. Indeksy
Jak pisałem w podrozdziale 11.6, należy dodawać indeks do każdej kolumny, która może
pojawiać sią w klauzuli . Klucze główne i kolumny oznaczone jako są indek-
sowane automatycznie, co oszczą dza nam trochą pracy. W naszych tabelach jest jednak
jeszcze kilka kolumn, na których prawdopodobnie również wykonywane bą dą zapytania.
Przygotowanie tych indeksów sprawi, że nawet jeśli ksią garnia oferować bą dzie kilka mi-
lionów książek, łatwo i szybko je odnajdziemy, poszukując książek według tytułu, autora,
daty publikacji czy ceny.
Rozdział 12. Tworzenie aplikacji dla baz danych 289
12.1.5. Integralność powiązań
Nasze obecne definicje tabel zabraniają wstawiania wartości do kolumn tytułów ksią-
żek i kodów ISBN. Może sią jednak zdarzyć, że przez przypadek do tej lub innej kolumny
wstawimy pusty łańcuch.
Ponieważ tworzona baza danych jest centralnym miejscem zbierania informacji o książkach
dostą pnych w ksią garni, przechowywane w niej dane muszą być na tyle wiarygodne, na ile
to tylko możliwe. Słowo kluczowe bazy PostgreSQL pozwala na nałożenie na ko-
lumny dodatkowych ograniczeń, w wyniku których wprowadzane dane przechodzić bą dą
dodatkowe testy. Na przykład tabelą można przedefiniować w nastą pujący sposób:
Taka poprawiona definicja tabeli uniemożliwia wpisanie do kolumny pustego
łańcucha, gwarantuje, że kolumna zawierać bą dzie przynajmniej jedną literą lub cyfrą
(korzystając w tym celu z niewrażliwego na rozmiar liter operatora PostgreSQL), i wy-
maga, żeby wartości w kolumnach i były liczbami dodatnimi.
PostgreSQL bą dzie od tej pory odmawiać dodawania do bazy książek, które łamać bą dą
jedno lub wią cej z tak zdefiniowanych ograniczeń. Jeśli na przykład spróbujemy dodać książ-
ką nieposiadającą tytułu:
PostgreSQL zwróci nastą pujący komunikat o błą dzie:
Tego rodzaju ograniczenia mogą sią wydawać nonsensowne lub zbyteczne, niemniej wcale
tak nie jest. Bez nich moglibyśmy przypadkowo wprowadzić do bazy danych nieprawidłowe
dane. Naprawianie bazy danych zawierającej niepoprawne lub niespójne dane jest skompli-
kowanym i pracochłonnym zadaniem, szczególnie jeśli baza danych musi być cały czas do-
stą pna. Ograniczenie pozwala na uniknią cie takich sytuacji, wymuszając poprawność
informacji zapisywanych w bazie danych.
290 Perl
12.1.6. Kategorie książek
Chcielibyśmy także przypisać każdą książką do jednej lub wią cej kategorii. Najprostszy
sposób polega na przygotowaniu pary tabel podobnych do tych, które przygotowaliśmy dla
autorów tabeli z nazwami kategorii i tabeli , która powiąże te
kategorie z książkami:
12.2. Pisanie aplikacji
Gdy baza danych jest gotowa, można przygotować programy Perla, które bą dą z nią współ-
pracować. Jeden zestaw programów pozwoli personelowi ksią garni wprowadzać, aktuali-
zować i usuwać informacje na temat książek, autorów i wydawców. Drugi przeznaczony
bą dzie dla klientów ksią garni, żeby z jego pomocą mogli odnalezć w bazie danych intere-
sujące ich książki.
12.2.1. Wprowadzanie informacji o autorach
Kusić nas może, aby zacząć od przygotowania aplikacji pozwalającej na wprowadzanie do
bazy danych informacji o książkach. Jednak musimy pamią tać, że kolumna
w tabeli jest kluczem obcym tabeli , co oznacza, ze przed zapełnieniem
tabeli trzeba najpierw wypełnić tabelą .
Pierwszy z przedstawionych programów, insert-author.pl, łączy sią z serwerem Postgre-
SQL, pobiera od użytkownika nazwisko autora książki i wykonuje odpowiednie zapytanie
wstawiające autora do bazy. Jeśli coś pójdzie nie tak, zakończy pracą , sygnalizując
krytyczny błąd.
Rozdział 12. Tworzenie aplikacji dla baz danych 291
Program ten wykonuje prosty test integralności danych na poziomie aplikacji, aby upewnić
sią , że nazwisko autora zawiera przynajmniej jeden znak. Wią kszość aplikacji współpracu-
jących z bazami danych sprawdza wprowadzane dane dwukrotnie: na poziomie definicji ta-
beli (ograniczenie ) i ponownie na poziomie aplikacji. Pierwszy test sprawdza, czy baza
danych nie zawiera niespójnych lub uszkodzonych danych, a drugi pozwala na przechwy-
tywanie błą dów i przygotowywanie czytelnych komunikatów o błą dach dla użytkownika.
292 Perl
Warto przyjrzeć sią odwołaniu do metody w programie insert-author.pl. Metoda
interfejsu przeznaczona jest dla tych zapytań i , które nie muszą pobie-
rać wyników zapytania za pośrednictwem uchwytu . Pierwszy argument metody
jest łańcuchem zawierającym instrukcją SQL, a drugi odwołaniem do tablicy asocja-
cyjnej zawierającej definicje atrybutów (lub wartość ). Pozostałe argumenty są warto-
ściami, jakie interfejs powinien przypisać symbolom zastą pczym w instrukcji SQL.
Metoda zwraca liczbą zmienionych przez nią wierszy w tabeli.
12.2.2. Wprowadzanie kategorii
Program insert-category.pl wstawiający nową kategorią do tabeli jest bardzo
podobny do programu insert-author.pl. Niemniej tym razem istnieje pewna pułapka: ko-
lumna została zdefiniowana jako . Nasza aplikacja mogłaby ignoro-
wać ten wymóg, próbując na ślepo wstawiać nowe nazwy kategorii do tabeli .
Gdyby baza PostgreSQL odmówiła dodania nowej kategorii, moglibyśmy przechwycić
błąd i zaraportować go użytkownikowi.
Tutaj jednak zastosowaliśmy bardziej wyszukane rozwiązanie, które wymaga sprawdzenia
bazy danych w celu ustalenia, czy taka nazwa kategorii nie została już wcześniej wprowa-
dzona. To jednak pociąga za sobą konieczność wykonania zapytania (aby pobrać
nazwy już istniejących kategorii), a dopiero potem zapytania (aby wstawić nową kate-
gorią ). Co jednak, jeśli ktoś inny spróbuje wykonać mią dzy tymi dwoma zapytaniami po-
dobne zapytanie ?
Rozwiązanie, tak jak to zostało wspomniane w sekcji 11.7.4 w poprzednim rozdziale, pole-
ga na połączeniu zapytań i w pojedynczej transakcji. W ten sposób upew-
niamy sią , że nikt inny nie zmodyfikuje bazy danych mią dzy obydwoma naszymi zapyta-
niami. Obsługą transakcji można włączyć, przypisując atrybutowi wartość .
Wygodniej jest jednak skorzystać z metody , która wyłączy atrybut
na czas pojedynczej transakcji do momentu wywołania metody
zatwierdzającej transakcją lub metody wycofującej transakcją .
Kod programu bą dzie wią c najpierw pytał użytkownika o nazwą nowej kategorii, nastą pnie
za pomocą zapytania sprawdzi, czy takiej nazwy już nie ma, a jeśli taka kategoria już
istnieje przerwie wykonywanie transakcji, przywołując metodą . Wy-
cofanie transakcji nie jest w tym przypadku tak naprawdą konieczne, ponieważ nie zmody-
fikowaliśmy żadnej tabeli. Ja jednak zawsze staram sią postą pować przezornie i przerywam
zapytanie za pomocą metody . Gdy już dane przejdą wszystkie testy na
poziomie aplikacji, wykonywane jest zapytanie i wywoływana metoda
zatwierdzająca transakcją .
Warto zauważyć, że program insert-category.pl działa z włączonym atrybutem .
Oznacza to, że nie ma potrzeby sprawdzania wartości zwracanych przez procedury
i , ponieważ program zakończy działanie, sygnalizując krytyczny błąd, za każdym
razem, gdy natknie sią na błąd bazy danych.
Rozdział 12. Tworzenie aplikacji dla baz danych 293
294 Perl
Jak łatwo przewidzieć, program insert-publisher.pl bą dzie wyglądał bardzo podobnie do
programu insert-category.pl.
12.2.3. Modyfikowanie już istniejących wartości
Program insert-category.pl działa całkiem sprawnie co jednak, jeśli ktoś wprowadzi do
bazy złą nazwą kategorii? Baza danych ksią garni potrzebuje jakiegoś sposobu modyfiko-
wania już istniejących nazw kategorii (to samo dotyczy wstawionych nazw autorów i wy-
dawców, ale tutaj omawiać bą dziemy tylko przypadek kategorii).
Program update-category.pl bą dzie wymagał podania przez użytkownika dwóch wartości:
starej nazwy kategorii i nowej kategorii . Może sią
jednak zdarzyć, że użytkownik popełni błąd przy wpisywaniu starej nazwy kategorii, po-
dając nazwą , której nie ma w bazie danych, i wówczas klauzula zapytania SQL nie
bą dzie pasowała do żadnego wiersza tabeli .
Moduł dostą pny w sieci (patrz: podrozdział 1.6) pozwala na ograni-
czenie liczby przyjmowanych od użytkownika danych wejściowych. Moduł
automatycznie eksportuje do przestrzeni nazw kodu przywołującego procedurą .
Rozdział 12. Tworzenie aplikacji dla baz danych 295
Procedura wymaga przesłania jej dwóch argumentów. Pierwszy z nich to tekst
komunikatu proszącego o wprowadzenie danych, który zostanie wyświetlony użytkowni-
kowi, a drugi jest listą lub też odwołaniem do tablicy, które zawierać bą dą dopuszczalne
odpowiedzi użytkownika. Użytkownik może w każdej chwili wcisnąć klawisze CTL+D, by
wyświetlić listą dopuszczalnych odpowiedzi. Jeśli użytkownik wprowadzi wystarczającą
liczbą znaków, aby było możliwe jednoznaczne zidentyfikowanie danego elementu listy,
wciśnią cie klawisza TAB pozwoli uzupełnić resztą .
Program update-category.pl pobierze listą bieżących kategorii (która przesłana zostanie
procedurze ), korzystając z zapytania , a nastą pnie bą dzie modyfikować bazą
za pomocą zapytania . Oba zapytania zostaną połączone w jedną transakcją za po-
mocą metody , podobnie jak to było w programie insert-category.pl.
Lista kategorii pobierana jest z tabeli . Zamiast jednak umieszczać nazwy kate-
gorii w tablicy, uczynimy je kluczami tablicy asocjacyjnej . Sprawdzenie, czy
dany klucz istnieje w tablicy asocjacyjnej, zajmuje bowiem znacznie mniej czasu niż od-
szukanie elementu w tablicy, tak wią c program bą dzie dzią ki temu działał szybciej.
A oto jedna z możliwych implementacji programu update-category.pl:
296 Perl
Rozdział 12. Tworzenie aplikacji dla baz danych 297
12.2.4. Dodawanie nowych książek
Po dodaniu kilku pozycji do tabel , i można przystąpić do
wprowadzania do bazy danych ksią garni nowych książek. Dodanie nowej książki oznacza
konieczność wstawienia jednego wiersza do tabeli i jednego lub wią cej wierszy do
tabeli .
Kolejny program, insert-book.pl, wykorzystuje wią kszość technik, które opisywałem wcze-
śniej w tym rozdziale: wykonuje zapytanie pobierające z bazy danych listą już wprowadzo-
nych wydawców i autorów, wykorzystuje moduł , dzią ki któremu użytkownik
podaje odpowiednią nazwą wydawnictwa i nazwisko autora, i wreszcie wstawia wiersze do
tabel i . Co wią cej, przeprowadza to wszystko w ramach jednej transak-
cji, dzią ki czemu opisana sekwencja transakcji zostaje wykonana łącznie i niepowodzenie
jednej oznaczać bą dzie niepowodzenie wszystkich.
Warto również zauważyć, że korzystamy tutaj z właściwego tylko bazie PostgreSQL atry-
butu , który zwraca identyfikator (OID) ostatnio wstawionego obiektu.
Identyfikatory obiektów są elementem specyficznym dla PostgreSQL. Można postrzegać je
jako niewidoczny, globalny klucz główny każdego wiersza w bazie danych. Identyfikator
OID ostatnio wprowadzonego wiersza pozwala na pobranie klucza głównego dla ostatnio
wykonanej operacji .
Na koniec warto przyjrzeć sią , w jaki sposób wiersze wstawiane są do tabeli
za pomocą pojedynczego odwołania do metody i kilkakrotnego przywoływania
metody . W ten sposób odciążamy program Perla i przyśpieszamy znacznie wyko-
nywanie zapytania, jeśli baza, z której korzystamy, przechowuje zapytania w pamią ci pod-
rą cznej.
Program insert-book.pl jest jak dotąd najdłuższym programem związanym z bazami da-
nych, które były omawiane w tej książce. Ponieważ jednak wszystkie jego elementy poja-
wiały sią już w poprzednio prezentowanych programach, zrozumienie go nie powinno być
zbyt trudne.
298 Perl
Rozdział 12. Tworzenie aplikacji dla baz danych 299
300 Perl
Mimo iż program insert-book.pl nie obsługuje kategorii, nietrudno domyślić sią , jak powi-
nien wyglądać odpowiedni kod, który należałoby w tym celu dodać do programu.
12.2.5. Pobieranie informacji o książkach
Teraz, gdy baza danych ksią garni jest gotowa, pora przygotować prostą aplikacją wykonu-
jącą zapytania, które umożliwią użytkownikom zdobycie informacji na temat konkretnych
książek. Napiszemy przykładowy program, który bą dzie zwracał książki o tytułach zawie-
rających tekst wprowadzony przez użytkownika.
Rozdział 12. Tworzenie aplikacji dla baz danych 301
Warto zauważyć, że najpierw wczytujemy wszystkie informacje o książce do tablicy aso-
cjacyjnej , a dopiero pózniej je wyświetlamy. Dzieje sią tak, ponieważ baza Postgre-
SQL zwróci po jednym wierszu dla każdego autora książki. Gdybyśmy po prostu wyświe-
tlili wyniki, tak jak są one zwracane przez bazą danych, książki mające dwóch autorów
byłyby wyświetlane dwukrotnie, a książki mające pią ciu autorów aż pią ć razy! Unik-
niemy takich powtórzeń, wczytując wszystkie zwrócone książki do tablicy asocjacyjnej ta-
blic asocjacyjnych, którą nastą pnie posortujemy i wyświetlimy to, co nam pozostanie.
Porządek, w jakim bą dą zwracane wyniki, może wydawać sią nieistotny, skoro i tak zostaną
one uporządkowane w pą tli . Nie jest to jednak do końca prawda: autorzy są doda-
wani do tablicy asocjacyjnej w takim samym porządku, w jakim są pobierani. Dlatego
właśnie klauzula upewnia sią , że zwracane wiersze bą dą uporządkowane według
nazwisk autorów.
Aby uniknąć pomyłek, które mogą być spowodowane różnicami w wielkości liter, wyko-
rzystywana jest funkcja ją zyka SQL, która powoduje zamianą wszystkich wielkich
znaków ciągów, które są jej argumentami, na małe:
302 Perl
Rozdział 12. Tworzenie aplikacji dla baz danych 303
12.3. Usuwanie błędów
w programach korzystających z DBI
Perl jest ją zykiem programowania, w którym błą dy wykrywa sią bardzo łatwo. Wielu pro-
gramistów zamiast korzystać z wbudowanego debuggera (patrz: sekcja 13.4.2), po prostu
wstawia do kodu kilka instrukcji . Tego rodzaju techniki nie zawsze jednak wystar-
czają, gdy korzystamy z interfejsu .
Jeśli na przykład program zakończy pracą w wyniku błą du bazy danych po próbie wykona-
nia instrukcji wstawiającej wiersz do bazy danych , dobrze by było wie-
dzieć, jak dokładnie wyglądało ostateczne zapytanie SQL, zanim zostało wysłane do bazy
danych. Jeśli korzystamy w zapytaniu z symboli zastą pczych, okaże sią , że uzyskanie tego
rodzaju informacji jest bardzo trudne.
Rozwiązaniem jest metoda , która pomaga w usuwaniu błą dów z programów
korzystających z interfejsu . Wymaga ona jednego obowiązkowego argumentu, który
powinien być liczbą całkowitą z przedziału od 0 (zupełny brak wykrywania błą dów) do 9
(poziom wykrywania błą dów oferujący znacznie wią cej informacji niż prawdopodobnie
kiedykolwiek bą dziesz potrzebować). Drugi argument jest opcjonalny i podaje nazwą pliku
na dysku, do którego mają być zapisywane informacje debugowania. Domyślnie wszystkie
informacje dostarczane przez metodą trafiają do standardowego strumienia
błą dów .
Po aktywacji metoda działać bą dzie przez cały czas pracy programu lub do
momentu, gdy zostanie wyłączona. Bardzo czą sto metodą wykorzystuje sią
w trakcie tworzenia programu, by wyłączyć ją, kiedy program zaczyna normalne działanie.
Można również wywołać metodą jako metodą klasy wprost z modułu , wpisując
. Pozwoli to na śledzenie działania metody , która zwraca uchwyt
bazy danych .
Żeby pokazać, jakie informacje zwraca metoda , zaprezentują tutaj zapis
działania programu insert-book.pl, dla którego metoda została włączona na
pierwszym poziomie debugowania. Do kodu programu insert-book.pl dodałem tylko jeden
wiersz, zaraz po odwołaniu do metody :
Oto, co pojawiło sią na ekranie podczas działania programu insert-book.pl:
304 Perl
W tym czasie za kulisami moduł zebrał nastą pujące informacje o tej sesji:
Rozdział 12. Tworzenie aplikacji dla baz danych 305
Jak widać, metoda dostarcza kompletnego dziennika rejestrującego każdą
zmianą atrybutu oraz każdą wywołaną metodą , lub .
306 Perl
12.4. Podsumowanie
W tym rozdziale poszerzyliśmy wiedzą na temat teorii baz danych. Poznaliśmy również
kilka standardowych rozwiązań z zakresu projektowania baz danych, które niezmiernie uła-
twiają tworzenie prawdziwych aplikacji współpracujących z bazami. Przyjrzeliśmy sią do-
kładnie przykładowym programom obsługującym katalog książek oferowanych przez pewną
ksią garnią . W szczególności omawialiśmy:
znaczenie normalizacji danych, która czyni bazy danych wydajniejszymi
i łatwiejszymi w obsłudze,
sposoby projektowania bazy danych, tak by była jak najwszechstronniejsza
i pozostawała wydajna, niezależnie od tego, ile informacji bą dzie przechowywać,
wykorzystanie modułu do narzucania ograniczeń na dane
wprowadzane przez użytkownika,
korzystanie z metody ułatwiającej wyszukiwanie błą dów
w aplikacjach dla baz danych.
Wyszukiwarka
Podobne podstrony:
Perl Zaawansowane programowanieperlprojekt perlperl wstepPerl Skryptywięcej podobnych podstron