Podstawowy kurs systemów baz danych. Wydanie III 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

Przedmowa (15)


• Co nowego w trzecim wydaniu? (16)
  
• Korzystanie z tej książki (16)
  
• Wymagania wstępne (17)
  
• Ćwiczenia (17)
  
• Ćwiczenia online z wykorzystaniem technologii Gradiance (17)
  
• Materiały w internecie (18)
  
• Odwzorowanie drugiego wydania na trzecie (18)
  
• Podziękowania (18)

1. Środowisko systemów baz danych (21)


• 1.1. Ewolucja systemów baz danych (21)
  
  • 1.1.1. Pierwsze systemy zarządzania bazami danych (22)
  • 1.1.2. Relacyjne bazy danych (23)
  • 1.1.3. Coraz mniejsze systemy (23)
  • 1.1.4. Coraz większe systemy (23)
  • 1.1.5. Integracja informacji (24)
• 1.2. System zarządzania bazą danych w zarysie (24)
  
  • 1.2.1. Polecenia języka definiowania danych (25)
  • 1.2.2. Ogólny opis przetwarzania zapytań (26)
  • 1.2.3. Zarządzanie pamięcią masową i buforami (27)
  • 1.2.4. Przetwarzanie transakcji (27)
  • 1.2.5. Procesor zapytań (28)
• 1.3. Plan opisu systemów baz danych (29)
  
• 1.4. Literatura do rozdziału 1. (30)

I: Modelowanie relacyjnych baz danych (33)


2. Relacyjny model danych (35)


• 2.1. Przegląd informacji o modelach danych (35)
  
  • 2.1.1. Co to jest model danych? (35)
  • 2.1.2. Ważniejsze modele danych (36)
  • 2.1.3. Model relacyjny w zarysie (36)
  • 2.1.4. Model semistrukturalny w zarysie (37)
  • 2.1.5. Inne modele danych (38)
  • 2.1.6. Porównanie sposobów modelowania danych (38)
• 2.2. Podstawowe informacje na temat modeli relacyjnych (39)
  
  • 2.2.1. Atrybuty (39)
  • 2.2.2. Schematy (40)
  • 2.2.3. Krotki (40)
  • 2.2.4. Dziedziny (40)
  • 2.2.5. Równoważne odpowiedniki relacji (41)
  • 2.2.6. Egzemplarze relacji (41)
  • 2.2.7. Klucze relacji (42)
  • 2.2.8. Przykład schematu bazy danych (44)
  • 2.2.9. Ćwiczenia do podrozdziału 2.2 (45)
• 2.3. Definiowanie schematu relacyjnego w SQL (46)
  
  • 2.3.1. Relacje w języku SQL (46)
  • 2.3.2. Typy danych (47)
  • 2.3.3. Proste deklaracje tabel (48)
  • 2.3.4. Modyfikowanie schematów relacji (49)
  • 2.3.5. Wartości domyślne (50)
  • 2.3.6. Deklarowanie kluczy (50)
  • 2.3.7. Ćwiczenia do podrozdziału 2.3 (52)
• 2.4. Algebraiczny język zapytań (53)
  
  • 2.4.1. Do czego jest potrzebny specjalny język zapytań? (54)
  • 2.4.2. Czym jest algebra? (54)
  • 2.4.3. Ogólne informacje o algebrze relacji (54)
  • 2.4.4. Działania na zbiorach wykonywane w odniesieniu do relacji (55)
  • 2.4.5. Rzutowanie (56)
  • 2.4.6. Selekcja (57)
  • 2.4.7. Iloczyn kartezjański (58)
  • 2.4.8. Złączenia naturalne (59)
  • 2.4.9. Złączenia teta (61)
  • 2.4.10. Łączenie operacji w celu tworzenia zapytań (62)
  • 2.4.11. Nadawanie nazw i przemianowywanie (64)
  • 2.4.12. Związki pomiędzy działaniami (64)
  • 2.4.13. Liniowa notacja dla wyrażeń algebraicznych (65)
  • 2.4.14. Ćwiczenia do podrozdziału 2.4 (66)
• 2.5. Ograniczenia dotyczące relacji (72)
  
  • 2.5.1. Algebra relacji jako język definiowania ograniczeń (73)
  • 2.5.2. Ograniczenia integralności odwołań (73)
  • 2.5.3. Ograniczenia kluczowe (74)
  • 2.5.4. Dodatkowe przykłady ograniczeń (75)
  • 2.5.5. Ćwiczenia do podrozdziału 2.5 (76)
• 2.6. Podsumowanie rozdziału 2. (77)
  
• 2.7. Literatura do rozdziału 2. (78)

3. Teoria projektowania relacyjnych baz danych (79)


• 3.1. Zależności funkcyjne (79)
  
  • 3.1.1. Definicja zależności funkcyjnej (80)
  • 3.1.2. Klucze relacji (81)
  • 3.1.3. Nadklucze (83)
  • 3.1.4. Ćwiczenia do podrozdziału 3.1 (83)
• 3.2. Reguły dotyczące zależności funkcyjnych (84)
  
  • 3.2.1. Wnioskowanie na temat zależności funkcyjnych (84)
  • 3.2.2. Reguła podziału i łączenia (85)
  • 3.2.3. Trywialne zależności funkcyjne (86)
  • 3.2.4. Obliczanie domknięcia zbioru atrybutów (86)
  • 3.2.5. Dlaczego algorytm domknięć działa? (89)
  • 3.2.6. Reguła przechodniości (90)
  • 3.2.7. Domykanie zbiorów zależności funkcyjnych (91)
  • 3.2.8. Projekcja zależności funkcyjnych (92)
  • 3.2.9. Ćwiczenia do podrozdziału 3.2 (94)
• 3.3. Projektowanie schematów relacyjnych baz danych (96)
  
  • 3.3.1. Anomalie (97)
  • 3.3.2. Dekompozycja relacji (97)
  • 3.3.3. Postać normalna Boyce'a-Codda (98)
  • 3.3.4. Dekompozycja do postaci BCNF (100)
  • 3.3.5. Ćwiczenia do podrozdziału 3.3 (103)
• 3.4. Dekompozycja - dobre, złe i brzydkie cechy (103)
  
  • 3.4.1. Odtwarzanie informacji po dekompozycji (104)
  • 3.4.2. Test pościgu dla złączeń bezstratnych (106)
  • 3.4.3. Dlaczego algorytm pościgu działa? (109)
  • 3.4.4. Zachowanie zależności (110)
  • 3.4.5. Ćwiczenia do podrozdziału 3.4 (111)
• 3.5. Trzecia postać normalna (112)
  
  • 3.5.1. Definicja trzeciej postaci normalnej (112)
  • 3.5.2. Algorytm syntezy dla schematów 3NF (113)
  • 3.5.3. Dlaczego algorytm syntezy 3NF działa? (114)
  • 3.5.4. Ćwiczenia do podrozdziału 3.5 (114)
• 3.6. Zależności wielowartościowe (115)
  
  • 3.6.1. Niezależność atrybutów a redundancja (115)
  • 3.6.2. Definicja zależności wielowartościowych (116)
  • 3.6.3. Wnioskowanie na temat zależności wielowartościowych (117)
  • 3.6.4. Czwarta postać normalna (120)
  • 3.6.5. Dekompozycja do czwartej postaci normalnej (120)
  • 3.6.6. Związki pomiędzy postaciami normalnymi (122)
  • 3.6.7. Ćwiczenia do podrozdziału 3.6 (122)
• 3.7. Algorytm wykrywania zależności wielowartościowych (124)
  
  • 3.7.1. Algorytm domknięć a algorytm pościgu (124)
  • 3.7.2. Rozszerzenie algorytmu pościgu o zależności wielowartościowe (125)
  • 3.7.3. Dlaczego algorytm pościgu dla zależności wielowartościowych działa? (128)
  • 3.7.4. Rzutowanie zależności wielowartościowych (128)
  • 3.7.5. Ćwiczenia do podrozdziału 3.7 (129)
• 3.8. Podsumowanie rozdziału 3. (130)
  
• 3.9. Literatura do rozdziału 3. (131)

4. Wysokopoziomowe modele baz danych (133)


• 4.1. Model związków encji (134)
  
  • 4.1.1. Zbiory encji (134)
  • 4.1.2. Atrybuty (134)
  • 4.1.3. Związki (135)
  • 4.1.4. Diagramy E/R (135)
  • 4.1.5. Egzemplarze diagramu E/R (136)
  • 4.1.6. Liczebność binarnych związków E/R (137)
  • 4.1.7. Związki wieloargumentowe (138)
  • 4.1.8. Role w związkach (139)
  • 4.1.9. Atrybuty w związkach (140)
  • 4.1.10. Konwersja związków wieloargumentowych na binarne (142)
  • 4.1.11. Podklasy w modelu E/R (143)
  • 4.1.12. Ćwiczenia do podrozdziału 4.1 (145)
• 4.2. Zasady projektowania (146)
  
  • 4.2.1. Wierność (147)
  • 4.2.2. Unikanie redundancji (147)
  • 4.2.3. Prostota (148)
  • 4.2.4. Dobór właściwych związków (148)
  • 4.2.5. Dobór właściwych typów elementów (150)
  • 4.2.6. Ćwiczenia do podrozdziału 4.2 (151)
• 4.3. Ograniczenia w modelu związków encji (154)
  
  • 4.3.1. Klucze w modelu związków encji (154)
  • 4.3.2. Reprezentowanie kluczy w modelu E/R (154)
  • 4.3.3. Integralność odwołań (155)
  • 4.3.4. Stopnie powiązania (156)
  • 4.3.5. Ćwiczenia do podrozdziału 4.3 (156)
• 4.4. Słabe zbiory encji (157)
  
  • 4.4.1. Sens istnienia słabych zbiorów encji (157)
  • 4.4.2. Wymagania dla słabych zbiorów encji (159)
  • 4.4.3. Notacja dla słabych zbiorów encji (160)
  • 4.4.4. Ćwiczenia do podrozdziału 4.4 (160)
• 4.5. Od diagramów E/R do projektu relacyjnej bazy danych (161)
  
  • 4.5.1. Od zbiorów encji do relacji (161)
  • 4.5.2. Od związków E/R do relacji (162)
  • 4.5.3. Łączenie relacji (164)
  • 4.5.4. Postępowanie ze słabymi zbiorami encji (165)
  • 4.5.5. Ćwiczenia do podrozdziału 4.5 (167)
• 4.6. Konwersja struktur podklas na relacje (169)
  
  • 4.6.1. Konwersja na podstawie diagramu E/R (169)
  • 4.6.2. Podejście obiektowe (170)
  • 4.6.3. Wykorzystanie 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 UML (175)
  • 4.7.2. Klucze klas UML (175)
  • 4.7.3. Asocjacje (175)
  • 4.7.4. Samoasocjacje (177)
  • 4.7.5. Klasy asocjacji (178)
  • 4.7.6. Podklasy w języku UML (178)
  • 4.7.7. Agregacje i kompozycje (180)
  • 4.7.8. Ćwiczenia do podrozdziału 4.7 (181)
• 4.8. Od diagramów UML do relacji (181)
  
  • 4.8.1. Podstawowe zasady przekształcania diagramów UML na relacje (181)
  • 4.8.2. Konwersja podklas UML na relacje (182)
  • 4.8.3. Konwersja agregacji i kompozycji na relacje (183)
  • 4.8.4. Analogia do słabych zbiorów encji w notacji UML (183)
  • 4.8.5. Ćwiczenia do podrozdziału 4.8 (184)
• 4.9. Język ODL (185)
  
  • 4.9.1. Deklaracje klas (185)
  • 4.9.2. Atrybuty w języku ODL (185)
  • 4.9.3. Związki w języku ODL (187)
  • 4.9.4. Związki odwrotne (187)
  • 4.9.5. Liczebność związków (188)
  • 4.9.6. Typy w języku ODL (189)
  • 4.9.7. Podklasy w języku ODL (191)
  • 4.9.8. Deklaracje kluczy w języku ODL (191)
  • 4.9.9. Ćwiczenia do podrozdziału 4.9 (193)
• 4.10. Od projektów w języku ODL do projektów relacyjnych baz danych (193)
  
  • 4.10.1. Konwersja klas ODL na relacje (194)
  • 4.10.2. Złożone atrybuty w klasach (195)
  • 4.10.3. Reprezentowanie atrybutów o wartościach typu zbiór (195)
  • 4.10.4. Reprezentowanie innych konstruktorów typów (197)
  • 4.10.5. Reprezentowanie związków ODL (198)
  • 4.10.6. Ćwiczenia do podrozdziału 4.10 (198)
• 4.11. Podsumowanie rozdziału 4. (199)
  
• 4.12. Literatura do rozdziału 4. (201)

II: Programowanie relacyjnych baz danych (203)


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


• 5.1. Działania relacyjne na wielozbiorach (205)
  
  • 5.1.1. Dlaczego wielozbiory? (206)
  • 5.1.2. Suma, część wspólna i różnica wielozbiorów (207)
  • 5.1.3. Rzutowanie wielozbiorów (208)
  • 5.1.4. Selekcja na wielozbiorach (209)
  • 5.1.5. Iloczyn wielozbiorów (209)
  • 5.1.6. Złączenia wielozbiorów (210)
  • 5.1.7. Ćwiczenia do podrozdziału 5.1 (211)
• 5.2. Rozszerzony zbiór operatorów algebry relacji (212)
  
  • 5.2.1. Eliminowanie duplikatów (213)
  • 5.2.2. Operatory agregacji (213)
  • 5.2.3. Grupowanie (214)
  • 5.2.4. Operator grupowania (215)
  • 5.2.5. Rozszerzenie operatora rzutowania (216)
  • 5.2.6. Operator sortowania (218)
  • 5.2.7. Złączenia zewnętrzne (218)
  • 5.2.8. Ćwiczenia do podrozdziału 5.2 (220)
• 5.3. Logika relacji (221)
  
  • 5.3.1. Predykaty i atomy (221)
  • 5.3.2. Atomy arytmetyczne (222)
  • 5.3.3. Reguły i zapytania w Datalogu (222)
  • 5.3.4. Znaczenie reguł Datalogu (223)
  • 5.3.5. Predykaty ekstensjonalne i intensjonalne (225)
  • 5.3.6. Reguły Datalogu stosowane do wielozbiorów (226)
  • 5.3.7. Ćwiczenia do podrozdziału 5.3 (227)
• 5.4. Algebra relacji a Datalog (228)
  
  • 5.4.1. Działania logiczne (228)
  • 5.4.2. Rzutowanie (229)
  • 5.4.3. Selekcja (230)
  • 5.4.4. Iloczyn (232)
  • 5.4.5. Złączenia (232)
  • 5.4.6. Symulacja wielu operacji w Datalogu (233)
  • 5.4.7. Porównanie Datalogu z algebrą relacji (235)
  • 5.4.8. Ćwiczenia do podrozdziału 5.4 (235)
• 5.5. Podsumowanie rozdziału 5. (236)
  
• 5.6. Bibliografia do rozdziału 5. (237)

6. Język baz danych SQL (239)


• 6.1. Proste zapytania w SQL (240)
  
  • 6.1.1. Rzutowanie w języku SQL (242)
  • 6.1.2. Selekcja w języku SQL (244)
  • 6.1.3. Porównywanie ciągów znaków (245)
  • 6.1.4. Dopasowywanie wzorców w SQL (246)
  • 6.1.5. Daty i godziny (246)
  • 6.1.6. Wartości null i porównania z wykorzystaniem wartości NULL (248)
  • 6.1.7. Wartość logiczna UNKNOWN (249)
  • 6.1.8. Porządkowanie wyniku (250)
  • 6.1.9. Ćwiczenia do podrozdziału 6.1 (251)
• 6.2. Zapytania do więcej niż jednej relacji (253)
  
  • 6.2.1. Iloczyny i złączenia w SQL (253)
  • 6.2.2. Eliminowanie niejednoznaczności atrybutów (255)
  • 6.2.3. Zmienne krotek (255)
  • 6.2.4. Interpretowanie zapytań do wielu relacji (257)
  • 6.2.5. Suma, część wspólna i różnica zapytań (259)
  • 6.2.6. Ćwiczenia do podrozdziału 6.2 (261)
• 6.3. Podzapytania (262)
  
  • 6.3.1. Podzapytania, które generują wynik w postaci wartości skalarnej (263)
  • 6.3.2. Warunki dotyczące relacji (264)
  • 6.3.3. Warunki dotyczące krotek (265)
  • 6.3.4. Podzapytania skorelowane (266)
  • 6.3.5. Podzapytania w klauzulach FROM (267)
  • 6.3.6. Wyrażenia złączeń w SQL (268)
  • 6.3.7. Złączenia naturalne (269)
  • 6.3.8. Złączenia zewnętrzne (270)
  • 6.3.9. Ćwiczenia do podrozdziału 6.3 (272)
• 6.4. Działania na całych relacjach (274)
  
  • 6.4.1. Eliminowanie duplikatów (274)
  • 6.4.2. Duplikaty w sumach, częściach wspólnych i różnicach relacji (275)
  • 6.4.3. Grupowanie i funkcje agregacji w języku SQL (276)
  • 6.4.4. Operatory agregacji (276)
  • 6.4.5. Grupowanie (277)
  • 6.4.6. Grupowanie, agregacje a wartości NULL (279)
  • 6.4.7. Klauzule HAVING (280)
  • 6.4.8. Ćwiczenia do podrozdziału 6.4 (281)
• 6.5. Modyfikacje baz danych (282)
  
  • 6.5.1. Wstawianie krotek (282)
  • 6.5.2. Usuwanie (284)
  • 6.5.3. Aktualizacje (285)
  • 6.5.4. Ćwiczenia do podrozdziału 6.5 (286)
• 6.6. Transakcje w języku SQL (287)
  
  • 6.6.1. Szeregowalność (287)
  • 6.6.2. Niepodzielność (289)
  • 6.6.3. Transakcje (290)
  • 6.6.4. Transakcje tylko do odczytu (291)
  • 6.6.5. Brudne odczyty (292)
  • 6.6.6. Inne poziomy izolacji (295)
  • 6.6.7. Ćwiczenia do podrozdziału 6.6 (296)
• 6.7. Podsumowanie rozdziału 6. (297)
  
• 6.8. Bibliografia do rozdziału 6. (298)

7. Więzy i wyzwalacze (301)


• 7.1. Klucze główne i obce (301)
  
  • 7.1.1. Deklarowanie więzów kluczy obcych (302)
  • 7.1.2. Utrzymywanie integralności odwołań (303)
  • 7.1.3. Odroczone sprawdzanie więzów (305)
  • 7.1.4. Ćwiczenia do podrozdziału 7.1 (307)
• 7.2. Więzy na poziomie atrybutów i krotek (308)
  
  • 7.2.1. Więzy NOT NULL (309)
  • 7.2.2. Więzy CHECK na poziomie atrybutów (309)
  • 7.2.3. Więzy CHECK na poziomie krotek (311)
  • 7.2.4. Porównanie więzów CHECK na poziomie krotek z więzami CHECK na poziomie atrybutów (312)
  • 7.2.5. Ćwiczenia do podrozdziału 7.2 (313)
• 7.3. Modyfikacje więzów (314)
  
  • 7.3.1. Nadawanie nazw więzom (314)
  • 7.3.2. Modyfikowanie więzów na poziomie tabel (315)
  • 7.3.3. Ćwiczenia do podrozdziału 7.3 (316)
• 7.4. Asercje (317)
  
  • 7.4.1. Tworzenie asercji (317)
  • 7.4.2. Wykorzystywanie asercji (317)
  • 7.4.3. Ćwiczenia do podrozdziału 7.4 (319)
• 7.5. Wyzwalacze (320)
  
  • 7.5.1. Wyzwalacze w języku SQL (320)
  • 7.5.2. Opcje projektowania wyzwalacza (322)
  • 7.5.3. Ćwiczenia do podrozdziału 7.5 (324)
• 7.6. Podsumowanie rozdziału 7. (326)
  
• 7.7. Bibliografia do rozdziału 7. (327)

8. Perspektywy i indeksy (329)


• 8.1. Perspektywy wirtualne (329)
  
  • 8.1.1. Deklarowanie perspektyw (329)
  • 8.1.2. Zapytania do perspektyw (331)
  • 8.1.3. Przemianowania atrybutów (331)
  • 8.1.4. Ćwiczenia do podrozdziału 8.1 (332)
• 8.2. Modyfikowanie perspektyw (332)
  
  • 8.2.1. Usuwanie perspektyw (333)
  • 8.2.2. Perspektywy modyfikowalne (333)
  • 8.2.3. Wyzwalacze instead-of dla perspektyw (335)
  • 8.2.4. Ćwiczenia do podrozdziału 8.2 (336)
• 8.3. Indeksy w języku SQL (337)
  
  • 8.3.1. Motywacja istnienia indeksów (338)
  • 8.3.2. Deklarowanie indeksów (338)
  • 8.3.3. Ćwiczenia do podrozdziału 8.3 (339)
• 8.4. Dobór indeksów (340)
  
  • 8.4.1. Prosty model kosztów (340)
  • 8.4.2. Przykłady przydatnych indeksów (340)
  • 8.4.3. Wyznaczanie najlepszych możliwych indeksów (342)
  • 8.4.4. Automatyczny wybór indeksów do utworzenia (345)
  • 8.4.5. Ćwiczenia do podrozdziału 8.4 (346)
• 8.5. Perspektywy zmaterializowane (346)
  
  • 8.5.1. Utrzymywanie perspektyw zmaterializowanych (347)
  • 8.5.2. Okresowa obsługa perspektyw zmaterializowanych (349)
  • 8.5.3. Przepisywanie zapytań w celu korzystania z perspektyw zmaterializowanych (349)
  • 8.5.4. Automatyczne tworzenie perspektyw zmaterializowanych (351)
  • 8.5.5. Ćwiczenia do podrozdziału 8.5 (352)
• 8.6. Podsumowanie rozdziału 8. (353)
  
• 8.7. Bibliografia do rozdziału 8. (354)

9. SQL w środowisku serwerowym (355)


• 9.1. Architektura trójwarstwowa (356)
  
  • 9.1.1. Warstwa serwera WWW (357)
  • 9.1.2. Warstwa aplikacji (357)
  • 9.1.3. Warstwa bazy danych (358)
• 9.2. Środowisko języka SQL (358)
  
  • 9.2.1. Środowiska (358)
  • 9.2.2. Schematy (360)
  • 9.2.3. Katalogi (361)
  • 9.2.4. Klienty i serwery w środowisku SQL (361)
  • 9.2.5. Połączenia (362)
  • 9.2.6. Sesje (362)
  • 9.2.7. Moduły (363)
• 9.3. Interfejs SQL - język-gospodarz (364)
  
  • 9.3.1. Problem niezgodności impedancji (365)
  • 9.3.2. Połączenie języka SQL z językiem-gospodarzem (365)
  • 9.3.3. Sekcja deklaracji (366)
  • 9.3.4. Używanie zmiennych współdzielonych (367)
  • 9.3.5. Jednowierszowe instrukcje SELECT (368)
  • 9.3.6. Kursory (368)
  • 9.3.7. Modyfikacje z wykorzystaniem kursorów (370)
  • 9.3.8. Zabezpieczenie przed równoległym wprowadzaniem aktualizacji (372)
  • 9.3.9. Dynamiczny SQL (372)
  • 9.3.10. Ćwiczenia do podrozdziału 9.3 (374)
• 9.4. Procedury składowane (375)
  
  • 9.4.1. Tworzenie funkcji i procedur PSM (375)
  • 9.4.2. Proste rodzaje instrukcji w PSM (376)
  • 9.4.3. Instrukcje warunkowe (377)
  • 9.4.4. Zapytania w modułach PSM (379)
  • 9.4.5. Pętle w modułach PSM (380)
  • 9.4.6. Pętle for (381)
  • 9.4.7. Wyjątki w modułach PSM (383)
  • 9.4.8. Posługiwanie się funkcjami i procedurami PSM (385)
  • 9.4.9. Ćwiczenia do podrozdziału 9.4 (385)
• 9.5. Wykorzystanie interfejsu poziomu wywołania (387)
  
  • 9.5.1. Wprowadzenie do interfejsu SQL/CLI (387)
  • 9.5.2. Przetwarzanie instrukcji (389)
  • 9.5.3. Pobieranie danych z wyniku zapytania (390)
  • 9.5.4. Przekazywanie parametrów do zapytań (392)
  • 9.5.5. Ćwiczenia do podrozdziału 9.5 (393)
• 9.6. JDBC (393)
  
  • 9.6.1. Wprowadzenie do JDBC (393)
  • 9.6.2. Tworzenie instrukcji w JDBC (394)
  • 9.6.3. Operacje na kursorach w JDBC (396)
  • 9.6.4. Przekazywanie parametrów (397)
  • 9.6.5. Ćwiczenia do podrozdziału 9.6 (397)
• 9.7. PHP (398)
  
  • 9.7.1. Podstawy PHP (398)
  • 9.7.2. Tablice (399)
  • 9.7.3. Biblioteka PEAR DB (399)
  • 9.7.4. Tworzenie połączenia z bazą danych za pomocą biblioteki DB (400)
  • 9.7.5. Uruchamianie instrukcji SQL (400)
  • 9.7.6. Operacje na kursorach w PHP (401)
  • 9.7.7. Dynamiczny SQL w języku PHP (402)
  • 9.7.8. Ćwiczenia do podrozdziału 9.7 (402)
• 9.8. Podsumowanie rozdziału 9. (403)
  
• 9.9. Bibliografia do rozdziału 9. (404)

10. Zaawansowane zagadnienia dotyczące relacyjnych baz danych (405)


• 10.1. Bezpieczeństwo i autoryzacja użytkowników w SQL (405)
  
  • 10.1.1. Uprawnienia (406)
  • 10.1.2. Definiowanie uprawnień (407)
  • 10.1.3. Proces sprawdzania uprawnień (408)
  • 10.1.4. Nadawanie uprawnień (409)
  • 10.1.5. Diagramy uprawnień (411)
  • 10.1.6. Odbieranie uprawnień (411)
  • 10.1.7. Ćwiczenia do podrozdziału 10.1 (415)
• 10.2. Rekurencja w języku SQL (416)
  
  • 10.2.1. Definiowanie relacji rekurencyjnych w języku SQL (416)
  • 10.2.2. Wyrażenia stwarzające problemy w rekurencyjnym SQL (419)
  • 10.2.3. Ćwiczenia do podrozdziału 10.2 (422)
• 10.3. Model obiektowo-relacyjny (423)
  
  • 10.3.1. Od relacji do obiektorelacji (424)
  • 10.3.2. Relacje zagnieżdżone (424)
  • 10.3.3. Referencje (425)
  • 10.3.4. Model obiektowy a obiektowo-relacyjny (426)
  • 10.3.5. Ćwiczenia do podrozdziału 10.3 (427)
• 10.4. Typy definiowane przez użytkowników w języku SQL (428)
  
  • 10.4.1. Definiowanie typów w języku SQL (428)
  • 10.4.2. Deklaracje metod w UDT (430)
  • 10.4.3. Definicje metod (430)
  • 10.4.4. Deklarowanie relacji z wykorzystaniem typów UDT (431)
  • 10.4.5. Referencje (431)
  • 10.4.6. Tworzenie identyfikatorów obiektów dla tabel (432)
  • 10.4.7. Ćwiczenia do podrozdziału 10.4 (433)
• 10.5. Działania na danych obiektowo-relacyjnych (434)
  
  • 10.5.1. Śledzenie referencji (434)
  • 10.5.2. Dostęp do składowych krotek wykorzystujących typy UDT (435)
  • 10.5.3. Funkcje generatora i mutatora (436)
  • 10.5.4. Sortowanie relacji bazujących na typach UDT (438)
  • 10.5.5. Ćwiczenia do podrozdziału 10.5 (439)
• 10.6. Przetwarzanie OLAP (440)
  
  • 10.6.1. Przetwarzanie OLAP i hurtownie danych (441)
  • 10.6.2. Aplikacje OLAP (441)
  • 10.6.3. Wielowymiarowe spojrzenie na dane OLAP (442)
  • 10.6.4. Schematy gwiaździste (443)
  • 10.6.5. Cięcie i kawałkowanie (445)
  • 10.6.6. Ćwiczenia do podrozdziału 10.6 (447)
• 10.7. Kostki danych (448)
  
  • 10.7.1. Operator CUBE (448)
  • 10.7.2. Operator CUBE w języku SQL (450)
  • 10.7.3. Ćwiczenia do podrozdziału 10.7 (452)
• 10.8. Podsumowanie rozdziału 10. (453)
  
• 10.9. Bibliografia do rozdziału 10. (454)

III: Modelowanie i programowanie danych semistrukturalnych (455)


11. Model danych semistrukturalnych (457)


• 11.1. Dane semistrukturalne (457)
  
  • 11.1.1. Sens istnienia modelu danych semistrukturalnych (457)
  • 11.1.2. Reprezentacja danych semistrukturalnych (458)
  • 11.1.3. Integracja informacji za pośrednictwem danych semistrukturalnych (459)
  • 11.1.4. Ćwiczenia do podrozdziału 11.1 (461)
• 11.2. XML (461)
  
  • 11.2.1. Znaczniki semantyczne (462)
  • 11.2.2. XML ze schematem i bez niego (462)
  • 11.2.3. Dokumenty XML poprawne składniowo (463)
  • 11.2.4. Atrybuty (464)
  • 11.2.5. Atrybuty łączące elementy (465)
  • 11.2.6. Przestrzenie nazw (466)
  • 11.2.7. XML i bazy danych (466)
  • 11.2.8. Ćwiczenia do podrozdziału 11.2 (468)
• 11.3. Definicje typu dokumentów (468)
  
  • 11.3.1. Format definicji DTD (468)
  • 11.3.2. Korzystanie z DTD (471)
  • 11.3.3. Listy atrybutów (471)
  • 11.3.4. Identyfikatory i referencje (472)
  • 11.3.5. Ćwiczenia do podrozdziału 11.3 (473)
• 11.4. XML Schema (474)
  
  • 11.4.1. Postać standardu XML Schema (474)
  • 11.4.2. Elementy (475)
  • 11.4.3. Typy złożone (476)
  • 11.4.4. Atrybuty (478)
  • 11.4.5. Ograniczenia dla typów prostych (479)
  • 11.4.6. Klucze w XML Schema (480)
  • 11.4.7. Klucze obce w XML Schema (482)
  • 11.4.8. Ćwiczenia do podrozdziału 11.4 (484)
• 11.5. Podsumowanie rozdziału 11. (484)
  
• 11.6. Bibliografia do rozdziału 11. (485)

12. Języki programowania dla XML (489)


• 12.1. XPath (489)
  
  • 12.1.1. Model danych XPath (489)
  • 12.1.2. Węzły-dokumenty (490)
  • 12.1.3. Ścieżki XPath (491)
  • 12.1.4. Ścieżki względne (492)
  • 12.1.5. Atrybuty w wyrażeniach opisujących ścieżki (492)
  • 12.1.6. Osie (493)
  • 12.1.7. Kontekst wyrażeń (494)
  • 12.1.8. Symbole wieloznaczne (494)
  • 12.1.9. Warunki w wyrażeniach ścieżek (495)
  • 12.1.10. Ćwiczenia do podrozdziału 12.1 (497)
• 12.2. XQuery (500)
  
  • 12.2.1. Podstawy języka XQuery (500)
  • 12.2.2. Wyrażenia FLWR (500)
  • 12.2.3. Zastępowanie zmiennych ich wartościami (504)
  • 12.2.4. Złączenia w XQuery (505)
  • 12.2.5. Operatory porównań w języku XQuery (506)
  • 12.2.6. Eliminowanie duplikatów (507)
  • 12.2.7. Kwantyfikatory w języku XQuery (508)
  • 12.2.8. Agregacje (509)
  • 12.2.9. Rozgałęzienia sterowania w wyrażeniach XQuery (509)
  • 12.2.10. Porządkowanie wyników zapytania (510)
  • 12.2.11. Ćwiczenia do podrozdziału 12.2 (512)
• 12.3. Język XSLT (513)
  
  • 12.3.1. Podstawy języka XSLT (513)
  • 12.3.2. Szablony (513)
  • 12.3.3. Odczytywanie wartości z danych XML (514)
  • 12.3.4. Rekurencyjne stosowanie szablonów (515)
  • 12.3.5. Iteracje w XSLT (517)
  • 12.3.6. Rozgałęzienia sterowania w XSLT (519)
  • 12.3.7. Ćwiczenia do podrozdziału 12.3 (519)
• 12.4. Podsumowanie rozdziału 12. (520)
  
• 12.5. Bibliografia do rozdziału 12. (521)

Skorowidz (523)

pokaż cały spis treści

ukryj recenzje