SQL dla każdego

Bazy danych nie są aż tak trudne. Zrozumienie SQL-a po lekturze tej książki nie będzie już problemem. Seria "Dla każdego" zobowiązuje, dlatego spróbuj i Ty!

Autor -- Rafe Coburn wprowadzi Cię w świat języka zapytań do relacyjnych baz danych. Już niedługo nie będą straszne polecenia szefa: "Proszę o raport ze sprzedaży za dwie ostatnie godziny!".

W książce znajdziesz wyczerpujące opisy:

• modelu relacyjnej bazy danych
• zasad przetwarzania danych
• języka SQL, jego składni i standardów
• systemów opartych na relacji klient-serwer
• praktycznych rozwiązań dotyczących, np. typów danych, wydajności i integralności bazy danych, transakcji i kursorów
• procedur, w tym procedur w języku Transact-SQL oraz PL/SQL (tworzenie procedur, tworzenie i użytkowanie funkcji, umieszczanie procedur i funkcji w pakietach)
• obsługi wyjątków
• testowania zapytań
• wyzwalaczy

Zostań się najlepszym specjalistą w zespole!

Spis treści

O Autorze (17)

Wstęp (19)

• Kompozycja książki (20)
• Konwencje przyjęte w książce (22)

Część I Projektowanie i tworzenie bazy danych (23)

• Model relacyjnej bazy danych (25)
  • Zasady dotyczące struktury danych (27)
  • Zasady dotyczące przetwarzania danych (27)
  • Zasady dotyczące integralności danych (28)
• Język SQL (29)
  • Przetwarzanie danych (29)
  • Definiowanie danych (30)
  • Zarządzanie bazą danych (31)
• Standardy języka SQL (31)
• Składnia języka SQL (32)
  • Nierozróżnianie wielkich i małych liter (32)
  • "Białe" znaki (33)
  • Zagnieżdżanie (34)
  • Używanie cudzysłowów (34)
  • Nawiasy (35)
• Operacje relacyjne (36)
  • Selekcja (36)
  • Projekcja (37)
  • Złączenie (37)
• Rozwój aplikacji baz danych (38)
  • Systemy scentralizowane (38)
  • Systemy klient-serwer (38)
  • Bazy danych na stronach WWW (39)
  • Wiersz poleceń (40)
• W praktyce (40)

Rozdział 2. Projektowanie bazy danych (43)

• Struktura bazy danych (44)
• Dobre i złe bazy danych (44)
  • Charakterystyka dobrej bazy danych (44)
  • Jak poznać złą bazę danych (45)
• Projektowanie (45)
• Zanim przystąpisz do projektu (46)
• Modelowanie danych (47)
• Zależności funkcyjne i klucze kandydujące (48)
  • Zależności funkcyjne (49)
  • Definicja zależności funkcyjnej (49)
  • Klucze kandydujące i klucze główne (51)
  • Droga na skróty (51)
• Modelowanie relacji (52)
  • Wybieranie obiektów (52)
  • Rozpoznawanie własności (53)
  • Rozpoznawanie relacji między obiektami (54)
  • Relacja jeden-do-jeden (54)
  • Relacja jeden-do-wiele (55)
  • Relacja wiele-do-wiele (55)
  • Schemat relacji (56)
• Normalizacja (57)
  • Dekompozycja bez straty danych (57)
  • Pierwsza postać normalna 1PN (58)
  • Druga postać normalna 2PN (59)
  • Trzecia postać normalna 3PN (60)
  • Boyce-Codd'a postać normalna BCPN (62)
  • Wyższe postacie normalne (63)
  • Denormalizacja (64)
• W praktyce (64)

Rozdział 3. Budowanie bazy danych (67)

• Tworzenie bazy danych (68)
• Dostęp do wybranej bazy danych (68)
• Tworzenie tabeli (69)
• Typy danych (70)
  • Dane łańcuchowe (71)
  • Dane numeryczne (71)
  • Określenia czasu (72)
• Określanie kluczy (72)
  • Klucze obce (74)
• Ograniczenia dla kolumn (74)
  • Odrzucanie wartości null (75)
  • Inne ograniczenia (75)
• Wartości domyślne (76)
• Projekt bazy danych o filmach (77)
  • Tabela Movies (77)
  • Tabela Studios (79)
  • Tabela People (79)
  • Tabela Cast_Movies (80)
• Indeksy (81)
  • Indeksy unikalne (82)
  • Indeks klastrowy (82)
  • Powody do indeksowania kolumn (83)
  • Kiedy nie używać indeksów (83)
• W praktyce (84)

Rozdział 4. Tworzenie, zmienianie i usuwanie rekordów (85)

• Przygotowanie danych (85)
• Instrukcja INSERT (86)
  • Wprowadzanie wartości domyślnych i wartości null (87)
• Równoczesne użycie instrukcji SELECT i INSERT (88)
  • Kopiowanie tabel, usuwanie powtarzających się wierszy (90)
• Instrukcja DELETE (93)
• Instrukcja UPDATE (93)
• Instrukcja TRUNCATE (95)
• Instrukcja DROP (95)
  • DROP TABLE (95)
  • DROP INDEX (96)
• Instrukcja ALTER (96)
  • ALTER TABLE (96)
• W praktyce (98)

Część II Pobieranie danych z bazy danych (101)

Rozdział 5. Instrukcja SELECT (103)

• Budowa instrukcji SELECT (103)
• Określanie kolumn do pobrania (104)
  • Użycie znaku "*" do wybrania wszystkich kolumn (105)
• Wykonywanie obliczeń na danych (107)
  • Użycie wyrażeń w instrukcji SELECT (107)
  • Nazwy kolumn w wyrażeniach (108)
  • Operatory arytmetyczne obsługiwane przez SQL (109)
• Użycie słowa kluczowego AS do nadawania nazw kolumnom i wyrażeniom (110)
• Filtrowanie wyników zapytania za pomocą klauzuli WHERE (112)
  • Operatory do porównywania (113)
  • Rozróżnianie wielkości liter w porównaniach (115)
  • Wykonywanie obliczeń w klauzuli WHERE (115)
• Postępowanie z wartościami null (116)
  • Wyszukiwanie wartości null (116)
  • Wyszukiwanie null w innych zapytaniach (117)
• Sortowanie wyników zapytania (119)
  • Użycie klauzuli ORDER BY (119)
  • Sortowanie w porządku malejącym (120)
  • Sortowanie wyrażeń (121)
  • Sortowanie po wielu kolumnach (122)
• Ustalanie identyczności łańcuchów (123)
  • Jak porównujemy łańcuchy (124)
  • Sortowanie z pominięciem znaczenia wielkości liter (125)
  • Zestaw znaków (125)
• W praktyce (125)

Rozdział 6. Zastosowanie klauzuli WHERE (127)

• Klauzula WHERE (127)
• Użycie operatorów logicznych w klauzuli WHERE (128)
  • Programowanie logiki (128)
  • Operator AND (128)
  • Operator OR (129)
  • Operator NOT (129)
  • Wykorzystanie złożonych operatorów logicznych (131)
  • Kolejność wykonywania działań (132)
• Klauzula IN (132)
  • Klauzula IN w podzapytaniu (133)
  • IN kontra OR (134)
  • NOT IN (134)
• Klauzula BETWEEN (135)
  • BETWEEN i typy czasowe (137)
  • BETWEEN i łańcuchy (137)
• Wyszukiwanie łańcuchów przy pomocy klauzuli LIKE (138)
  • Budowanie szablonów (139)
  • Złożone instrukcje WHERE z operatorem LIKE (140)
  • Pomijanie znaków wieloznacznych (141)
  • LIKE i wydajność (141)
  • Dopasowywanie jednego lub wielu znaków (142)
• Funkcje przydatne dla klauzuli WHERE (142)
  • Usuwanie niepotrzebnych spacji (143)
  • Długość łańcucha (143)
  • Funkcje umożliwiające konwersję typów danych (143)
  • Zagnieżdżanie funkcji (144)
  • Funkcje agregujące (145)
• W praktyce (145)

Rozdział 7. Przetwarzanie wyników zapytań (147)

• Wybór wartości unikalnych: operator DISTINCT (147)
  • Wybieranie unikalnych kombinacji wartości (148)
  • DISTINCT i NULL (149)
• Funkcje agregujące (150)
  • Funkcje agregujące i klauzula WHERE (151)
  • Zmiana nazwy wyników funkcji agregującej (152)
• Funkcja COUNT() (152)
  • Funkcja COUNT() i wartości null (153)
  • Funkcja COUNT() i operator DISTINCT (153)
• Funkcje SUM() i AVG() (153)
  • Funkcje MIN() i MAX() (154)
• Wykonywanie obliczeń z podziałem na kategorie (155)
  • Klauzula GROUP BY (156)
  • Grupy i podgrupy (157)
  • Klauzule GROUP BY i ORDER BY (158)
  • Klauzula GROUP BY stosowana łącznie z WHERE (160)
• Filtrowanie wyników zapytań z użyciem HAVING (161)
  • Złożone wyrażenia w klauzuli HAVING (162)
  • HAVING i WHERE (162)
• W praktyce (163)

Rozdział 8. Łączenie tabel (165)

• Połączenia i normalizacja (165)
• Co to jest złączenie? (166)
  • Zgodne kolumny (166)
  • Warunki złączenia (168)
• Używanie złączeń (168)
  • Wybieranie kolumn (169)
  • Skracanie nazw tabel (170)
  • Złączenia i relacje (170)
• Jak działają złączenia (171)
• Typy złączeń (172)
  • Połączenia naturalne (172)
  • Złączenia w oparciu o inne warunki (173)
  • Self-joins (174)
• Łączenie więcej niż dwóch tabel (175)
  • Tabele łączące (177)
• Złączenia zewnętrzne (178)
• Unie (179)
  • Opcja ALL (181)
  • Łączenie UNION i ORDER BY (182)
  • INTERSECT (183)
  • MINUS (184)
• Składnia złączeń w SQL-92 (184)
  • Złączenia wewnętrzne (185)
  • Złączenia zewnętrzne (186)
• W praktyce (188)

Rozdział 9. Podzapytania (189)

• Co to jest podzapytanie? (190)
  • Zastępowanie podzapytań przez złączenia (191)
• Typy podzapytań (191)
  • Podzapytania niepowiązane (192)
  • Podzapytanie powiązane (192)
• Podzapytania zwracające listę wartości (193)
  • Tworzenie zapytań z IN (193)
  • Zastosowanie IN w zapytaniach powiązanych (195)
  • Zastępowanie autozłączeń przez podzapytanie (195)
  • Podzapytania i NOT IN (196)
  • Wykorzystanie EXISTS (198)
  • Znajdowanie zbiorów pustych przy pomocy NOT EXISTS (199)
  • Operatory porównania z ANY i ALL (199)
  • Zastosowanie ANY (200)
  • Zastosowanie ALL (201)
• Podzapytania zwracające pojedynczą wartość (202)
  • Podzapytania i funkcje agregujące (203)
• Pisanie złożonych zapytań (205)
  • Zagnieżdżanie podzapytań (205)
  • Łączenie podzapytań i złączeń (206)
  • Zastosowanie podzapytania w klauzuli HAVING (207)
• Wykorzystanie podzapytań w instrukcjach UPDATE i DELETE (208)
  • Podzapytania z instrukcją DELETE (208)
  • Podzapytania z instrukcją UPDATE (208)
• Stosowanie podzapytań z instrukcją INSERT (210)
• W praktyce (211)

Część III Zarządzanie bazą danych (213)

Rozdział 10. Widoki (215)

• Tworzenie widoków (215)
• Korzyści płynące ze stosowania widoków (217)
  • Wygoda (217)
  • Ukrywanie efektów normalizacji (218)
  • Ograniczanie danych dostępnych dla użytkowników (219)
  • Tworzenie warstwy abstrakcji (219)
• Aliasy kolumn (220)
• Widoki pojedynczych tabel (221)
  • Widoki z wyrażeniami i funkcjami (221)
  • Widoki z funkcjami agregującymi (223)
• Widoki tworzone ze złączeń (225)
• Widoki z podzapytaniami (226)
• Korzystanie z innych operacji złączeń w widokach (227)
• Zagnieżdżanie widoków (228)
• Modyfikowanie danych poprzez widoki (229)
• Zadania realizowane za pomocą widoków (232)
  • Tabele w przykładzie (233)
  • Działanie systemu (234)
  • Widoki użyte w systemie (235)
  • Zapytanie wydobywające artykuły (237)
• W praktyce (238)

Rozdział 11. Model bezpieczeństwa SQL (241)

• Bezpieczeństwo baz danych (241)
  • Konto administratora bazy danych (242)
  • Właściciele bazy danych (243)
• Tworzenie użytkowników bazy danych (243)
  • Modyfikowanie użytkowników (244)
  • Usuwanie użytkowników (244)
• Elementy bazy danych (244)
  • Bazy danych (245)
  • Tabele (247)
  • Widoki (247)
  • Kolumny oraz kolumny widoku (248)
• Polecenia GRANT I REVOKE (248)
  • Użytkownik publiczny (249)
  • Nadawanie użytkownikom uprawnienia GRANT (250)
• Role a bezpieczeństwo bazy danych (251)
  • Tworzenie i usuwanie ról (252)
  • Przypisywanie użytkowników do ról (252)
  • Przypisywanie ról innym rolom (254)
• Widoki a bezpieczeństwo bazy danych (255)
  • Dostosowywanie praw dostępu poprzez widoki (257)
• W praktyce (260)

Część IV Zagadnienia praktyczne (261)

Rozdział 12. Typy danych (263)

• Dane numeryczne (264)
  • Sortowanie liczb (264)
  • Liczby i wartość null (266)
  • Wyrażenia matematyczne (267)
  • Standardowe funkcje matematyczne (268)
  • Formatowanie liczb (270)
• Dane łańcuchowe (271)
  • Konkatenacja łańcuchów (271)
  • Funkcje łańcuchowe (272)
  • Przeszukiwanie łańcuchów (273)
  • Podciągi (274)
  • Użycie przeszukiwania i wyciągania podciągów (274)
  • Soundex (276)
• Daty i określenia czasu (277)
  • Formatowanie dat przed wyprowadzeniem (278)
  • Formatowanie dat przed zapisem (279)
  • Dodawanie i odejmowanie dat (279)
  • Porównywanie dat (281)
  • Zaokrąglanie dat (282)
• Konwertowanie danych (283)
  • Funkcja Convert() (284)
  • Konwertowanie typów danych w Oracle'u (286)
• W praktyce (289)

Rozdział 13. Wydajność i integralność bazy danych (291)

• Zwiększanie wydajności bazy danych (291)
  • Projekt bazy danych a jej wydajność (292)
• Narzędzia pomiaru wydajności (292)
  • AUTOTRACE (Oracle) (293)
  • SHOWPLAN (Transact-SQL) (296)
• Indeksy (297)
  • Indeksy klastrowe (298)
  • Zapytania wykorzystujące indeksy (298)
• Optymalizator zapytań (300)
  • Zasada działania (300)
  • Optymalizator i indeksy (302)
  • Wiele indeksów w jednym zapytaniu (303)
  • Operacje na zbiorach danych (304)
  • Optymalizator zapytań i widoki (305)
  • Optymalizator zapytań i podzapytania (305)
  • Operacje złączenia (306)
  • Podpowiedzi dotyczące złączeń (307)
• Integralność danych (307)
• Integralność kontra wydajność (309)
• W praktyce (310)

Rozdział 14. Transakcje i kursory (313)

• Transakcje (314)
  • Zasada działania (314)
• Transakcje w Oracle (315)
  • AUTOCOMMIT (316)
• Transakcje w języku Transact-SQL (317)
• Blokowanie danych (318)
  • Typy blokad (320)
  • Transakcje i procedury składowane (321)
  • Dziennik transakcji (321)
• Kursory (322)
• Kursory w języku Transact-SQL (322)
  • Deklarowanie kursora (323)
  • Otwieranie kursora (324)
  • Pobieranie wierszy z kursora (324)
  • Modyfikowanie i usuwanie danych poprzez kursory (325)
  • Zamykanie i usuwanie kursorów (326)
• Kursory w języku PL/SQL (327)
  • Deklarowanie kursorów (328)
  • Używanie kursorów w programach PL/SQL (328)
  • Atrybuty kursorów (329)
  • Iteracyjne przetwarzanie kursora (330)
• W praktyce (332)

Część V Procedury składowane (335)

Rozdział 15. Procedury składowane (337)

• Pisanie procedur składowanych (339)
  • Przekazywanie parametrów do procedur składowanych (340)
• Zmienne (342)
  • Nadawanie wartości zmiennym (343)
• Definiowanie bloków kodu (345)
• Wyrażenia warunkowe (346)
  • Zapytania w wyrażeniach warunkowych (347)
  • Połączenie wyrażenia warunkowego z blokiem kodu (348)
  • Wyrażenie IF...ELSE (348)
  • Zagnieżdżanie wyrażeń warunkowych (349)
• Pętle (350)
  • Pętla WHILE (351)
  • Pętle nieskończone (352)
  • Restartowanie pętli - CONTINUE (354)
  • Zagnieżdżanie pętli (355)
• Iteracyjne przetwarzanie kursora (355)
• Wyzwalacze (357)
  • Tworzenie wyzwalaczy (358)
  • Usuwanie wyzwalaczy (358)
  • Kod wyzwalacza (358)
  • Wyzwalacze działające na kolumnach (359)
• W praktyce (360)

Rozdział 16. Procedury składowane w języku Transact-SQL (363)

• Ogólne informacje na temat programowania w Transact-SQL (363)
• Zmienne globalne (363)
• Przerywanie pracy procedur - RETURN (366)
• Obsługa błędów (366)
  • RAISERROR (366)
  • RAISERROR w Microsoft SQL Server (367)
  • RAISERROR w Sybase (369)
  • Przechwytywanie błędów (370)
  • Wyrażenie RETURN (371)
  • Definiowanie własnych komunikatów błędów (372)
• Obiekty tymczasowe (372)
• tempdb - zasada działania (373)
  • Tworzenie tymczasowej tabeli (373)
  • Klasy obiektów tymczasowych (374)
  • Trwałe obiekty tymczasowe (375)
• WAITFOR (375)
• Zaawansowane techniki tworzenia wyzwalaczy (376)
  • ROLLBACK TRIGGER (376)
  • Tabele INSERTED i DELETED (377)
• W praktyce (378)

Rozdział 17. Procedury składowane w języku PL/SQL (Oracle) (381)

• Sekcja deklaracji (382)
  • Stałe (383)
  • Deklarowanie kursorów (383)
• Sekcja poleceń wykonywalnych (384)
  • Wyprowadzanie danych (384)
  • Przypisania (385)
  • Wyrażenia warunkowe (385)
  • Pętle (386)
  • Iteracyjne przetwarzanie kursora (387)
  • Pętla FOR (387)
  • Kursory w pętlach FOR (388)
  • Pętla WHILE (388)
  • Kursory w pętlach WHILE (389)
  • GOTO (390)
  • Pobieranie wartości do zmiennych (390)
• Obsługa wyjątków (391)
  • Wyjątki definiowane przez użytkownika (392)
• Tworzenie procedur składowanych (393)
  • Tworzenie procedur (394)
  • Uruchamianie procedur składowanych (395)
• Tworzenie i stosowanie funkcji (396)
• Umieszczanie procedur i funkcji w pakietach (397)
  • Specyfikacja pakietu (397)
• Testowanie programów PL/SQL (399)
  • SHOW ERRORS (399)
  • DBMS_OUTPUT (400)
• Wyzwalacze (400)
  • Wyzwalacze INSTEAD OF (403)
  • Zarządzanie wyzwalaczami (404)
• W praktyce (405)

Część VI Przegląd baz danych (407)

Rozdział 18. Oracle (409)

• SQL*PLUS (410)
  • Uruchamianie SQL*PLUS (410)
  • Korzystanie z SQL*PLUS (411)
  • Ładowanie skryptów SQL*PLUS (412)
  • Skrypt login.sql (413)
  • Edycja poleceń SQL (413)
  • Zapisywanie danych w pliku (414)
  • Kontrolowanie sposobu prezentowania wyników (415)
• Tworzenie raportów w SQL*PLUS (417)
  • Tytułowanie raportów (417)
  • Zmiana sposobu wyświetlania danych (418)
  • Inne polecenia formatowania danych (421)
• Widoki systemowe Oracle'a (423)
  • Korzystanie z widoków systemowych (425)
• Sekwencje (426)
• Synonimy (428)
• Typy danych w Oracle'u (429)
• Zasoby na temat Oracle'a w sieci WWW (430)
• W praktyce (431)

Rozdział 19. Microsoft SQL Server i Sybase Adaptive Server (433)

• Narzędzia administracyjne baz danych (434)
  • SQL Enterprise Manager (434)
  • SQL Server Query Analyzer (436)
  • SQL Central (436)
  • ISQL (437)
• Zasady nadawania nazw obiektom w Transact-SQL (438)
• WYRAŻENIE SELECT ... INTO (438)
• Funkcje systemowe (439)
  • Identyfikowanie użytkowników (440)
  • Identyfikowanie bazy danych lub serwera (440)
  • Funkcje porównywania danych (441)
  • Funkcje walidacji danych (442)
• Wyrażenia CASE (443)
  • Złożone wyrażenia CASE (443)
  • Połączenie CASE i GROUP BY (445)
  • Użycie CASE w wyrażeniach UPDATE (446)
• Systemowe procedury składowane (447)
  • Procedury związane z bezpieczeństwem (447)
  • Procedury serwerów zdalnych (451)
  • Procedury definiujące dane (451)
• Typy danych w języku Transact-SQL (455)
• W praktyce (457)

Rozdział 20. Microsoft Access (459)

• Pliki bazy danych (459)
• ODBC (460)
• Interfejs użytkownika (460)
• Obiekty bazy danych (461)
  • Tabele (461)
  • Kwerendy (462)
  • Formularze (463)
  • Raporty (464)
  • Makra (465)
  • Moduły (465)
• Tworzenie tabel (466)
  • Tworzenie tabel przy użyciu widoku arkusza danych (466)
  • Tworzenie tabel przy użyciu widoku projektu (468)
  • Kwerendy definiujące dane (470)
• Typy danych (471)
• Tworzenie i uruchamianie zapytań (473)
  • Budowanie zapytań przy użyciu widoku projektu (473)
  • Pisanie zapytań przy użyciu widoku SQL (476)
• Tworzenie źródeł danych ODBC (476)
• Zasoby dostępne w sieci WWW (478)
• W praktyce (479)

Rozdział 21. MSQL i MySQL (481)

• Jak zdobyć MySQL i MSQL (482)
• Różnice między MySQL i MSQL (482)
• Użytkowanie MySQL (484)
  • Klient MySQL (484)
• Cechy MySQL (486)
• Ograniczenia MySQL (489)
  • Brak podzapytań (489)
  • Brak transakcji (489)
  • Procedury składowane, wyzwalacze i kursory (490)
  • Związki kluczy obcych (490)
• Typy danych stosowane w MySQL (490)
• Składnia MySQL (492)
  • Komentarze (494)
• MSQL (495)
  • Wykonywanie zapytań (496)
  • Tworzenie obiektów bazy danych (496)
  • Usuwanie obiektów (498)
  • Inne zapytania MSQL (498)
• Porównywanie łańcuchów w MSQL i MySQL (498)
  • RLIKE (499)
• W praktyce (501)

Część VII Udostępnianie baz danych w sieci WWW (503)

Rozdział 22. Podstawy programowania sieciowego (505)

• Podstawy architektury sieci WWW (505)
• HTML (506)
• Formularze HTML (507)
• Pola formularzy - znacznik <input> (509)
  • Pole tekstowe (509)
  • Pole hasła (510)
  • Pola wyboru (511)
  • Przyciski opcji (511)
  • Pole załącznika pliku (512)
  • Pola ukryte (513)
  • Przycisk SUBMIT (513)
  • Przycisk RESET (514)
  • Rysunki jako przyciski SUBMIT (515)
• Listy (515)
  • Pole TEXTAREA (517)
• CGI (518)
  • Przetwarzanie danych z formularza (519)
  • Wysyłanie odpowiedzi do przeglądarki (519)
• XML (521)
  • Publikowanie danych z użyciem XML (522)
  • XML i relacyjne bazy danych (522)
• W praktyce (523)

Rozdział 23. Serwery aplikacji WWW (525)

• Przegląd serwerów aplikacji WWW (525)
• Ogólne uwagi na temat serwerów aplikacji (526)
• Programy niezależne (527)
• Perl/CGI (527)
  • Zapisywanie danych z formularza w bazie danych (531)
  • Zapytania do bazy danych z wnętrza skryptu CGI (534)
• Programy osadzane w kodzie HTML (536)
• ColdFusion (536)
  • Zapytania do bazy danych z wnętrza programu ColdFusion (537)
• ASP (540)
  • Zapytania do bazy danych z wnętrza skryptu ASP (541)
• Serwlety Javy (543)
• Systemy oparte na wzorcach dokumentów (544)
  • Zasada działania serwerów opartych na wzorcach dokumentów (545)
• W praktyce (545)

Rozdział 24. Przykładowa aplikacja WWW (547)

• Architektura aplikacji (548)
• Strona z listą filmów (548)
• Strona informacji szczegółowych (553)
• Dodawanie nowego filmu (558)
  • Skrypt walidacji danych (562)
  • Skrypt tworzący formularz (563)
  • Modyfikacja istniejącego filmu (567)
• Edycja obsady filmu (570)
• Modyfikowanie lokalizacji zdjęć (576)
• Usuwanie filmów (579)
• W praktyce (580)

Dodatki (581)

Dodatek A Wyjątki systemowe w języku PL/SQL (583)

Skorowidz (585)