Systemy baz danych. Kompletny podręcznik. Wydanie II Hector Garcia-Molina, Jeffrey D. Ullman, Jennifer Widom

Dostępność produktu

Produkt nie został jeszcze oceniony pod kątem ułatwień dostępu lub nie podano żadnych informacji o ułatwieniach dostępu lub są one niewystarczające. Prawdopodobnie Wydawca/Dostawca jeszcze nie umożliwił dokonania walidacji produktu lub nie przekazał odpowiednich informacji na temat jego dostępności.

Spis treści książki

Wstęp (25)


O autorach (29)


1. Świat systemów baz danych (31)


• 1.1. Ewolucja systemów baz danych (31)
  
  • 1.1.1. Wczesne systemy zarządzania bazami danych (32)
  • 1.1.2. Relacyjne systemy baz danych (32)
  • 1.1.3. Coraz mniejsze systemy (33)
  • 1.1.4. Coraz większe systemy (33)
  • 1.1.5. Integrowanie informacji (34)
• 1.2. Elementy systemu zarządzania bazami danych (34)
  
  • 1.2.1. Polecenia w języku definicji danych (34)
  • 1.2.2. Omówienie przetwarzania zapytań (35)
  • 1.2.3. Zarządzanie pamięcią i buforem (36)
  • 1.2.4. Przetwarzanie transakcji (37)
  • 1.2.5. Procesor zapytań (38)
• 1.3. Zarys dziedziny systemów baz danych (38)
  
• 1.4. Literatura do rozdziału 1. (40)

I: Modelowanie relacyjnych baz danych (41)


2. Relacyjny model danych (43)


• 2.1. Przegląd modeli danych (43)
  
  • 2.1.1. Czym jest model danych? (43)
  • 2.1.2. Ważne modele danych (44)
  • 2.1.3. Krótki opis modelu relacyjnego (44)
  • 2.1.4. Krótki opis modelu semistrukturalnego (45)
  • 2.1.5. Inne modele danych (46)
  • 2.1.6. Porównanie podejść do modelowania (46)
• 2.2. Podstawy modelu relacyjnego (47)
  
  • 2.2.1. Atrybuty (47)
  • 2.2.2. Schematy (47)
  • 2.2.3. Krotki (48)
  • 2.2.4. Dziedziny (48)
  • 2.2.5. Równoważne reprezentacje relacji (49)
  • 2.2.6. Egzemplarze relacji (49)
  • 2.2.7. Klucze relacji (49)
  • 2.2.8. Przykładowy schemat bazy danych (50)
  • 2.2.9. Ćwiczenia do podrozdziału 2.2 (52)
• 2.3. Definiowanie schematu relacji w języku SQL (53)
  
  • 2.3.1. Relacje w SQL-u (53)
  • 2.3.2. Typy danych (54)
  • 2.3.3. Proste deklaracje tabel (55)
  • 2.3.4. Modyfikowanie schematów relacji (56)
  • 2.3.5. Wartości domyślne (57)
  • 2.3.6. Deklarowanie kluczy (57)
  • 2.3.7. Ćwiczenia do podrozdziału 2.3 (59)
• 2.4. Algebraiczny język zapytań (60)
  
  • 2.4.1. Dlaczego potrzebujemy specjalnego języka zapytań? (61)
  • 2.4.2. Czym jest algebra? (61)
  • 2.4.3. Przegląd algebry relacji (61)
  • 2.4.4. Operacje specyficzne dla zbiorów wykonywane na relacjach (62)
  • 2.4.5. Projekcja (63)
  • 2.4.6. Selekcja (64)
  • 2.4.7. Iloczyn kartezjański (65)
  • 2.4.8. Złączenia naturalne (65)
  • 2.4.9. Złączenia warunkowe (68)
  • 2.4.10. Łączenie operacji w celu tworzenia zapytań (69)
  • 2.4.11. Nadawanie i zmienianie nazw (70)
  • 2.4.12. Zależności między operacjami (71)
  • 2.4.13. Notacja liniowa wyrażeń algebraicznych (72)
  • 2.4.14. Ćwiczenia do podrozdziału 2.4 (73)
• 2.5. Więzy relacji (79)
  
  • 2.5.1. Algebra relacji jako język więzów (79)
  • 2.5.2. Więzy integralności referencyjnej (80)
  • 2.5.3. Więzy klucza (81)
  • 2.5.4. Inne przykłady dotyczące więzów (82)
  • 2.5.5. Ćwiczenia do podrozdziału 2.5 (82)
• 2.6. Podsumowanie rozdziału 2. (83)
  
• 2.7. Literatura do rozdziału 2. (84)

3. Teoria projektowania relacyjnych baz danych (85)


• 3.1. Zależności funkcyjne (85)
  
  • 3.1.1. Definicja zależności funkcyjnej (86)
  • 3.1.2. Klucze relacji (87)
  • 3.1.3. Nadklucze (88)
  • 3.1.4. Ćwiczenia do podrozdziału 3.1 (89)
• 3.2. Reguły dotyczące zależności funkcyjnych (89)
  
  • 3.2.1. Wnioskowanie na temat zależności funkcyjnych (90)
  • 3.2.2. Reguła podziału i łączenia (90)
  • 3.2.3. Trywialne zależności funkcyjne (91)
  • 3.2.4. Obliczanie domknięcia atrybutów (92)
  • 3.2.5. Dlaczego algorytm obliczania domknięć działa? (94)
  • 3.2.6. Reguła przechodniości (96)
  • 3.2.7. Domykanie zbiorów zależności funkcyjnych (97)
  • 3.2.8. Projekcje zależności funkcyjnych (98)
  • 3.2.9. Ćwiczenia do podrozdziału 3.2 (99)
• 3.3. Projektowanie schematów relacyjnych baz danych (101)
  
  • 3.3.1. Anomalie (101)
  • 3.3.2. Dekompozycja relacji (102)
  • 3.3.3. Postać normalna Boyce'a-Codda (103)
  • 3.3.4. Dekompozycja do BCNF (104)
  • 3.3.5. Ćwiczenia do podrozdziału 3.3 (107)
• 3.4. Dekompozycja - dobre, złe i okropne skutki (108)
  
  • 3.4.1. Odzyskiwanie informacji po dekompozycji (108)
  • 3.4.2. Test dla złączeń bezstratnych oparty na algorytmie chase (111)
  • 3.4.3. Dlaczego algorytm chase działa? (113)
  • 3.4.4. Zachowywanie zależności (114)
  • 3.4.5. Ćwiczenia do podrozdziału 3.4 (115)
• 3.5. Trzecia postać normalna (116)
  
  • 3.5.1. Definicja trzeciej postaci normalnej (116)
  • 3.5.2. Algorytm syntezy do schematów o trzeciej postaci normalnej (117)
  • 3.5.3. Dlaczego algorytm syntezy do 3NF działa? (118)
  • 3.5.4. Ćwiczenia do podrozdziału 3.5 (118)
• 3.6. Zależności wielowartościowe (119)
  
  • 3.6.1. Niezależność atrybutów i wynikająca z tego nadmiarowość (119)
  • 3.6.2. Definicja zależności wielowartościowej (120)
  • 3.6.3. Wnioskowanie na temat ZW (121)
  • 3.6.4. Czwarta postać normalna (123)
  • 3.6.5. Dekompozycja do czwartej postaci normalnej (124)
  • 3.6.6. Związki między postaciami normalnymi (125)
  • 3.6.7. Ćwiczenia do podrozdziału 3.6 (126)
• 3.7. Algorytm wyprowadzania ZW (127)
  
  • 3.7.1. Domknięcie i algorytm chase (127)
  • 3.7.2. Rozszerzanie algorytmu chase na ZW (128)
  • 3.7.3. Dlaczego algorytm chase działa dla ZW? (130)
  • 3.7.4. Projekcje ZW (131)
  • 3.7.5. Ćwiczenia do podrozdziału 3.7 (132)
• 3.8. Podsumowanie rozdziału 3. (132)
  
• 3.9. Literatura do rozdziału 3. (134)

4. Wysokopoziomowe modele baz danych (135)


• 4.1. Model związków encji (136)
  
  • 4.1.1. Zbiory encji (136)
  • 4.1.2. Atrybuty (136)
  • 4.1.3. Związki (137)
  • 4.1.4. Diagramy ER (137)
  • 4.1.5. Egzemplarze diagramów ER (138)
  • 4.1.6. Krotność w związkach binarnych w modelu ER (139)
  • 4.1.7. Związki wieloargumentowe (139)
  • 4.1.8. Role w związkach (140)
  • 4.1.9. Atrybuty związków (142)
  • 4.1.10. Przekształcanie związków wieloargumentowych na binarne (143)
  • 4.1.11. Podklasy w modelu ER (144)
  • 4.1.12. Ćwiczenia do podrozdziału 4.1 (146)
• 4.2. Zasady projektowania (148)
  
  • 4.2.1. Wierność (148)
  • 4.2.2. Unikanie nadmiarowości (149)
  • 4.2.3. Prostota ma znaczenie (149)
  • 4.2.4. Wybór odpowiednich związków (149)
  • 4.2.5. Wybór elementów odpowiedniego rodzaju (151)
  • 4.2.6. Ćwiczenia do podrozdziału 4.2 (153)
• 4.3. Więzy w modelu ER (155)
  
  • 4.3.1. Klucze w modelu ER (155)
  • 4.3.2. Reprezentowanie kluczy w modelu ER (155)
  • 4.3.3. Integralność referencyjna (156)
  • 4.3.4. Więzy stopni (157)
  • 4.3.5. Ćwiczenia do podrozdziału 4.3 (157)
• 4.4. Słabe zbiory encji (158)
  
  • 4.4.1. Przyczyny tworzenia słabych zbiorów encji (158)
  • 4.4.2. Wymogi związane ze słabymi zbiorami encji (160)
  • 4.4.3. Notacja do opisu słabych zbiorów encji (161)
  • 4.4.4. Ćwiczenia do podrozdziału 4.4 (161)
• 4.5. Z diagramów ER na projekty relacyjne (162)
  
  • 4.5.1. Ze zbiorów encji na relacje (162)
  • 4.5.2. Ze związków ER na relacje (163)
  • 4.5.3. Łączenie relacji (165)
  • 4.5.4. Przekształcanie słabych zbiorów encji (166)
  • 4.5.5. Ćwiczenia do podrozdziału 4.5 (168)
• 4.6. Przekształcanie struktur podklas na relacje (169)
  
  • 4.6.1. Przekształcanie w stylu modelu ER (170)
  • 4.6.2. Podejście obiektowe (171)
  • 4.6.3. Stosowanie wartości null do łączenia relacji (171)
  • 4.6.4. Porównanie podejść (172)
  • 4.6.5. Ćwiczenia do podrozdziału 4.6 (173)
• 4.7. Język UML (174)
  
  • 4.7.1. Klasy w języku UML (174)
  • 4.7.2. Klucze klas w UML-u (175)
  • 4.7.3. Asocjacje (175)
  • 4.7.4. Asocjacje zwrotne (177)
  • 4.7.5. Klasy asocjacji (177)
  • 4.7.6. Podklasy w UML-u (178)
  • 4.7.7. Agregacje i kompozycje (179)
  • 4.7.8. Ćwiczenia do podrozdziału 4.7 (180)
• 4.8. Z diagramów UML na relacje (181)
  
  • 4.8.1. Podstawy przekształcania diagramów UML na relacje (181)
  • 4.8.2. Z podklas w UML-u na relacje (181)
  • 4.8.3. Z agregacji i kompozycji na relacje (182)
  • 4.8.4. Odpowiednik słabych zbiorów encji w UML-u (183)
  • 4.8.5. Ćwiczenia do podrozdziału 4.8 (184)
• 4.9. Język ODL (184)
  
  • 4.9.1. Deklaracje klas (184)
  • 4.9.2. Atrybuty w ODL-u (185)
  • 4.9.3. Związki w ODL-u (186)
  • 4.9.4. Związki zwrotne (186)
  • 4.9.5. Krotność związków (187)
  • 4.9.6. Typy w ODL-u (188)
  • 4.9.7. Podklasy w ODL-u (190)
  • 4.9.8. Deklarowanie kluczy w ODL-u (190)
  • 4.9.9. Ćwiczenia do podrozdziału 4.9 (192)
• 4.10. Z projektów w ODL-u na projekty relacyjne (192)
  
  • 4.10.1. Z klas w ODL-u na relacje (193)
  • 4.10.2. Atrybuty złożone w klasach (193)
  • 4.10.3. Przedstawianie atrybutów wartości w formie zbioru (194)
  • 4.10.4. Reprezentowanie innych konstruktorów typów (195)
  • 4.10.5. Przedstawianie związków w ODL-u (197)
  • 4.10.6. Ćwiczenia do podrozdziału 4.10 (197)
• 4.11. Podsumowanie rozdziału 4. (198)
  
• 4.12. Literatura do rozdziału 4. (200)

II: Programowanie relacyjnych baz danych (201)


5. Algebraiczne i logiczne języki zapytań (203)


• 5.1. Operacje relacyjne na wielozbiorach (203)
  
  • 5.1.1. Dlaczego wielozbiory? (204)
  • 5.1.2. Suma, część wspólna i różnica dla wielozbiorów (205)
  • 5.1.3. Projekcje wielozbiorów (206)
  • 5.1.4. Selekcja na wielozbiorach (207)
  • 5.1.5. Iloczyn kartezjański wielozbiorów (207)
  • 5.1.6. Złączenia wielozbiorów (208)
  • 5.1.7. Ćwiczenia do podrozdziału 5.1 (209)
• 5.2. Dodatkowe operatory algebry relacji (210)
  
  • 5.2.1. Eliminowanie powtórzeń (211)
  • 5.2.2. Operatory agregacji (211)
  • 5.2.3. Grupowanie (212)
  • 5.2.4. Operator grupowania (213)
  • 5.2.5. Rozszerzanie operatora projekcji (214)
  • 5.2.6. Operator sortowania (215)
  • 5.2.7. Złączenia zewnętrzne (216)
  • 5.2.8. Ćwiczenia do podrozdziału 5.2 (218)
• 5.3. Logika relacji (219)
  
  • 5.3.1. Predykaty i atomy (219)
  • 5.3.2. Atomy arytmetyczne (220)
  • 5.3.3. Reguły i zapytania w Datalogu (220)
  • 5.3.4. Znaczenie reguł Datalogu (221)
  • 5.3.5. Predykaty ekstensjonalne i intensjonalne (223)
  • 5.3.6. Reguły Datalogu stosowane do wielozbiorów (224)
  • 5.3.7. Ćwiczenia do podrozdziału 5.3 (225)
• 5.4. Algebra relacji i Datalog (226)
  
  • 5.4.1. Operacje logiczne (226)
  • 5.4.2. Projekcja (227)
  • 5.4.3. Selekcja (228)
  • 5.4.4. Iloczyn kartezjański (230)
  • 5.4.5. Złączenia (230)
  • 5.4.6. Symulowanie w Datalogu operacji złożonych (231)
  • 5.4.7. Porównanie Datalogu i algebry relacji (232)
  • 5.4.8. Ćwiczenia do podrozdziału 5.4 (233)
• 5.5. Podsumowanie rozdziału 5. (234)
  
• 5.6. Literatura do rozdziału 5. (235)

6. SQL - język baz danych (237)


• 6.1. Proste zapytania w SQL-u (238)
  
  • 6.1.1. Projekcje w SQL-u (240)
  • 6.1.2. Selekcja w SQL-u (242)
  • 6.1.3. Porównywanie łańcuchów znaków (243)
  • 6.1.4. Dopasowywanie wzorców w SQL-u (243)
  • 6.1.5. Data i czas (244)
  • 6.1.6. Wartości NULL i porównania z takimi wartościami (245)
  • 6.1.7. Wartość logiczna UNKNOWN (246)
  • 6.1.8. Porządkowanie danych wyjściowych (248)
  • 6.1.9. Ćwiczenia do podrozdziału 6.1 (249)
• 6.2. Zapytania obejmujące więcej niż jedną relację (251)
  
  • 6.2.1. Iloczyn kartezjański i złączenia w SQL-u (251)
  • 6.2.2. Jednoznaczne określanie atrybutów (252)
  • 6.2.3. Zmienne krotkowe (253)
  • 6.2.4. Przetwarzanie zapytań obejmujących wiele relacji (254)
  • 6.2.5. Suma, część wspólna i różnica zapytań (256)
  • 6.2.6. Ćwiczenia do podrozdziału 6.2 (258)
• 6.3. Podzapytania (259)
  
  • 6.3.1. Podzapytania zwracające wartości skalarne (260)
  • 6.3.2. Warunki dotyczące relacji (261)
  • 6.3.3. Warunki obejmujące krotki (262)
  • 6.3.4. Podzapytania skorelowane (263)
  • 6.3.5. Podzapytania w klauzulach FROM (264)
  • 6.3.6. Wyrażenia ze złączeniami w SQL-u (265)
  • 6.3.7. Złączenia naturalne (266)
  • 6.3.8. Złączenia zewnętrzne (267)
  • 6.3.9. Ćwiczenia do podrozdziału 6.3 (269)
• 6.4. Operacje na całych relacjach (271)
  
  • 6.4.1. Eliminowanie powtórzeń (271)
  • 6.4.2. Powtórzenia w sumach, częściach wspólnych i różnicach (272)
  • 6.4.3. Grupowanie i agregacja w SQL-u (273)
  • 6.4.4. Operatory agregacji (273)
  • 6.4.5. Grupowanie (274)
  • 6.4.6. Grupowanie, agregacja i wartości null (276)
  • 6.4.7. Klauzule HAVING (277)
  • 6.4.8. Ćwiczenia do podrozdziału 6.4 (278)
• 6.5. Modyfikowanie bazy danych (279)
  
  • 6.5.1. Wstawianie (279)
  • 6.5.2. Usuwanie (281)
  • 6.5.3. Aktualizowanie (282)
  • 6.5.4. Ćwiczenia do podrozdziału 6.5 (283)
• 6.6. Transakcje w SQL-u (284)
  
  • 6.6.1. Możliwość szeregowania operacji (284)
  • 6.6.2. Atomowość (286)
  • 6.6.3. Transakcje (286)
  • 6.6.4. Transakcje tylko do odczytu (287)
  • 6.6.5. Odczyt "brudnych danych" (288)
  • 6.6.6. Inne poziomy izolacji (291)
  • 6.6.7. Ćwiczenia do podrozdziału 6.6 (292)
• 6.7. Podsumowanie rozdziału 6. (293)
  
• 6.8. Literatura do rozdziału 6. (294)

7. Więzy i wyzwalacze (295)


• 7.1. Klucze zwykłe i klucze obce (295)
  
  • 7.1.1. Deklarowanie więzów klucza obcego (296)
  • 7.1.2. Zachowywanie integralności referencyjnej (297)
  • 7.1.3. Odroczone sprawdzanie więzów (299)
  • 7.1.4. Ćwiczenia do podrozdziału 7.1 (301)
• 7.2. Więzy atrybutów i krotek (302)
  
  • 7.2.1. Więzy NOT NULL (302)
  • 7.2.2. Więzy CHECK atrybutów (303)
  • 7.2.3. Więzy CHECK krotek (304)
  • 7.2.4. Porównanie więzów krotek i atrybutów (305)
  • 7.2.5. Ćwiczenia do podrozdziału 7.2 (306)
• 7.3. Modyfikowanie więzów (307)
  
  • 7.3.1. Przypisywanie nazw więzom (307)
  • 7.3.2. Modyfikowanie więzów tabel (308)
  • 7.3.3. Ćwiczenia do podrozdziału 7.3 (309)
• 7.4. Asercje (309)
  
  • 7.4.1. Tworzenie asercji (310)
  • 7.4.2. Stosowanie asercji (310)
  • 7.4.3. Ćwiczenia do podrozdziału 7.4 (311)
• 7.5. Wyzwalacze (312)
  
  • 7.5.1. Wyzwalacze w SQL-u (313)
  • 7.5.2. Możliwości w zakresie projektowania wyzwalaczy (314)
  • 7.5.3. Ćwiczenia do podrozdziału 7.5 (317)
• 7.6. Podsumowanie rozdziału 7. (319)
  
• 7.7. Literatura do rozdziału 7. (319)

8. Widoki i indeksy (321)


• 8.1. Widoki wirtualne (321)
  
  • 8.1.1. Deklarowanie widoków (321)
  • 8.1.2. Zapytania o widoki (323)
  • 8.1.3. Zmienianie nazw atrybutów (323)
  • 8.1.4. Ćwiczenia do podrozdziału 8.1 (324)
• 8.2. Modyfikowanie widoków (324)
  
  • 8.2.1. Usuwanie widoku (324)
  • 8.2.2. Widoki modyfikowalne (325)
  • 8.2.3. Wyzwalacze INSTEAD OF dla widoków (327)
  • 8.2.4. Ćwiczenia do podrozdziału 8.2 (328)
• 8.3. Indeksy w SQL-u (329)
  
  • 8.3.1. Cel stosowania indeksów (329)
  • 8.3.2. Deklarowanie indeksów (330)
  • 8.3.3. Ćwiczenia do podrozdziału 8.3 (331)
• 8.4. Wybieranie indeksów (331)
  
  • 8.4.1. Prosty model kosztów (331)
  • 8.4.2. Wybrane przydatne indeksy (332)
  • 8.4.3. Obliczanie najlepszych indeksów (333)
  • 8.4.4. Automatyczne wybieranie tworzonych indeksów (336)
  • 8.4.5. Ćwiczenia do podrozdziału 8.4 (337)
• 8.5. Widoki zmaterializowane (337)
  
  • 8.5.1. Przechowywanie widoku zmaterializowanego (338)
  • 8.5.2. Okresowa konserwacja widoków zmaterializowanych (339)
  • 8.5.3. Modyfikowanie zapytań w celu zastosowania widoków zmaterializowanych (340)
  • 8.5.4. Automatyczne tworzenie widoków zmaterializowanych (342)
  • 8.5.5. Ćwiczenia do podrozdziału 8.5 (342)
• 8.6. Podsumowanie rozdziału 8. (343)
  
• 8.7. Literatura do rozdziału 8. (344)

9. SQL w środowisku serwerowym (345)


• 9.1. Architektura trójwarstwowa (345)
  
  • 9.1.1. Warstwa serwerów WWW (346)
  • 9.1.2. Warstwa aplikacji (347)
  • 9.1.3. Warstwa bazy danych (347)
• 9.2. Środowisko SQL-a (348)
  
  • 9.2.1. Środowiska (348)
  • 9.2.2. Schematy (349)
  • 9.2.3. Katalogi (350)
  • 9.2.4. Klienty i serwery w środowisku SQL-a (350)
  • 9.2.5. Połączenia (351)
  • 9.2.6. Sesje (352)
  • 9.2.7. Moduły (352)
• 9.3. Interfejs łączący SQL z językiem macierzystym (353)
  
  • 9.3.1. Problem niezgodności impedancji (354)
  • 9.3.2. Łączenie SQL-a z językiem macierzystym (355)
  • 9.3.3. Sekcja DECLARE (355)
  • 9.3.4. Używanie zmiennych wspólnych (356)
  • 9.3.5. Jednowierszowe instrukcje SELECT (357)
  • 9.3.6. Kursory (357)
  • 9.3.7. Modyfikowanie danych za pomocą kursora (359)
  • 9.3.8. Zabezpieczanie się przed jednoczesnymi aktualizacjami (360)
  • 9.3.9. Dynamiczny SQL (361)
  • 9.3.10. Ćwiczenia do podrozdziału 9.3 (362)
• 9.4. Procedury składowane (363)
  
  • 9.4.1. Tworzenie funkcji i procedur w PSM-ie (364)
  • 9.4.2. Wybrane proste formy instrukcji w PSM-ie (365)
  • 9.4.3. Instrukcje rozgałęziające (366)
  • 9.4.4. Zapytania w PSM-ie (367)
  • 9.4.5. Pętle w PSM-ie (368)
  • 9.4.6. Pętle FOR (370)
  • 9.4.7. Wyjątki w PSM-ie (371)
  • 9.4.8. Stosowanie funkcji i procedur PSM-a (373)
  • 9.4.9. Ćwiczenia do podrozdziału 9.4 (373)
• 9.5. Używanie interfejsu poziomu wywołań (375)
  
  • 9.5.1. Wprowadzenie do SQL/CLI (375)
  • 9.5.2. Przetwarzanie instrukcji (377)
  • 9.5.3. Pobieranie danych z wyników zapytania (378)
  • 9.5.4. Przekazywanie parametrów do zapytań (380)
  • 9.5.5. Ćwiczenia do podrozdziału 9.5 (381)
• 9.6. Interfejs JDBC (381)
  
  • 9.6.1. Wprowadzenie do JDBC (381)
  • 9.6.2. Tworzenie instrukcji w JDBC (382)
  • 9.6.3. Operacje na kursorach w JDBC (384)
  • 9.6.4. Przekazywanie parametrów (385)
  • 9.6.5. Ćwiczenia do podrozdziału 9.6 (385)
• 9.7. PHP (385)
  
  • 9.7.1. Podstawy PHP (386)
  • 9.7.2. Tablice (387)
  • 9.7.3. Biblioteka DB z repozytorium PEAR (387)
  • 9.7.4. Tworzenie połączenia z bazą danych za pomocą biblioteki DB (388)
  • 9.7.5. Wykonywanie instrukcji SQL-a (388)
  • 9.7.6. Operacje oparte na kursorze w PHP (389)
  • 9.7.7. Dynamiczny SQL w PHP (389)
  • 9.7.8. Ćwiczenia do podrozdziału 9.7 (390)
• 9.8. Podsumowanie rozdziału 9. (390)
  
• 9.9. Literatura do rozdziału 9. (391)

10. Zaawansowane zagadnienia z obszaru relacyjnych baz danych (393)


• 10.1. Bezpieczeństwo i uwierzytelnianie użytkowników w SQL-u (393)
  
  • 10.1.1. Uprawnienia (394)
  • 10.1.2. Tworzenie uprawnień (395)
  • 10.1.3. Proces sprawdzania uprawnień (396)
  • 10.1.4. Przyznawanie uprawnień (397)
  • 10.1.5. Diagramy przyznanych uprawnień (398)
  • 10.1.6. Odbieranie uprawnień (400)
  • 10.1.7. Ćwiczenia do podrozdziału 10.1 (403)
• 10.2. Rekurencja w SQL-u (404)
  
  • 10.2.1. Definiowanie relacji rekurencyjnych w SQL-u (404)
  • 10.2.2. Problematyczne wyrażenia w rekurencyjnym SQL-u (407)
  • 10.2.3. Ćwiczenia do podrozdziału 10.2 (409)
• 10.3. Model obiektowo-relacyjny (410)
  
  • 10.3.1. Od relacji do relacji obiektowych (411)
  • 10.3.2. Relacje zagnieżdżone (411)
  • 10.3.3. Referencje (413)
  • 10.3.4. Podejście obiektowe a obiektowo-relacyjne (414)
  • 10.3.5. Ćwiczenia do podrozdziału 10.3 (415)
• 10.4. Typy definiowane przez użytkownika w SQL-u (415)
  
  • 10.4.1. Definiowanie typów w SQL-u (415)
  • 10.4.2. Deklaracje metod w typach UDT (417)
  • 10.4.3. Definicje metod (417)
  • 10.4.4. Deklarowanie relacji za pomocą typów UDT (418)
  • 10.4.5. Referencje (418)
  • 10.4.6. Tworzenie identyfikatorów obiektów dla tabel (419)
  • 10.4.7. Ćwiczenia do podrozdziału 10.4 (421)
• 10.5. Operacje na danych obiektowo-relacyjnych (421)
  
  • 10.5.1. Podążanie za referencjami (421)
  • 10.5.2. Dostęp do komponentów krotek o typie UDT (422)
  • 10.5.3. Generatory i modyfikatory (423)
  • 10.5.4. Sortowanie elementów o typie UDT (425)
  • 10.5.5. Ćwiczenia do podrozdziału 10.5 (426)
• 10.6. Techniki OLAP (427)
  
  • 10.6.1. OLAP i hurtownie danych (428)
  • 10.6.2. Aplikacje OLAP (428)
  • 10.6.3. Wielowymiarowe ujęcie danych w aplikacjach OLAP (429)
  • 10.6.4. Schemat gwiazdy (430)
  • 10.6.5. Podział i wycinki (432)
  • 10.6.6. Ćwiczenia do podrozdziału 10.6 (434)
• 10.7. Kostki danych (435)
  
  • 10.7.1. Operator kostki (CUBE) (435)
  • 10.7.2. Operator kostki w SQL-u (437)
  • 10.7.3. Ćwiczenia do podrozdziału 10.7 (438)
• 10.8. Podsumowanie rozdziału 10. (439)
  
• 10.9. Literatura do rozdziału 10. (441)

III: Modelowanie i programowanie danych semistrukturalnych (443)


11. Semistrukturalny model danych (445)


• 11.1. Dane semistrukturalne (445)
  
  • 11.1.1. Uzasadnienie powstania modelu danych semistrukturalnych (445)
  • 11.1.2. Reprezentowanie danych semistrukturalnych (446)
  • 11.1.3. Integrowanie informacji za pomocą danych semistrukturalnych (447)
  • 11.1.4. Ćwiczenia do podrozdziału 11.1 (449)
• 11.2. XML (449)
  
  • 11.2.1. Znaczniki semantyczne (449)
  • 11.2.2. XML ze schematem i bez niego (450)
  • 11.2.3. Poprawny składniowo XML (450)
  • 11.2.4. Atrybuty (452)
  • 11.2.5. Atrybuty łączące elementy (452)
  • 11.2.6. Przestrzenie nazw (453)
  • 11.2.7. XML i bazy danych (454)
  • 11.2.8. Ćwiczenia do podrozdziału 11.2 (455)
• 11.3. Definicje typów dokumentu (455)
  
  • 11.3.1. Forma definicji DTD (456)
  • 11.3.2. Korzystanie z definicji DTD (458)
  • 11.3.3. Listy atrybutów (459)
  • 11.3.4. Identyfikatory i referencje (460)
  • 11.3.5. Ćwiczenia do podrozdziału 11.3 (461)
• 11.4. XML Schema (462)
  
  • 11.4.1. Struktura dokumentów XML Schema (462)
  • 11.4.2. Elementy (462)
  • 11.4.3. Typy złożone (463)
  • 11.4.4. Atrybuty (465)
  • 11.4.5. Typy proste z ograniczeniami (466)
  • 11.4.6. Klucze w XML Schema (467)
  • 11.4.7. Klucze obce w dokumentach XML Schema (469)
  • 11.4.8. Ćwiczenia do podrozdziału 11.4 (471)
• 11.5. Podsumowanie rozdziału 11. (471)
  
• 11.6. Literatura do rozdziału 11. (472)

12. Języki programowania dla formatu XML (473)


• 12.1. XPath (473)
  
  • 12.1.1. Model danych w języku XPath (473)
  • 12.1.2. Węzły dokumentu (474)
  • 12.1.3. Wyrażenia XPath (475)
  • 12.1.4. Względne wyrażenia XPath (476)
  • 12.1.5. Atrybuty w wyrażeniach XPath (476)
  • 12.1.6. Osie (477)
  • 12.1.7. Kontekst wyrażeń (478)
  • 12.1.8. Symbole wieloznaczne (478)
  • 12.1.9. Warunki w wyrażeniach XPath (479)
  • 12.1.10. Ćwiczenia do podrozdziału 12.1 (481)
• 12.2. Język XQuery (483)
  
  • 12.2.1. Podstawy języka XQuery (484)
  • 12.2.2. Wyrażenia FLWR (484)
  • 12.2.3. Zastępowanie zmiennych ich wartościami (488)
  • 12.2.4. Złączenia w XQuery (489)
  • 12.2.5. Operatory porównywania w XQuery (490)
  • 12.2.6. Eliminowanie powtórzeń (491)
  • 12.2.7. Kwantyfikatory w XQuery (492)
  • 12.2.8. Agregacje (492)
  • 12.2.9. Rozgałęzianie w wyrażeniach XQuery (493)
  • 12.2.10. Sortowanie wyników zapytania (494)
  • 12.2.11. Ćwiczenia do podrozdziału 12.2 (495)
• 12.3. Język XSLT (496)
  
  • 12.3.1. Podstawy języka XSLT (496)
  • 12.3.2. Szablony (496)
  • 12.3.3. Pobieranie wartości z danych w formacie XML (497)
  • 12.3.4. Rekurencyjne stosowanie szablonów (498)
  • 12.3.5. Iteracje w XSLT (500)
  • 12.3.6. Instrukcje warunkowe w XSLT (501)
  • 12.3.7. Ćwiczenia do podrozdziału 12.3 (502)
• 12.4. Podsumowanie rozdziału 12. (503)
  
• 12.5. Literatura do rozdziału 12. (504)

IV: Implementowanie systemów baz danych (505)


13. Zarządzanie pamięcią drugiego stopnia (507)


• 13.1. Hierarchia pamięci (507)
  
  • 13.1.1. Hierarchia pamięci (507)
  • 13.1.2. Transfer danych między poziomami (509)
  • 13.1.3. Pamięć nietrwała i trwała (509)
  • 13.1.4. Pamięć wirtualna (510)
  • 13.1.5. Ćwiczenia do podrozdziału 13.1 (511)
• 13.2. Dyski (511)
  
  • 13.2.1. Mechanika dysków (511)
  • 13.2.2. Kontroler dysku (513)
  • 13.2.3. Cechy operacji dostępu do dysku (513)
  • 13.2.4. Ćwiczenia do podrozdziału 13.2 (515)
• 13.3. Przyspieszanie dostępu do pamięci drugiego stopnia (516)
  
  • 13.3.1. Model przetwarzania oparty na wejściu-wyjściu (516)
  • 13.3.2. Porządkowanie danych według cylindrów (517)
  • 13.3.3. Używanie wielu dysków (517)
  • 13.3.4. Tworzenie dysków lustrzanych (518)
  • 13.3.5. Szeregowanie operacji dyskowych i algorytm windy (518)
  • 13.3.6. Wstępne pobieranie i buforowanie na dużą skalę (520)
  • 13.3.7. Ćwiczenia do podrozdziału 13.3 (521)
• 13.4. Problemy z dyskami (522)
  
  • 13.4.1. Nieregularne błędy (522)
  • 13.4.2. Sumy kontrolne (523)
  • 13.4.3. Pamięć stabilna (524)
  • 13.4.4. Możliwości obsługi błędów w pamięci stabilnej (524)
  • 13.4.5. Przywracanie danych po awarii dysku (525)
  • 13.4.6. Tworzenie kopii lustrzanych jako technika zapewniania nadmiarowości (525)
  • 13.4.7. Bloki parzystości (526)
  • 13.4.8. Usprawnienie - RAID 5 (529)
  • 13.4.9. Obsługa awarii kilku dysków (529)
  • 13.4.10. Ćwiczenia do podrozdziału 13.4 (532)
• 13.5. Porządkowanie danych na dysku (534)
  
  • 13.5.1. Rekordy o stałej długości (535)
  • 13.5.2. Umieszczanie rekordów o stałej długości w blokach (536)
  • 13.5.3. Ćwiczenia do podrozdziału 13.5 (537)
• 13.6. Przedstawianie adresów bloków i rekordów (537)
  
  • 13.6.1. Adresy w systemach klient-serwer (537)
  • 13.6.2. Adresy logiczne i ustrukturyzowane (538)
  • 13.6.3. Przemiana wskaźników (539)
  • 13.6.4. Zapisywanie bloków z powrotem na dysku (542)
  • 13.6.5. Rekordy i bloki przyklejone (543)
  • 13.6.6. Ćwiczenia do podrozdziału 13.6 (544)
• 13.7. Dane i rekordy o zmiennej długości (545)
  
  • 13.7.1. Rekordy o polach o zmiennej długości (546)
  • 13.7.2. Rekordy z powtarzającymi się polami (546)
  • 13.7.3. Rekordy o zmiennym formacie (548)
  • 13.7.4. Rekordy, które nie mieszczą się w bloku (549)
  • 13.7.5. Obiekty BLOB (549)
  • 13.7.6. Zapisywanie kolumn (550)
  • 13.7.7. Ćwiczenia do podrozdziału 13.7 (551)
• 13.8. Modyfikowanie rekordów (552)
  
  • 13.8.1. Wstawianie (552)
  • 13.8.2. Usuwanie (553)
  • 13.8.3. Aktualizacje (554)
  • 13.8.4. Ćwiczenia do podrozdziału 13.8 (555)
• 13.9. Podsumowanie rozdziału 13. (555)
  
• 13.10. Literatura do rozdziału 13. (557)

14. Struktury indeksów (559)


• 14.1. Podstawy struktur indeksów (560)
  
  • 14.1.1. Pliki sekwencyjne (560)
  • 14.1.2. Indeksy gęste (561)
  • 14.1.3. Indeksy rzadkie (562)
  • 14.1.4. Wiele poziomów indeksu (562)
  • 14.1.5. Indeksy pomocnicze (563)
  • 14.1.6. Zastosowania indeksów pomocniczych (564)
  • 14.1.7. Poziom pośredni w indeksach pomocniczych (565)
  • 14.1.8. Pobieranie dokumentów i indeksy odwrócone (567)
  • 14.1.9. Ćwiczenia do podrozdziału 14.1 (570)
• 14.2. Drzewa zbalansowane (571)
  
  • 14.2.1. Struktura drzew zbalansowanych (572)
  • 14.2.2. Zastosowania drzew zbalansowanych (574)
  • 14.2.3. Wyszukiwanie w drzewach zbalansowanych (576)
  • 14.2.4. Zapytania zakresowe (576)
  • 14.2.5. Wstawianie elementów do drzew zbalansowanych (577)
  • 14.2.6. Usuwanie elementów z drzew zbalansowanych (579)
  • 14.2.7. Wydajność drzew zbalansowanych (582)
  • 14.2.8. Ćwiczenia do podrozdziału 14.2 (582)
• 14.3. Tablice z haszowaniem (584)
  
  • 14.3.1. Tablice z haszowaniem w pamięci drugiego stopnia (584)
  • 14.3.2. Wstawianie elementów do tablicy z haszowaniem (585)
  • 14.3.3. Usuwanie elementów z tablicy z haszowaniem (586)
  • 14.3.4. Wydajność indeksów opartych na tablicy z haszowaniem (587)
  • 14.3.5. Tablice z haszowaniem rozszerzalnym (587)
  • 14.3.6. Wstawianie do tablic z haszowaniem rozszerzalnym (588)
  • 14.3.7. Tablice z haszowaniem liniowym (590)
  • 14.3.8. Wstawianie do tablic z haszowaniem liniowym (591)
  • 14.3.9. Ćwiczenia do podrozdziału 14.3 (593)
• 14.4. Indeksy wielowymiarowe (595)
  
  • 14.4.1. Zastosowania indeksów wielowymiarowych (595)
  • 14.4.2. Wykonywanie zapytań zakresowych za pomocą tradycyjnych indeksów (596)
  • 14.4.3. Wykonywanie zapytań o najbliższego sąsiada z wykorzystaniem tradycyjnych indeksów (597)
  • 14.4.4. Przegląd struktur wielowymiarowych indeksów (598)
• 14.5. Struktury haszujące na wielowymiarowe dane (598)
  
  • 14.5.1. Pliki siatki (598)
  • 14.5.2. Wyszukiwanie w pliku siatki (599)
  • 14.5.3. Wstawianie danych do plików siatki (600)
  • 14.5.4. Wydajność plików siatki (602)
  • 14.5.5. Podzielone funkcje haszujące (603)
  • 14.5.6. Porównanie plików siatki i haszowania podzielonego (604)
  • 14.5.7. Ćwiczenia do podrozdziału 14.5 (605)
• 14.6. Struktury drzewiaste dla danych wielowymiarowych (606)
  
  • 14.6.1. Indeksy na wielu kluczach (607)
  • 14.6.2. Wydajność indeksów na wielu kluczach (607)
  • 14.6.3. Drzewa kd (608)
  • 14.6.4. Operacje na drzewach kd (610)
  • 14.6.5. Przystosowywanie drzew kd do pamięci drugiego stopnia (611)
  • 14.6.6. Drzewa czwórkowe (612)
  • 14.6.7. R-drzewa (613)
  • 14.6.8. Operacje na r-drzewach (614)
  • 14.6.9. Ćwiczenia do podrozdziału 14.6 (616)
• 14.7. Indeksy bitmapowe (617)
  
  • 14.7.1. Uzasadnienie stosowania indeksów bitmapowych (618)
  • 14.7.2. Bitmapy skompresowane (620)
  • 14.7.3. Operacje na wektorach bitowych w postaci kodów długości serii (621)
  • 14.7.4. Zarządzanie indeksami bitmapowymi (622)
  • 14.7.5. Ćwiczenia do podrozdziału 14.7 (623)
• 14.8. Podsumowanie rozdziału 14. (623)
  
• 14.9. Literatura do rozdziału 14. (625)

15. Wykonywanie zapytań (627)


• 15.1. Wprowadzenie do operatorów z fizycznego planu zapytania (629)
  
  • 15.1.1. Skanowanie tabel (629)
  • 15.1.2. Sortowanie w trakcie skanowania tabel (629)
  • 15.1.3. Model obliczeń dla operatorów fizycznych (630)
  • 15.1.4. Parametry do pomiaru kosztów (630)
  • 15.1.5. Koszty operacji wejścia-wyjścia dla operatorów skanowania (631)
  • 15.1.6. Iteratory do implementowania operatorów fizycznych (631)
• 15.2. Algorytmy jednoprzebiegowe (634)
  
  • 15.2.1. Algorytmy jednoprzebiegowe dla operacji krotkowych (635)
  • 15.2.2. Algorytmy jednoprzebiegowe dla jednoargumentowych operacji na całych relacjach (636)
  • 15.2.3. Algorytmy jednoprzebiegowe dla operacji dwuargumentowych (638)
  • 15.2.4. Ćwiczenia do podrozdziału 15.2 (640)
• 15.3. Złączenia zagnieżdżone (641)
  
  • 15.3.1. Krotkowe złączenia zagnieżdżone (641)
  • 15.3.2. Iterator dla krotkowych złączeń zagnieżdżonych (642)
  • 15.3.3. Algorytm złączenia zagnieżdżonego opartego na blokach (643)
  • 15.3.4. Analiza złączeń zagnieżdżonych (644)
  • 15.3.5. Przegląd opisanych wcześniej algorytmów (644)
  • 15.3.6. Ćwiczenia do podrozdziału 15.3 (645)
• 15.4. Algorytmy dwuprzebiegowe oparte na sortowaniu (645)
  
  • 15.4.1. Dwuetapowe wielościeżkowe sortowanie przez scalanie (646)
  • 15.4.2. Eliminowanie powtórzeń za pomocą sortowania (647)
  • 15.4.3. Grupowanie i agregacja z wykorzystaniem sortowania (647)
  • 15.4.4. Algorytm obliczania sumy oparty na sortowaniu (648)
  • 15.4.5. Obliczanie za pomocą sortowania części wspólnej i różnicy (649)
  • 15.4.6. Prosty algorytm złączenia oparty na sortowaniu (649)
  • 15.4.7. Analiza prostego złączenia przez sortowanie (650)
  • 15.4.8. Wydajniejsze złączenie przez sortowanie (651)
  • 15.4.9. Omówienie algorytmów opartych na sortowaniu (652)
  • 15.4.10. Ćwiczenia do podrozdziału 15.4 (652)
• 15.5. Dwuprzebiegowe algorytmy oparte na haszowaniu (653)
  
  • 15.5.1. Podział relacji przez haszowanie (653)
  • 15.5.2. Algorytm usuwania powtórzeń oparty na haszowaniu (654)
  • 15.5.3. Grupowanie i agregacja oparte na haszowaniu (654)
  • 15.5.4. Suma, część wspólna i różnica oparte na haszowaniu (655)
  • 15.5.5. Algorytm złączenia przez haszowanie (655)
  • 15.5.6. Zmniejszanie liczby dyskowych operacji wejścia-wyjścia (656)
  • 15.5.7. Przegląd algorytmów opartych na haszowaniu (658)
  • 15.5.8. Ćwiczenia do podrozdziału 15.5 (659)
• 15.6. Algorytmy oparte na indeksach (659)
  
  • 15.6.1. Indeksy klastrujące i nieklastrujące (659)
  • 15.6.2. Selekcja oparta na indeksie (660)
  • 15.6.3. Złączenie za pomocą indeksu (662)
  • 15.6.4. Złączenia z wykorzystaniem posortowanego indeksu (663)
  • 15.6.5. Ćwiczenia do podrozdziału 15.6 (664)
• 15.7. Zarządzanie buforem (665)
  
  • 15.7.1. Architektura menedżera buforów (665)
  • 15.7.2. Strategie zarządzania buforami (667)
  • 15.7.3. Związki między fizycznym operatorem selekcji a zarządzaniem buforami (668)
  • 15.7.4. Ćwiczenia do podrozdziału 15.7 (669)
• 15.8. Algorytmy o więcej niż dwóch przebiegach (670)
  
  • 15.8.1. Wieloprzebiegowe algorytmy oparte na sortowaniu (670)
  • 15.8.2. Wydajność wieloprzebiegowych algorytmów opartych na sortowaniu (671)
  • 15.8.3. Wieloprzebiegowe algorytmy oparte na haszowaniu (672)
  • 15.8.4. Wydajność wieloprzebiegowych algorytmów opartych na haszowaniu (672)
  • 15.8.5. Ćwiczenia do podrozdziału 15.8 (673)
• 15.9. Podsumowanie rozdziału 15. (673)
  
• 15.10. Literatura do rozdziału 15. (675)

16. Kompilator zapytań (677)


• 16.1. Parsowanie i przetwarzanie wstępne (678)
  
  • 16.1.1. Analiza składni i drzewa wyprowadzenia (678)
  • 16.1.2. Gramatyka prostego podzbioru SQL-a (679)
  • 16.1.3. Preprocesor (681)
  • 16.1.4. Przetwarzanie wstępne zapytań obejmujących widoki (682)
  • 16.1.5. Ćwiczenia do podrozdziału 16.1 (685)
• 16.2. Prawa algebraiczne pomocne przy ulepszaniu planów zapytań (685)
  
  • 16.2.1. Prawa przechodniości i łączności (685)
  • 16.2.2. Prawa obejmujące selekcję (687)
  • 16.2.3. Przenoszenie selekcji (689)
  • 16.2.4. Prawa obejmujące projekcję (691)
  • 16.2.5. Prawa dotyczące złączeń i iloczynów (692)
  • 16.2.6. Prawa obejmujące eliminowanie powtórzeń (693)
  • 16.2.7. Prawa dotyczące grupowania i agregacji (693)
  • 16.2.8. Ćwiczenia do podrozdziału 16.2 (695)
• 16.3. Od drzewa wyprowadzenia do logicznych planów zapytań (697)
  
  • 16.3.1. Przekształcanie na algebrę relacji (697)
  • 16.3.2. Eliminowanie podzapytań z warunków (699)
  • 16.3.3. Usprawnianie logicznego planu zapytania (703)
  • 16.3.4. Grupowanie operatorów łącznych i przechodnich (704)
  • 16.3.5. Ćwiczenia do podrozdziału 16.3 (705)
• 16.4. Szacowanie kosztów operacji (706)
  
  • 16.4.1. Szacowanie wielkości relacji pośrednich (707)
  • 16.4.2. Szacowanie rozmiaru po projekcji (707)
  • 16.4.3. Szacowanie rozmiaru relacji po selekcji (708)
  • 16.4.4. Szacowanie rozmiaru wyniku złączenia (710)
  • 16.4.5. Złączenia naturalne oparte na wielu atrybutach (711)
  • 16.4.6. Złączenia wielu relacji (712)
  • 16.4.7. Szacowanie rozmiaru wyników innych operacji (713)
  • 16.4.8. Ćwiczenia do podrozdziału 16.4 (714)
• 16.5. Wprowadzenie do wyboru planu na podstawie kosztów (715)
  
  • 16.5.1. Szacowanie parametrów związanych z rozmiarem (716)
  • 16.5.2. Obliczanie statystyk (718)
  • 16.5.3. Heurystyki zmniejszania kosztów logicznych planów zapytań (719)
  • 16.5.4. Sposoby wyliczania planów fizycznych (721)
  • 16.5.5. Ćwiczenia do podrozdziału 16.5 (723)
• 16.6. Określanie kolejności złączeń (724)
  
  • 16.6.1. Znaczenie lewego i prawego argumentu złączenia (724)
  • 16.6.2. Drzewa złączeń (725)
  • 16.6.3. Lewostronnie zagłębione drzewa złączeń (726)
  • 16.6.4. Programowanie dynamiczne przy określaniu kolejności złączeń i grupowaniu (728)
  • 16.6.5. Programowanie dynamiczne i bardziej szczegółowe funkcje obliczania kosztów (732)
  • 16.6.6. Algorytm zachłanny wyboru kolejności złączenia (733)
  • 16.6.7. Ćwiczenia do podrozdziału 16.6 (734)
• 16.7. Uzupełnianie fizycznego planu zapytania (734)
  
  • 16.7.1. Wybór metody selekcji (735)
  • 16.7.2. Wybieranie metody złączenia (737)
  • 16.7.3. Przekazywanie potokowe a materializacja (738)
  • 16.7.4. Przekazywanie potokowe w operacjach jednoargumentowych (738)
  • 16.7.5. Przekazywanie potokowe w operacjach dwuargumentowych (739)
  • 16.7.6. Notacja dla fizycznych planów zapytań (741)
  • 16.7.7. Porządkowanie operacji fizycznych (744)
  • 16.7.8. Ćwiczenia do podrozdziału 16.7 (745)
• 16.8. Podsumowanie rozdziału 16. (746)
  
• 16.9. Literatura do rozdziału 16. (747)

17. Radzenie sobie z awariami systemu (749)


• 17.1. Problemy i modele z obszaru odpornych operacji (749)
  
  • 17.1.1. Rodzaje awarii (750)
  • 17.1.2. Więcej o transakcjach (751)
  • 17.1.3. Prawidłowe wykonywanie transakcji (752)
  • 17.1.4. Operacje podstawowe w transakcjach (753)
  • 17.1.5. Ćwiczenia do podrozdziału 17.1 (755)
• 17.2. Rejestrowanie z możliwością wycofywania (756)
  
  • 17.2.1. Rekordy dziennika (756)
  • 17.2.2. Reguły rejestrowania z możliwością wycofywania (757)
  • 17.2.3. Przywracanie stanu z wykorzystaniem rejestrowania z możliwością wycofywania (759)
  • 17.2.4. Tworzenie punktów kontrolnych (761)
  • 17.2.5. Nieblokujące punkty kontrolne (762)
  • 17.2.6. Ćwiczenia do podrozdziału 17.2 (765)
• 17.3. Rejestrowanie z możliwością powtarzania (766)
  
  • 17.3.1. Reguła rejestrowania z możliwością powtarzania (766)
  • 17.3.2. Przywracanie stanu przy stosowaniu rejestrowania z możliwością powtarzania (767)
  • 17.3.3. Tworzenie punktów kontrolnych w dzienniku z możliwością powtarzania (768)
  • 17.3.4. Przywracanie stanu za pomocą dziennika z możliwością powtarzania z punktami kontrolnymi (769)
  • 17.3.5. Ćwiczenia do podrozdziału 17.3 (771)
• 17.4. Rejestrowanie z możliwością wycofywania i powtarzania (771)
  
  • 17.4.1. Reguły wycofywania i powtarzania (772)
  • 17.4.2. Przywracanie stanu przy rejestrowaniu z możliwością wycofywania i powtarzania (772)
  • 17.4.3. Tworzenie punktów kontrolnych w dziennikach z możliwością wycofywania i powtarzania (773)
  • 17.4.4. Ćwiczenia do podrozdziału 17.4 (775)
• 17.5. Zabezpieczanie się przed uszkodzeniem nośnika (776)
  
  • 17.5.1. Archiwum (776)
  • 17.5.2. Archiwizowanie nieblokujące (777)
  • 17.5.3. Przywracanie stanu za pomocą archiwum i dziennika (779)
  • 17.5.4. Ćwiczenia do podrozdziału 17.5 (780)
• 17.6. Podsumowanie rozdziału 17. (780)
  
• 17.7. Literatura do rozdziału 17. (782)

18. Sterowanie współbieżnością (783)


• 18.1. Harmonogramy szeregowe i szeregowalne (784)
  
  • 18.1.1. Harmonogramy (784)
  • 18.1.2. Harmonogramy szeregowe (784)
  • 18.1.3. Harmonogramy szeregowalne (786)
  • 18.1.4. Skutki semantyki działania transakcji (787)
  • 18.1.5. Notacja do opisu transakcji i harmonogramów (788)
  • 18.1.6. Ćwiczenia do podrozdziału 18.1 (789)
• 18.2. Szeregowalność konfliktowa (789)
  
  • 18.2.1. Konflikty (789)
  • 18.2.2. Grafy poprzedzania i sprawdzanie szeregowalności konfliktowej (791)
  • 18.2.3. Dlaczego test z wykorzystaniem grafu poprzedzania działa? (793)
  • 18.2.4. Ćwiczenia do podrozdziału 18.2 (794)
• 18.3. Wymuszanie szeregowalności za pomocą blokad (795)
  
  • 18.3.1. Blokady (796)
  • 18.3.2. Program szeregujący z funkcją blokowania (798)
  • 18.3.3. Blokowanie dwufazowe (799)
  • 18.3.4. Dlaczego blokowanie dwufazowe działa? (799)
  • 18.3.5. Ćwiczenia do podrozdziału 18.3 (800)
• 18.4. Systemy blokowania z kilkoma rodzajami blokad (802)
  
  • 18.4.1. Blokady dzielone i na wyłączność (802)
  • 18.4.2. Macierze zgodności (804)
  • 18.4.3. "Rozwijanie" blokad (805)
  • 18.4.4. Blokady z aktualizacją (806)
  • 18.4.5. Blokady inkrementacji (807)
  • 18.4.6. Ćwiczenia do podrozdziału 18.4 (809)
• 18.5. Architektura programu szeregującego z funkcją blokowania (811)
  
  • 18.5.1. Program szeregujący wstawiający operacje związane z blokadami (811)
  • 18.5.2. Tablica blokad (813)
  • 18.5.3. Ćwiczenia do podrozdziału 18.5 (816)
• 18.6. Hierarchie elementów bazy danych (816)
  
  • 18.6.1. Blokady o różnej szczegółowości (816)
  • 18.6.2. Blokady ostrzegawcze (817)
  • 18.6.3. Fantomy i poprawna obsługa wstawiania (820)
  • 18.6.4. Ćwiczenia do podrozdziału 18.6 (820)
• 18.7. Protokół drzewa (821)
  
  • 18.7.1. Uzasadnienie blokowania opartego na drzewach (821)
  • 18.7.2. Reguły dostępu do danych w strukturach drzewiastych (822)
  • 18.7.3. Dlaczego protokół drzewa działa? (823)
  • 18.7.4. Ćwiczenia do podrozdziału 18.7 (826)
• 18.8. Sterowanie współbieżnością za pomocą znaczników czasu (826)
  
  • 18.8.1. Znaczniki czasu (827)
  • 18.8.2. Fizycznie niewykonalne działania (828)
  • 18.8.3. Problemy z "brudnymi" danymi (829)
  • 18.8.4. Reguły szeregowania na podstawie znaczników czasu (830)
  • 18.8.5. Wielowersyjne znaczniki czasu (831)
  • 18.8.6. Znaczniki czasu a blokowanie (833)
  • 18.8.7. Ćwiczenia do podrozdziału 18.8 (833)
• 18.9. Sterowanie współbieżnością przez sprawdzanie poprawności (834)
  
  • 18.9.1. Architektura programu szeregującego opartego na sprawdzaniu poprawności (834)
  • 18.9.2. Reguły sprawdzania poprawności (835)
  • 18.9.3. Porównanie trzech mechanizmów sterowania współbieżnością (838)
  • 18.9.4. Ćwiczenia do podrozdziału 18.9 (839)
• 18.10. Podsumowanie rozdziału 18. (839)
  
• 18.11. Literatura do rozdziału 18. (841)

19. Więcej o zarządzaniu transakcjami (843)


• 19.1. Szeregowalność a możliwość przywracania stanu (843)
  
  • 19.1.1. Problem "brudnych" danych (844)
  • 19.1.2. Kaskadowe ponawianie (845)
  • 19.1.3. Harmonogramy odtwarzalne (845)
  • 19.1.4. Harmonogramy zapobiegające kaskadowemu ponawianiu (846)
  • 19.1.5. Zarządzanie ponawianiem przy użyciu blokad (847)
  • 19.1.6. Zatwierdzanie grupowe (849)
  • 19.1.7. Rejestrowanie logiczne (849)
  • 19.1.8. Przywracanie stanu na podstawie dzienników logicznych (852)
  • 19.1.9. Ćwiczenia do podrozdziału 19.1 (853)
• 19.2. Zakleszczenie (854)
  
  • 19.2.1. Wykrywanie zakleszczenia za pomocą limitów czasu (854)
  • 19.2.2. Graf oczekiwania (855)
  • 19.2.3. Zapobieganie zakleszczeniu przez porządkowanie elementów (857)
  • 19.2.4. Wykrywanie zakleszczeń za pomocą znaczników czasu (858)
  • 19.2.5. Porównanie metod zarządzania zakleszczeniem (860)
  • 19.2.6. Ćwiczenia do podrozdziału 19.2 (861)
• 19.3. Długie transakcje (862)
  
  • 19.3.1. Problemy z długimi transakcjami (862)
  • 19.3.2. Sagi (864)
  • 19.3.3. Transakcje kompensujące (865)
  • 19.3.4. Dlaczego transakcje kompensujące działają? (866)
  • 19.3.5. Ćwiczenia do podrozdziału 19.3 (867)
• 19.4. Podsumowanie rozdziału 19. (867)
  
• 19.5. Literatura do rozdziału 19. (868)

20. Równoległe i rozproszone bazy danych (869)


• 20.1. Równoległe algorytmy działające na relacjach (869)
  
  • 20.1.1. Modele równoległości (870)
  • 20.1.2. Równoległe wykonywanie operacji działających krotka po krotce (872)
  • 20.1.3. Algorytmy równoległe dla operacji działających na całych relacjach (873)
  • 20.1.4. Wydajność algorytmów równoległych (873)
  • 20.1.5. Ćwiczenia do podrozdziału 20.1 (875)
• 20.2. System map-reduce do obsługi równoległości (876)
  
  • 20.2.1. Model pamięci (876)
  • 20.2.2. Funkcja odwzorowująca (876)
  • 20.2.3. Funkcja redukująca (877)
  • 20.2.4. Ćwiczenia do podrozdziału 20.2 (878)
• 20.3. Rozproszone bazy danych (879)
  
  • 20.3.1. Podział danych (879)
  • 20.3.2. Transakcje rozproszone (880)
  • 20.3.3. Replikacja danych (880)
  • 20.3.4. Ćwiczenia do podrozdziału 20.3 (881)
• 20.4. Przetwarzanie zapytań rozproszonych (881)
  
  • 20.4.1. Problem złączenia w środowisku rozproszonym (881)
  • 20.4.2. Redukcje za pomocą złączeń częściowych (882)
  • 20.4.3. Złączenia wielu relacji (883)
  • 20.4.4. Hipergrafy acykliczne (884)
  • 20.4.5. Ciągi kompletnej redukcji dla hipergrafów acyklicznych (886)
  • 20.4.6. Dlaczego algorytm pełnej redukcji działa? (887)
  • 20.4.7. Ćwiczenia do podrozdziału 20.4 (887)
• 20.5. Zatwierdzanie w środowisku rozproszonym (888)
  
  • 20.5.1. Zapewnianie atomowości w środowisku rozproszonym (888)
  • 20.5.2. Dwufazowe zatwierdzanie (889)
  • 20.5.3. Przywracanie stanu przy transakcjach rozproszonych (891)
  • 20.5.4. Ćwiczenia do podrozdziału 20.5 (893)
• 20.6. Blokowanie w środowisku rozproszonym (893)
  
  • 20.6.1. Scentralizowane systemy blokad (894)
  • 20.6.2. Model kosztów dla algorytmów blokowania rozproszonego (894)
  • 20.6.3. Blokowanie zreplikowanych elementów (895)
  • 20.6.4. Blokowanie kopii podstawowej (896)
  • 20.6.5. Blokady globalne oparte na blokadach lokalnych (896)
  • 20.6.6. Ćwiczenia do podrozdziału 20.6 (898)
• 20.7. Wyszukiwanie rozproszone w systemach P2P (898)
  
  • 20.7.1. Sieci P2P (899)
  • 20.7.2. Problem z haszowaniem rozproszonym (899)
  • 20.7.3. Scentralizowane rozwiązania z obszaru haszowania rozproszonego (900)
  • 20.7.4. Okrąg z cięciwami (900)
  • 20.7.5. Odnośniki w okręgach z cięciwami (901)
  • 20.7.6. Wyszukiwanie z wykorzystaniem tablicy podręcznej (902)
  • 20.7.7. Dodawanie nowych węzłów (904)
  • 20.7.8. Opuszczanie sieci przez węzły (907)
  • 20.7.9. Awaria węzła (907)
  • 20.7.10. Ćwiczenia do podrozdziału 20.7 (907)
• 20.8. Podsumowanie rozdziału 20. (908)
  
• 20.9. Literatura do rozdziału 20. (909)

V: Inne zagadnienia z obszaru zarządzania dużymi zbiorami danych (911)


21. Integrowanie informacji (913)


• 21.1. Wprowadzenie do integrowania informacji (913)
  
  • 21.1.1. Po co stosować integrowanie informacji? (914)
  • 21.1.2. Problem heterogeniczności (915)
• 21.2. Tryby integrowania informacji (917)
  
  • 21.2.1. Federacyjne systemy baz danych (917)
  • 21.2.2. Hurtownie danych (919)
  • 21.2.3. Mediator (920)
  • 21.2.4. Ćwiczenia do podrozdziału 21.2 (922)
• 21.3. Nakładki w systemach opartych na mediatorze (923)
  
  • 21.3.1. Szablony wzorców zapytań (924)
  • 21.3.2. Generatory nakładek (925)
  • 21.3.3. Filtry (926)
  • 21.3.4. Inne operacje nakładki (927)
  • 21.3.5. Ćwiczenia do podrozdziału 21.3 (928)
• 21.4. Optymalizacja oparta na możliwościach (929)
  
  • 21.4.1. Problem ograniczonych możliwości źródeł (929)
  • 21.4.2. Notacja do opisywania możliwości źródeł (930)
  • 21.4.3. Wybór planu zapytania na podstawie możliwości (931)
  • 21.4.4. Dołączanie optymalizacji na podstawie kosztów (932)
  • 21.4.5. Ćwiczenia do podrozdziału 21.4 (933)
• 21.5. Optymalizowanie zapytań mediatora (933)
  
  • 21.5.1. Uproszczona notacja dla ozdobników (934)
  • 21.5.2. Uzyskiwanie wyników podzadań (934)
  • 21.5.3. Algorytm łańcuchowy (935)
  • 21.5.4. Sumowanie widoków w mediatorze (938)
  • 21.5.5. Ćwiczenia do podrozdziału 21.5 (939)
• 21.6. Mediator lokalny w formie widoku (940)
  
  • 21.6.1. Uzasadnienie stosowania mediatorów LAV (940)
  • 21.6.2. Terminologia dotycząca mediatorów LAV (941)
  • 21.6.3. Rozszerzanie rozwiązań (942)
  • 21.6.4. Zawieranie się zapytań koniunkcyjnych (944)
  • 21.6.5. Dlaczego test na istnienie odwzorowania zawierającego działa? (945)
  • 21.6.6. Wyszukiwanie rozwiązań dla zapytań mediatora (946)
  • 21.6.7. Dlaczego twierdzenie LMSS jest prawdziwe? (947)
  • 21.6.8. Ćwiczenia do podrozdziału 21.6 (948)
• 21.7. Określanie encji (948)
  
  • 21.7.1. Określanie, czy rekordy reprezentują tę samą encję (948)
  • 21.7.2. Scalanie podobnych rekordów (950)
  • 21.7.3. Przydatne cechy funkcji określania podobieństwa i scalania (951)
  • 21.7.4. Algorytm R-Swoosh dla rekordów ICAR (952)
  • 21.7.5. Dlaczego algorytm R-Swoosh działa? (954)
  • 21.7.6. Inne sposoby określania encji (954)
  • 21.7.7. Ćwiczenia do podrozdziału 21.7 (955)
• 21.8. Podsumowanie rozdziału 21. (957)
  
• 21.9. Literatura do rozdziału 21. (958)

22. Drążenie danych (961)


• 22.1. Wyszukiwanie często występujących zbiorów elementów (961)
  
  • 22.1.1. Model koszyka zakupów (962)
  • 22.1.2. Podstawowe definicje (963)
  • 22.1.3. Reguły asocjacji (964)
  • 22.1.4. Model obliczeń dla często występujących zbiorów elementów (965)
  • 22.1.5. Ćwiczenia do podrozdziału 22.1 (966)
• 22.2. Algorytmy do wyszukiwania często występujących zbiorów elementów (967)
  
  • 22.2.1. Rozkład często występujących zbiorów elementów (967)
  • 22.2.2. Naiwny algorytm wyszukiwania częstych zbiorów elementów (968)
  • 22.2.3. Algorytm a-priori (969)
  • 22.2.4. Implementacja algorytmu a-priori (970)
  • 22.2.5. Lepsze wykorzystanie pamięci głównej (971)
  • 22.2.6. Kiedy warto stosować algorytm PCY? (972)
  • 22.2.7. Algorytm wieloetapowy (973)
  • 22.2.8. Ćwiczenia do podrozdziału 22.2 (974)
• 22.3. Wyszukiwanie podobnych elementów (975)
  
  • 22.3.1. Miara podobieństwa Jaccarda (975)
  • 22.3.2. Zastosowania podobieństwa Jaccarda (976)
  • 22.3.3. Minhashing (977)
  • 22.3.4. Minhashing i odległość Jaccarda (978)
  • 22.3.5. Dlaczego minhashing działa? (978)
  • 22.3.6. Implementowanie minhashingu (979)
  • 22.3.7. Ćwiczenia do podrozdziału 22.3 (980)
• 22.4. LSH (981)
  
  • 22.4.1. Określanie encji i przykład zastosowania LSH (981)
  • 22.4.2. Zastosowanie LSH do sygnatur (982)
  • 22.4.3. Łączenie minhashingu i LSH (984)
  • 22.4.4. Ćwiczenia do podrozdziału 22.4 (985)
• 22.5. Grupowanie dużych zbiorów danych (986)
  
  • 22.5.1. Zastosowania grupowania (986)
  • 22.5.2. Miary odległości (988)
  • 22.5.3. Grupowanie aglomeracyjne (990)
  • 22.5.4. Algorytmy oparte na k-średnich (992)
  • 22.5.5. Algorytm k-średnich dla dużych zbiorów danych (993)
  • 22.5.6. Przetwarzanie porcji punktów z pamięci (995)
  • 22.5.7. Ćwiczenia do podrozdziału 22.5 (997)
• 22.6. Podsumowanie rozdziału 22. (998)
  
• 22.7. Literatura do rozdziału 22. (999)

23. Systemy baz danych i internet (1001)


• 23.1. Architektura wyszukiwarek (1001)
  
  • 23.1.1. Komponenty wyszukiwarek (1001)
  • 23.1.2. Roboty internetowe (1002)
  • 23.1.3. Przetwarzanie zapytań w wyszukiwarkach (1005)
  • 23.1.4. Tworzenie rankingu stron (1005)
• 23.2. Określanie ważnych stron za pomocą wskaźnika PageRank (1006)
  
  • 23.2.1. Intuicyjne podstawy algorytmu PageRank (1006)
  • 23.2.2. Rekurencyjne ujęcie wskaźnika PageRank - pierwsze podejście (1007)
  • 23.2.3. Pułapki i ślepe uliczki (1009)
  • 23.2.4. Wskaźnik PageRank z uwzględnieniem pułapek i ślepych uliczek (1011)
  • 23.2.5. Ćwiczenia do podrozdziału 23.2 (1013)
• 23.3. Wskaźnik PageRank specyficzny dla tematu (1014)
  
  • 23.3.1. Zbiór teleportacji (1014)
  • 23.3.2. Obliczanie wskaźnika PageRank specyficznego dla tematu (1015)
  • 23.3.3. Spam odnośnikami (1016)
  • 23.3.4. Wskaźnik PageRank specyficzny dla tematu i spam odnośnikami (1017)
  • 23.3.5. Ćwiczenia do podrozdziału 23.3 (1018)
• 23.4. Strumienie danych (1019)
  
  • 23.4.1. Systemy zarządzania strumieniami danych (1019)
  • 23.4.2. Zastosowania strumieni (1020)
  • 23.4.3. Model danych oparty na strumieniach (1021)
  • 23.4.4. Przekształcanie strumieni na relacje (1022)
  • 23.4.5. Przekształcanie relacji na strumienie (1023)
  • 23.4.6. Ćwiczenia do podrozdziału 23.4 (1025)
• 23.5. Drążenie danych w strumieniach (1025)
  
  • 23.5.1. Uzasadnienie (1026)
  • 23.5.2. Określanie liczby bitów (1027)
  • 23.5.3. Określanie liczby różnych elementów (1030)
  • 23.5.4. Ćwiczenia do podrozdziału 23.5 (1031)
• 23.6. Podsumowanie rozdziału 23. (1032)
  
• 23.7. Literatura do rozdziału 23. (1034)

Skorowidz (1037)

pokaż cały spis treści

ukryj recenzje