reklama - zainteresowany?

Systemy baz danych. Kompletny podręcznik. Wydanie II - Helion

Systemy baz danych. Kompletny podręcznik. Wydanie II
Autor: Hector Garcia-Molina, Jeffrey D. Ullman, Jennifer Widom
Tytuł oryginału: Database Systems: The Complete Book (2nd Edition)
Tłumaczenie: Tomasz Walczak
ISBN: 978-83-246-3303-6
stron: 1048, Format: 172x245, okładka: twarda
Data wydania: 2011-10-21
Księgarnia: Helion

Cena książki: 99,00 zł

Dodaj do koszyka Systemy baz danych. Kompletny podręcznik. Wydanie II

Pobierz fragment książki »   Osoby, które kupiły tę książkę, wybierały także »
Tagi: Inne

Pierwsze tak szczegółowe, kompleksowe wprowadzenie!

Trzej znani naukowcy z dziedziny IT nauczą Cię:

  • profesjonalnego projektowania i korzystania z baz danych
  • tworzenia i wdrażania złożonych aplikacji bazodanowych
  • sprawnej implementacji systemów zarządzania bazami danych

Z kluczowej roli, jaką bazy danych odgrywają w codziennym życiu milionów ludzi, zdajemy sobie sprawę za każdym razem, gdy wpisujemy hasło w wyszukiwarce Google, robimy zakupy w internetowej księgarni czy logujemy się do swojego konta w banku. Szybkie, bezpieczne i niezawodne przetwarzanie oraz przechowywanie ogromnych ilości informacji stało się dziś strategicznym czynnikiem funkcjonowania większości firm, organizacji i instytucji państwowych. Ten ogromny potencjał współczesnych baz danych jest dziś sumą wiedzy i technologii rozwijanych przez kilka ostatnich dziesięcioleci. Owocem tych prac jest przede wszystkim wyspecjalizowane oprogramowanie - systemy zarządzania bazami danych DBMS, czyli rozbudowane narzędzia do wydajnego tworzenia dużych zbiorów informacji i zarządzania nimi. Niestety, mają one jedną zasadniczą wadę - należą do najbardziej złożonych rodzajów oprogramowania!

W związku z tym trzech znanych naukowców w dziedzinie IT z Uniwersytetu Stanforda. Hector Garcia-Molina, Jeffrey D. Ullman i Jennifer Widom - postanowiło stworzyć pierwszy tak kompletny podręcznik, wprowadzający do systemów baz danych. Zawiera on opis najnowszych standardów bazy danych SQL 1999, SQL/PSM, SQL/CLI, JDBC, ODL oraz XML - i to w znacznie szerszym zakresie niż w większości publikacji. Podręcznik został przygotowany w taki sposób, aby po jego przeczytaniu użytkowanie czy projektowanie baz danych, pisanie programów w różnych językach związanych z systemami DBMS oraz ich sprawna implementacja nie stanowiły dla Czytelnika najmniejszego problemu! W tej książce znajdziesz obszerne omówienie między innymi:

  • modelowania relacyjnego i wysokopoziomowego oraz języka UML i ODL
  • zależności funkcyjnych i wielowartościowych oraz algorytmów umożliwiających manipulowanie zależnościami
  • różnych aspektów programowania w języku SQL
  • architektury trójwarstwowej, kostek danych, modelu relacji zagnieżdżonych i obiektowo-relacyjnych funkcji SQL-a
  • XML-a i systemów opartych na tym języku
  • zagadnień dotyczących sprawnego implementowania baz danych
  • struktur używanych w indeksach, w tym drzew zbalansowanych, struktur haszujących i struktur dla indeksów wielowymiarowych
  • wykonywania i optymalizowania zapytań, rejestrowania zdarzeń, kontrolowania współbieżności
  • równoległych i rozproszonych baz danych, platformy Map Reduce, bazy danych P2P
  • kluczowych technik, takich jak shingling, MinHash i LSH, służących do wyszukiwania podobnych elementów w dużych bazach danych
  • algorytmów przeszukiwania sieci WWW, w tym algorytmu PageRank i jego odmian
  • modelu strumieniowania danych i rozszerzenia języka SQL

Kompleksowe podejście do systemów baz danych ? z punktu widzenia projektanta, użytkownika i programisty.

Dodaj do koszyka Systemy baz danych. Kompletny podręcznik. Wydanie II

 

Osoby które kupowały "Systemy baz danych. Kompletny podręcznik. Wydanie II", wybierały także:

  • Windows Media Center. Domowe centrum rozrywki
  • Przywództwo w świecie VUCA. Jak być skutecznym liderem w niepewnym środowisku
  • Mapa Agile & Scrum. Jak si
  • Sztuka podst
  • Lean dla bystrzaków. Wydanie II

Dodaj do koszyka Systemy baz danych. Kompletny podręcznik. Wydanie II

Spis treści

Systemy baz danych. Kompletny podręcznik. Wydanie II -- spis treści

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)

Dodaj do koszyka Systemy baz danych. Kompletny podręcznik. Wydanie II

Code, Publish & WebDesing by CATALIST.com.pl



(c) 2005-2024 CATALIST agencja interaktywna, znaki firmowe należą do wydawnictwa Helion S.A.