księgarnia informatyczna

Książka informatyczna wydawnictw: BTC Edition Exit Helion Help Microsoft Press Mikom Nakom PJWSTK Read Me Robomatic Skalmierski Tortech Translator WKŁ WNT WSISIZ

Projektuj i twórz bazy danych oraz zarządzaj nimi jak profesjonalista.

• Jak działają bazy danych?
• Jakie możliwości kryje język SQL?
• Jak modelować bazę danych?

Sam termin "baza danych" powstał w latach sześćdziesiątych ubiegłego wieku. W ciągu blisko pięćdziesięciu lat ewolucji w dziedzinie baz danych zaszły ogromne zmiany. Transakcje, wyzwalacze, procedury wbudowane, kontrola integralności, mechanizmy tworzenia kopii bezpieczeństwa to tylko część elementów, bez których nie mogą się obyć współczesne bazy danych. Jeżeli dołożymy do tego zestaw przeróżnych zaawansowanych narzędzi do ich projektowania i utrzymywania, otrzymamy ogromny obszar materiału do opanowania - od projektowania bazy po administrowanie.

Ten podręcznik zawiera całą wiedzę potrzebną do swobodnego poruszania się w świecie baz danych. W trakcie lektury poznasz historię baz, ich rodzaje oraz ogólną zasadę działania. Ponadto zdobędziesz wiedzę na temat tworzenia relacyjnego modelu danych oraz zobaczysz, jak przeprowadzić operację normalizacji. Będziesz miał również okazję poszerzyć swoje wiadomości na temat wysokopoziomowych modeli baz danych. Po opanowaniu teorii przejdziesz do części praktycznej.

Nauczysz się biegle korzystać z języka SQL, deklarować więzy integralności, tworzyć widoki i indeksy. Ostatnie rozdziały poświęcone zostały zaawansowanym zagadnieniom związanym ze środowiskiem serwerowym, bezpieczeństwem baz, typami własnymi oraz modelowaniem i programowaniem danych semistrukturalnych. To idealna pozycja dla wszystkich osób, które interesują się bazami danych lub pracują z nimi na co dzień.

• Historia baz danych
• Zarys systemu zarządzania bazą danych
• Relacyjny model danych
• Projektowanie relacyjnych baz danych
• Trzecia postać normalna
• Wysokopoziomowe modele baz danych
• Modele związków encji
• Diagramy E/R
• Język UML, ODL
• Algebraiczne i logiczne języki zapytań
• Zapytania SQL
• Korzystanie z podzapytań
• Transakcje
• Zastosowanie wyzwalaczy
• Tworzenie widoków
• Trójwarstwowa architektura aplikacji
• Procedury składowane
• JDBC
• Bezpieczeństwo i autoryzacja użytkowników w SQL
• Model danych semistrukturalnych
• Języki programowania dla formatu XML

Odkryj wszystkie tajemnice baz danych.

Rozdziały:

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)

adobe algorytmy apache asp autocad asembler bsd c++ c# delphi dtp excel flash html java javascript linux matlab mysql office php samba voip uml unix visual studio windows word

Księgarnia Informatyczna  zaprasza.