Rzut oka na książkę O autorach ....................................................................................................... 25 Wprowadzenie...
Rzut oka na książkę O autorach ....................................................................................................... 25 Wprowadzenie ................................................................................................. 27
Część I. Komponenty Accessa ....................................................... 33 Rozdział 1. Wprowadzenie do projektowania baz danych ............................. 35 Rozdział 2. Wprowadzenie do Accessa ............................................................ 51
Część II. Tabele Accessa ................................................................. 63 Rozdział 3. Tworzenie tabel ............................................................................. 65 Rozdział 4. Relacje między tabelami .............................................................. 117 Rozdział 5. Praca z tabelami ........................................................................... 155 Rozdział 6. Importowanie i eksportowanie danych ..................................... 191 Rozdział 7. Dołączanie danych zewnętrznych ............................................... 221
Część III. Kwerendy Accessa ........................................................ 245 Rozdział 8. Pobieranie danych za pomocą kwerend ..................................... 247 Rozdział 9. Stosowanie operatorów i wyrażeń ............................................. 277 Rozdział 10. Poza kwerendy wybierające ...................................................... 317
Część IV. Analizowanie danych w Accessie ................................ 349 Rozdział 11. Przekształcanie danych ............................................................. 351 Rozdział 12. Obliczenia i daty ......................................................................... 371 Rozdział 13. Analizy warunkowe .................................................................... 393 Rozdział 14. Podstawy SQL-a w Accessie ....................................................... 409 Rozdział 15. Podkwerendy i funkcje agregujące domeny ............................ 427 Rozdział 16. Statystyki opisowe ..................................................................... 447
6
Access 2013 PL. Biblia
Część V. Formularze i raporty Accessa ....................................... 461 Rozdział 17. Tworzenie prostych formularzy ................................................ 463 Rozdział 18. Praca z danymi w formularzach ................................................ 499 Rozdział 19. Praca z formantami formularzy ................................................ 529 Rozdział 20. Prezentowanie danych za pomocą raportów .......................... 561 Rozdział 21. Raporty w Accessie — techniki zaawansowane ....................... 613
Część VI. Podstawy programowania w Accessie ....................... 653 Rozdział 22. Korzystanie z makr programu Access ....................................... 655 Rozdział 23. Podstawy programowania w języku VBA ................................. 689 Rozdział 24. Typy danych i procedury w języku VBA .................................... 727 Rozdział 25. Model zdarzeń ............................................................................ 767 Rozdział 26. Debugowanie aplikacji Accessa ................................................. 789
Część VII. Zaawansowane techniki programowania w Accessie ................................................................... 817 Rozdział 27. Dostęp do danych za pomocą kodu VBA ................................... 819 Rozdział 28. Zaawansowany dostęp do danych z wykorzystaniem kodu VBA ................................................... 859 Rozdział 29. Integrowanie baz SQL Server i Access ....................................... 875 Rozdział 30. Dostosowywanie wstążek ......................................................... 915 Rozdział 31. Dystrybucja aplikacji Accessa .................................................... 949
Część VIII. Access i Windows SharePoint Services ...................... 991 Rozdział 32. Wprowadzenie do programu Windows SharePoint Services .... 993 Rozdział 33. Integrowanie Accessa z SharePointem ..................................... 999 Rozdział 34. Wprowadzenie do usług Access Services ................................ 1013 Rozdział 35. Instalowanie aplikacji Accessa w SharePoincie ...................... 1023 Rozdział 36. Makra danych ........................................................................... 1039
Dodatki ..................................................................................... 1057 Dodatek A. Specyfikacja Accessa 2013 ........................................................ 1059 Dodatek B. Optymalizowanie aplikacji Accessa .......................................... 1065 Dodatek C. Wydajność kwerend i uszkodzenia baz danych ....................... 1087 Dodatek D. Przegląd funkcji dla analityków danych .................................. 1095 Skorowidz ................................................................................................... 1127
Spis treści O autorach ....................................................................................................... 25 Wprowadzenie ................................................................................................. 27
Część I. Komponenty Accessa ....................................................... 33 Rozdział 1. Wprowadzenie do projektowania baz danych ............................. 35 Terminologia związana z bazami danych występująca w Accessie ....................................................35 Bazy danych .................................................................................................................................36 Tabele ...........................................................................................................................................37 Rekordy i pola ..............................................................................................................................38 Wartości .......................................................................................................................................38 Relacyjne bazy danych .......................................................................................................................38 Obiekty baz danych Accessa ..............................................................................................................39 Arkusze danych ............................................................................................................................40 Kwerendy .....................................................................................................................................40 Formularze do wprowadzania danych i ich wyświetlania ............................................................40 Raporty .........................................................................................................................................41 Obiekty bazy danych ....................................................................................................................41 Pięcioetapowa metoda projektowania .................................................................................................42 Krok 1.: Ogólny projekt systemu — od koncepcji do rzeczywistości ..........................................42 Krok 2.: Projektowanie raportów ..................................................................................................43 Krok 3.: Projektowanie danych ....................................................................................................43 Krok 4.: Projektowanie tabel ........................................................................................................45 Krok 5.: Projektowanie formularzy ..............................................................................................48 Rozdział 2. Wprowadzenie do Accessa ............................................................ 51 Ekran powitalny ..................................................................................................................................51 Tworzenie pustej bazy danych dla komputerów stacjonarnych ..........................................................53 Interfejs Accessa 2013 ........................................................................................................................54 Okienko nawigacji ........................................................................................................................55 Wstążka ........................................................................................................................................58 Pasek narzędzi Szybki dostęp .......................................................................................................58
8
Access 2013 PL. Biblia
Część II. Tabele Accessa ................................................................. 63 Rozdział 3. Tworzenie tabel ............................................................................. 65 Rodzaje tabel ......................................................................................................................................65 Tabele obiektów ...........................................................................................................................66 Tabele transakcyjne ......................................................................................................................66 Tabele łączące ..............................................................................................................................66 Tworzenie nowej tabeli .......................................................................................................................66 Projektowanie tabel ......................................................................................................................68 Posługiwanie się zakładką Projektowanie ....................................................................................72 Praca z polami ..............................................................................................................................74 Tworzenie tabeli klientów ..................................................................................................................82 Korzystanie z pól typu Autonumerowanie ...................................................................................82 Kończenie definicji tabeli tblCustomers .......................................................................................82 Zmiana projektu tabeli ........................................................................................................................83 Wstawianie pola ...........................................................................................................................83 Usuwanie pola ..............................................................................................................................83 Zmiana położenia pola ..................................................................................................................84 Zmiana nazwy pola .......................................................................................................................84 Zmiana rozmiaru pola ...................................................................................................................84 Problemy konwersji danych .........................................................................................................84 Przypisywanie właściwości pól ....................................................................................................85 Właściwości pól tabeli tblCustomers ................................................................................................101 Określanie klucza głównego .............................................................................................................103 Wybór klucza głównego .............................................................................................................103 Tworzenie klucza głównego .......................................................................................................104 Tworzenie złożonych kluczy głównych ......................................................................................105 Indeksowanie tabel ...........................................................................................................................106 Ważność stosowania indeksów ...................................................................................................107 Indeksy złożone z wielu pól .......................................................................................................108 Kiedy należy indeksować tabele? ...............................................................................................110 Drukowanie struktury tabeli .............................................................................................................111 Zapisywanie ukończonej tabeli .........................................................................................................112 Operacje na tabelach .........................................................................................................................113 Zmiana nazwy tabel ....................................................................................................................113 Usuwanie tabel ...........................................................................................................................113 Kopiowanie tabel w obrębie bazy danych ..................................................................................113 Kopiowanie tabel do innej bazy danych .....................................................................................114 Dodawanie rekordów do tabeli bazy danych ....................................................................................115 Posługiwanie się polami typu Załącznik ...........................................................................................116 Rozdział 4. Relacje między tabelami .............................................................. 117 Tworzenie kuloodpornych baz danych .............................................................................................118 Normalizacja i denormalizacja danych .............................................................................................120 Pierwsza postać normalna ..........................................................................................................120 Druga postać normalna ...............................................................................................................123 Trzecia postać normalna .............................................................................................................128 Denormalizacja ...........................................................................................................................130
Spis treści
9
Relacje między tabelami ...................................................................................................................131 Wiązanie danych ........................................................................................................................132 Jeden do jednego ........................................................................................................................134 Jeden do wielu ............................................................................................................................135 Wiele do wielu ............................................................................................................................137 Reguły integralności .........................................................................................................................138 Klucz główny nie może mieć wartości null ................................................................................140 Wszystkim wartościom kluczy obcych muszą odpowiadać klucze główne ................................141 Klucze ...............................................................................................................................................142 Określanie klucza głównego .......................................................................................................143 Korzyści wynikające ze stosowania kluczy głównych ...............................................................144 Wybór klucza głównego .............................................................................................................145 Tworzenie relacji i wymuszanie przestrzegania integralności odwołań .....................................147 Przeglądanie wszystkich relacji ..................................................................................................152 Usuwanie relacji .........................................................................................................................153 Reguły integralności specyficzne dla aplikacji ...........................................................................153 Rozdział 5. Praca z tabelami ........................................................................... 155 Arkusze danych ................................................................................................................................156 Okno arkusza danych ........................................................................................................................157 Poruszanie się po arkuszu danych ..............................................................................................157 Korzystanie z przycisków nawigacyjnych ..................................................................................158 Wstążka arkusza danych .............................................................................................................159 Otwieranie arkusza danych ...............................................................................................................160 Wpisywanie nowych danych ............................................................................................................161 Zapisywanie rekordu ..................................................................................................................162 Automatyczne sprawdzanie poprawności typów danych ............................................................163 W jaki sposób właściwości wpływają na wprowadzanie danych? ..............................................164 Poruszanie się między rekordami w arkuszu danych ........................................................................167 Poruszanie się między rekordami ...............................................................................................167 Wyszukiwanie określonej wartości ............................................................................................168 Modyfikowanie wartości w arkuszu danych .....................................................................................170 Ręczne zamienianie istniejących wartości ..................................................................................170 Modyfikacja istniejącej wartości ................................................................................................171 Używanie funkcji Cofnij ...................................................................................................................172 Kopiowanie i wklejanie wartości ......................................................................................................172 Zastępowanie wartości ......................................................................................................................173 Dodawanie nowych rekordów ..........................................................................................................174 Usuwanie rekordów ..........................................................................................................................174 Wyświetlanie rekordów ....................................................................................................................175 Zmiana kolejności pól ................................................................................................................175 Zmiana szerokości wyświetlanych pól .......................................................................................176 Zmiana wysokości wyświetlanych rekordów .............................................................................177 Zmiana czcionki .........................................................................................................................178 Wyświetlanie linii oddzielających komórki i różne kolory wierszy ...........................................179 Wyrównywanie danych w kolumnach ........................................................................................181 Ukrywanie i odkrywanie kolumn ...............................................................................................181 Blokowanie kolumn ....................................................................................................................182 Zapisywanie zmienionego układu arkusza .................................................................................182 Zapisywanie rekordu ..................................................................................................................182
10
Access 2013 PL. Biblia Sortowanie i filtrowanie rekordów w arkuszu danych ......................................................................182 Korzystanie z funkcji szybkiego sortowania ..............................................................................183 Używanie filtrowania według wyboru ........................................................................................183 Używanie filtrowania według formularza ..................................................................................185 Agregowanie danych ........................................................................................................................186 Drukowanie rekordów ......................................................................................................................188 Drukowanie arkusza danych .......................................................................................................188 Korzystanie z podglądu wydruku ...............................................................................................189 Rozdział 6. Importowanie i eksportowanie danych ..................................... 191 Access i dane zewnętrzne .................................................................................................................191 Typy danych zewnętrznych ........................................................................................................192 Metody pracy z danymi zewnętrznymi .......................................................................................192 Typy importu i eksportu ...................................................................................................................195 Importowanie zewnętrznych danych ................................................................................................196 Importowanie z innej bazy danych Accessa ...............................................................................197 Importowanie danych z arkusza kalkulacyjnego Excela .............................................................199 Importowanie list SharePointa ....................................................................................................203 Importowanie danych z plików tekstowych ................................................................................203 Importowanie i eksportowanie dokumentów XML ....................................................................208 Importowanie i eksportowanie dokumentów HTML ..................................................................212 Importowanie obiektów Accessa innych niż tabele ....................................................................214 Importowanie folderu Outlooka .................................................................................................215 Eksportowanie do formatów zewnętrznych ......................................................................................217 Eksportowanie obiektów do innych baz danych Accessa ...........................................................217 Eksportowanie do programu Word .............................................................................................218 Publikowanie w formacie PDF lub XPS .....................................................................................219 Rozdział 7. Dołączanie danych zewnętrznych ............................................... 221 Dołączanie danych zewnętrznych .....................................................................................................222 Identyfikowanie tabel połączonych ............................................................................................223 Ograniczenia dotyczące dołączonych danych .............................................................................225 Dołączanie tabel z innych baz danych Accessa ..........................................................................226 Łączenie ze źródłami danych ODBC ..........................................................................................228 Dołączanie danych, które nie są bazami .....................................................................................229 Praca z tabelami połączonymi ..........................................................................................................235 Ustawianie właściwości widoku .................................................................................................235 Ustawianie relacji .......................................................................................................................236 Optymalizowanie tabel połączonych ..........................................................................................236 Usuwanie odwołania do tabeli połączonej ..................................................................................237 Przeglądanie lub zmienianie informacji o tabelach połączonych ...............................................237 Odświeżanie zawartości tabel połączonych ................................................................................238 Dzielenie baz danych dla dostępu sieciowego ..................................................................................239 Zalety dzielenia baz danych ........................................................................................................239 Jak podzielić obiekty? ................................................................................................................242 Korzystanie z dodatku Rozdzielacz bazy danych .......................................................................242
Spis treści
11
Część III. Kwerendy Accessa ........................................................ 245 Rozdział 8. Pobieranie danych za pomocą kwerend ..................................... 247 Wprowadzenie w tematykę kwerend ................................................................................................248 Czym są kwerendy? ....................................................................................................................248 Co można robić za pomocą kwerend? ........................................................................................249 Co zwracają kwerendy? ..............................................................................................................250 Tworzenie kwerendy ........................................................................................................................250 Dodawanie pól ............................................................................................................................253 Uruchamianie kwerend ...............................................................................................................255 Praca z polami ..................................................................................................................................256 Zaznaczanie pola w obszarze siatki QBE ...................................................................................256 Zmiana kolejności pól ................................................................................................................257 Zmiana rozmiaru kolumn w obszarze siatki QBE ......................................................................257 Usuwanie pól ..............................................................................................................................258 Wstawianie pól ...........................................................................................................................258 Ukrywanie pól ............................................................................................................................258 Zmiana kolejności sortowania ....................................................................................................259 Dodawanie kryteriów do kwerend ....................................................................................................260 Kryteria wyboru rekordów .........................................................................................................260 Definiowanie prostych kryteriów tekstowych ............................................................................261 Definiowanie prostych kryteriów innych typów .........................................................................262 Drukowanie zbiorów wynikowych kwerend .....................................................................................263 Zapisywanie kwerendy .....................................................................................................................264 Tworzenie kwerend bazujących na wielu tabelach ...........................................................................264 Przeglądanie nazw tabel .............................................................................................................265 Dodawanie wielu pól ..................................................................................................................266 Ograniczenia dla kwerend bazujących na wielu tabelach ...........................................................266 Obchodzenie ograniczeń dotyczących kwerend .........................................................................267 Obszar tabel ......................................................................................................................................268 Linie sprzężeń .............................................................................................................................268 Przesuwanie tabel .......................................................................................................................269 Usuwanie tabel ...........................................................................................................................269 Dodawanie kolejnych tabel .........................................................................................................270 Tworzenie sprzężeń w kwerendach i ich obsługa .............................................................................270 Wprowadzenie do sprzężeń ........................................................................................................270 Wykorzystywanie sprzężeń ad hoc .............................................................................................272 Określanie typu sprzężenia .........................................................................................................273 Usuwanie sprzężeń .....................................................................................................................274 Rozdział 9. Stosowanie operatorów i wyrażeń ............................................. 277 Wprowadzenie w tematykę operatorów ............................................................................................277 Typy operatorów ........................................................................................................................278 Priorytety operatorów .................................................................................................................289 Stosowanie operatorów i wyrażeń w kwerendach ............................................................................291 Używanie operatorów porównania w kwerendach .....................................................................292 Tworzenie złożonych kryteriów .................................................................................................292 Używanie funkcji w kwerendach wybierających ........................................................................296 Odwoływanie się do pól w kwerendach wybierających .............................................................296
12
Access 2013 PL. Biblia Wpisywanie kryteriów jednowartościowych ....................................................................................296 Wprowadzanie kryteriów znakowych (Krótki tekst lub Długi tekst) ..........................................297 Operator Like i symbole wieloznaczne .......................................................................................298 Określanie wartości niepasujących .............................................................................................301 Wprowadzanie kryteriów liczbowych ........................................................................................302 Wprowadzanie kryteriów logicznych (Prawda/Fałsz) ................................................................303 Wprowadzanie kryterium dla obiektu OLE ................................................................................303 Wprowadzanie wielu kryteriów w kwerendzie .................................................................................304 Operacja Or ................................................................................................................................304 Określanie wielu wartości pola za pomocą operatora Or ............................................................304 Używanie komórki Lub: na siatce projektu (QBE) .....................................................................305 Używanie listy wartości w połączeniu z operatorem In ..............................................................306 Wykorzystanie operatora And do zdefiniowania zakresu ...........................................................306 Stosowanie operatora Between...And .........................................................................................307 Wyszukiwanie danych o wartości Null .......................................................................................308 Wprowadzanie kryteriów w wielu polach .........................................................................................310 Stosowanie operacji And i Or w polach kwerendy .....................................................................310 Określanie kryteriów Or w wielu polach kwerendy ...................................................................311 Stosowanie operacji And i Or na różnych polach .......................................................................313 Kwerenda złożona w wielu wierszach ........................................................................................313 Rozdział 10. Poza kwerendy wybierające ...................................................... 317 Kwerendy podsumowujące ...............................................................................................................317 Tworzenie kwerendy podsumowującej .......................................................................................318 Funkcje agregujące .....................................................................................................................320 Kwerendy funkcjonalne ....................................................................................................................325 Kwerendy tworzące tabele ..........................................................................................................325 Kwerendy usuwające ..................................................................................................................327 Kwerendy dołączające ................................................................................................................329 Kwerendy aktualizujące .............................................................................................................334 Kwerendy krzyżowe .........................................................................................................................337 Używanie kreatora kwerend krzyżowych ...................................................................................338 Ręczne tworzenie kwerend krzyżowych .....................................................................................342
Część IV. Analizowanie danych w Accessie ................................ 349 Rozdział 11. Przekształcanie danych ............................................................. 351 Wyszukiwanie i usuwanie powtarzających się rekordów .................................................................352 Czym są powtarzające się rekordy? ............................................................................................352 Wyszukiwanie duplikatów .........................................................................................................353 Usuwanie powtarzających się rekordów .....................................................................................355 Typowe zadania z zakresu przekształcania danych ..........................................................................358 Uzupełnianie pustych pól ...........................................................................................................358 Scalanie łańcuchów znaków .......................................................................................................359 Zmiana wielkości liter ................................................................................................................361 Usuwanie początkowych i końcowych spacji z łańcuchów znaków ...........................................362 Wyszukiwanie i zastępowanie określonego tekstu .....................................................................363 Dodawanie własnego tekstu w określonych miejscach łańcucha znaków ..................................364 Przetwarzanie łańcuchów znaków na podstawie znaczników ....................................................367
Spis treści
13
Rozdział 12. Obliczenia i daty ......................................................................... 371 Korzystanie z obliczeń w analizach ..................................................................................................371 Typowe scenariusze związane z obliczeniami ............................................................................372 Tworzenie obliczeń za pomocą konstruktora wyrażeń ...............................................................375 Typowe błędy w obliczeniach ....................................................................................................379 Używanie dat w analizach ................................................................................................................382 Proste obliczenia na datach .........................................................................................................382 Zaawansowane analizy z wykorzystaniem funkcji .....................................................................382 Rozdział 13. Analizy warunkowe .................................................................... 393 Stosowanie kwerend z parametrami .................................................................................................393 Jak działają kwerendy z parametrami? .......................................................................................395 Podstawowe zasady dotyczące kwerend z parametrami .............................................................395 Używanie kwerend z parametrami .............................................................................................395 Stosowanie funkcji warunkowych ....................................................................................................400 Funkcja IIf ..................................................................................................................................401 Funkcja Switch ...........................................................................................................................405 Porównanie funkcji IIf i Switch ..................................................................................................406 Rozdział 14. Podstawy SQL-a w Accessie ....................................................... 409 Podstawy SQL-a ...............................................................................................................................409 Instrukcja SELECT ....................................................................................................................410 Klauzula WHERE ......................................................................................................................411 Sprzężenia ..................................................................................................................................412 Zaawansowane instrukcje SQL-a ......................................................................................................413 Rozbudowywanie wyszukiwania za pomocą operatora Like ......................................................413 Pobieranie unikatowych wartości i wierszy bez grupowania ......................................................415 Grupowanie i agregowanie danych za pomocą klauzuli GROUP BY ........................................415 Określanie kolejności sortowania za pomocą klauzuli ORDER BY ...........................................416 Tworzenie aliasów za pomocą klauzuli AS ................................................................................416 Wyświetlanie tylko pierwszych elementów (instrukcje SELECT TOP i SELECT TOP PERCENT) ..........................................................416 Wykonywanie kwerend funkcjonalnych za pomocą instrukcji SQL-a .......................................419 Tworzenie kwerend krzyżowych za pomocą instrukcji TRANSFORM .....................................419 Kwerendy charakterystyczne dla SQL-a ...........................................................................................420 Scalanie zbiorów danych za pomocą operatora UNION ............................................................420 Tworzenie tabeli za pomocą instrukcji CREATE TABLE .........................................................422 Manipulowanie kolumnami za pomocą instrukcji ALTER TABLE ...........................................422 Tworzenie kwerend przekazujących ...........................................................................................424 Rozdział 15. Podkwerendy i funkcje agregujące domeny ............................ 427 Wzbogacanie analiz za pomocą podkwerend ....................................................................................428 Po co stosować podkwerendy? ...................................................................................................429 Podstawowe zasady dotyczące podkwerend ...............................................................................429 Tworzenie podkwerend bez pisania instrukcji SQL-a ................................................................429 Używanie operatorów IN i NOT IN w podkwerendach .............................................................432 Używanie podkwerend z operatorami porównania .....................................................................432 Stosowanie podkwerend jako wyrażeń .......................................................................................433 Stosowanie podkwerend skorelowanych ....................................................................................434 Używanie podkwerend w kwerendach funkcjonalnych ..............................................................436
14
Access 2013 PL. Biblia Funkcje agregujące domeny .............................................................................................................438 Różne funkcje agregujące domeny .............................................................................................440 Składnia funkcji agregujących domeny ......................................................................................441 Stosowanie funkcji agregujących domeny ..................................................................................442 Rozdział 16. Statystyki opisowe ..................................................................... 447 Podstawowe statystyki opisowe ........................................................................................................448 Obliczanie statystyk opisowych za pomocą kwerend podsumowujących ..................................448 Określanie rankingu, wartości modalnej i mediany ....................................................................449 Pobieranie losowej próbki ze zbioru danych ..............................................................................454 Zaawansowane statystyki opisowe ...................................................................................................455 Obliczanie percentyli ..................................................................................................................455 Ustalanie kwartyla dla rekordu ...................................................................................................457 Tworzenie rozkładu częstości .....................................................................................................458
Część V. Formularze i raporty Accessa ....................................... 461 Rozdział 17. Tworzenie prostych formularzy ................................................ 463 Tworzenie formularzy ......................................................................................................................464 Tworzenie nowego formularza ...................................................................................................465 Specjalne typy formularzy ..........................................................................................................469 Zmiana rozmiaru obszaru formularza .........................................................................................474 Zapisywanie formularza .............................................................................................................474 Formanty formularza ........................................................................................................................475 Typy formantów .........................................................................................................................475 Dodawanie formantów ...............................................................................................................477 Zaznaczanie i anulowanie zaznaczenia formantów ....................................................................482 Wykonywanie operacji na formantach .......................................................................................483 Właściwości ......................................................................................................................................492 Wyświetlanie arkusza właściwości .............................................................................................493 Korzystanie z arkusza właściwości .............................................................................................494 Zmiana ustawień właściwości formantu .....................................................................................494 Nadawanie nazw i tytułów formantom .......................................................................................496 Rozdział 18. Praca z danymi w formularzach ................................................ 499 Używanie widoku formularza ...........................................................................................................500 Zakładka NARZĘDZIA GŁÓWNE ...........................................................................................501 Nawigacja między polami ..........................................................................................................504 Nawigacja między rekordami w formularzu ...............................................................................504 Modyfikowanie wartości w formularzu ............................................................................................505 Formanty, których nie można modyfikować ..............................................................................506 Praca z obrazami i obiektami OLE .............................................................................................506 Wprowadzanie danych w polu typu Długi tekst .........................................................................507 Wprowadzanie danych w polu typu Data ...................................................................................507 Używanie grup opcji ...................................................................................................................508 Używanie pól kombi i list ...........................................................................................................509 Przełączanie się do widoku arkusza danych ...............................................................................510 Zapisywanie rekordu ..................................................................................................................510
Spis treści
15
Drukowanie formularzy ....................................................................................................................510 Praca z właściwościami formularza ..................................................................................................511 Modyfikacja tekstu na pasku tytułu za pomocą właściwości Tytuł ............................................513 Tworzenie formularza związanego .............................................................................................514 Określanie sposobu wyświetlania formularza .............................................................................514 Usuwanie paska selektora rekordów ...........................................................................................515 Inne właściwości formularzy ......................................................................................................515 Dodawanie nagłówka lub stopki formularza .....................................................................................522 Korzystanie z właściwości sekcji ......................................................................................................522 Właściwość Widoczny ...............................................................................................................522 Właściwość Wysokość ...............................................................................................................522 Właściwość Kolor tła .................................................................................................................522 Właściwość Efekt specjalny .......................................................................................................523 Właściwość Kiedy wyświetlać ...................................................................................................523 Właściwości związane z drukowaniem ......................................................................................523 Zmiana układu formularza ................................................................................................................523 Modyfikacja właściwości formantów .........................................................................................524 Określanie kolejności dostępu ....................................................................................................524 Modyfikowanie formatu tekstu w formancie ..............................................................................525 Używanie narzędzia Lista pól do dodawania formantów ...........................................................526 Przekształcanie formularza w raport .................................................................................................527 Rozdział 19. Praca z formantami formularzy ................................................ 529 Ustawianie właściwości formantów ..................................................................................................530 Modyfikowanie właściwości domyślnych ..................................................................................531 Często używane formanty i właściwości ....................................................................................532 Tworzenie formantów obliczeniowych .............................................................................................537 Praca z podformularzami ..................................................................................................................537 Wskazówki z zakresu projektowania formularzy .............................................................................539 Wykorzystanie właściwości Tab Stop ........................................................................................539 Zliczanie pól wyboru ..................................................................................................................539 Szybsze odświeżanie z użyciem SQL-a ......................................................................................539 Techniki związane z polami kombi i polami list ........................................................................540 Techniki zaawansowane ...................................................................................................................542 Formanty numeru strony i daty/godziny .....................................................................................542 Stosowanie formantu Obraz .......................................................................................................543 Morfing formantów ....................................................................................................................543 Malarz formatów ........................................................................................................................544 Dodatkowa pomoc dla użytkowników ........................................................................................545 Dodawanie obrazów tła ..............................................................................................................545 Ograniczanie liczby rekordów wyświetlanych w formularzu .....................................................547 Korzystanie z formantu Karta ...........................................................................................................548 Pobieranie informacji za pomocą okien dialogowych ......................................................................550 Projektowanie kwerend ..............................................................................................................551 Konfigurowanie przycisków poleceń .........................................................................................552 Wybór przycisku domyślnego ....................................................................................................552 Konfiguracja przycisku Anuluj ...................................................................................................553 Usunięcie menu sterowania ........................................................................................................553
16
Access 2013 PL. Biblia Projektowanie formularza od podstaw ..............................................................................................553 Tworzenie prostego formularza ..................................................................................................553 Tworzenie podformularza ...........................................................................................................554 Dodawanie podformularza .........................................................................................................555 Modyfikowanie działania formularza .........................................................................................557 Modyfikowanie wyglądu formularza ..........................................................................................559 Rozdział 20. Prezentowanie danych za pomocą raportów .......................... 561 Podstawowe informacje o raportach .................................................................................................561 Dostępne typy raportów ..............................................................................................................562 Różnice między raportami a formularzami .................................................................................565 Tworzenie raportu od podstaw ..........................................................................................................565 Zdefiniowanie układu raportu .....................................................................................................565 Gromadzenie danych ..................................................................................................................565 Tworzenie raportu za pomocą kreatora .......................................................................................566 Drukowanie lub wyświetlanie raportu ........................................................................................579 Zapisywanie raportów ................................................................................................................581 Zagadnienia związane z raportami typu pasmowego ........................................................................581 Sekcja nagłówka raportu ............................................................................................................583 Sekcja nagłówka strony ..............................................................................................................584 Sekcja nagłówka grupy ...............................................................................................................584 Sekcja szczegółów ......................................................................................................................585 Sekcja stopki grupy ....................................................................................................................585 Sekcja stopki strony ....................................................................................................................585 Sekcja stopki raportu ..................................................................................................................585 Tworzenie raportu od podstaw ..........................................................................................................586 Tworzenie nowego raportu i wiązanie go z kwerendą ................................................................587 Definiowanie rozmiaru i układu strony raportu ..........................................................................589 Umieszczanie formantów na raporcie .........................................................................................590 Zmiana rozmiaru sekcji ..............................................................................................................590 Praca z polami tekstowymi .........................................................................................................592 Zmiana właściwości etykiet i pól tekstowych .............................................................................598 Powiększanie i zmniejszanie pól tekstowych .............................................................................599 Sortowanie i grupowanie danych ................................................................................................601 Sortowanie danych w obrębie grup ............................................................................................603 Wprowadzanie podziału na strony ..............................................................................................605 Dopracowywanie wyglądu raportu ...................................................................................................606 Modyfikowanie nagłówka strony ...............................................................................................607 Tworzenie wyrażenia w nagłówku grupy ...................................................................................608 Tworzenie nagłówka raportu ......................................................................................................609 Rozdział 21. Raporty w Accessie — techniki zaawansowane ....................... 613 Grupowanie i sortowanie danych ......................................................................................................614 Alfabetyczne grupowanie danych ...............................................................................................614 Grupowanie według przedziałów czasowych .............................................................................619 Ukrywanie powtarzających się informacji ..................................................................................620 Ukrycie nagłówka strony ............................................................................................................623 Nowa numeracja strony dla każdej grupy ...................................................................................624
Spis treści
17
Formatowanie danych .......................................................................................................................624 Tworzenie list numerowanych ....................................................................................................625 Dodawanie znaków wypunktowania ..........................................................................................628 Dodawanie wyróżnienia w czasie wykonywania programu .......................................................630 Unikanie pustych raportów .........................................................................................................632 Dodawanie linii pionowych pomiędzy kolumnami ....................................................................633 Dodawanie pustego wiersza co n rekordów ................................................................................634 Drukowanie stron nieparzystych i parzystych ............................................................................636 Używanie różnych formatów w tym samym polu tekstowym ....................................................638 Centrowanie tytułu .....................................................................................................................639 Łatwe wyrównywanie etykiet formantów ..................................................................................639 Precyzyjne przemieszczanie formantów .....................................................................................639 Dodawanie danych ............................................................................................................................640 Dodawanie innych informacji do raportu ...................................................................................640 Dodanie nazwiska użytkownika do raportu związanego ............................................................640 Inne techniki .....................................................................................................................................642 Wyświetlanie wszystkich raportów w polu kombi .....................................................................642 Szybkie drukowanie danych z kwerendy ....................................................................................643 Używanie dwóch i więcej kolumn w raporcie ............................................................................644 Wykorzystanie dwuprzebiegowego przetwarzania raportów ......................................................650 Przypisywanie unikatowych nazw do formantów .......................................................................652
Część VI. Podstawy programowania w Accessie ....................... 653 Rozdział 22. Korzystanie z makr programu Access ....................................... 655 Wprowadzenie do makr ....................................................................................................................656 Tworzenie makr ..........................................................................................................................656 Przypisanie makra do zdarzenia .................................................................................................658 Makra a bezpieczeństwo ...................................................................................................................659 Centrum zaufania ........................................................................................................................662 Makra z wieloma akcjami .................................................................................................................663 Podmakra ..........................................................................................................................................666 Korzystanie z warunków ..................................................................................................................670 Otwieranie raportów za pomocą warunków ...............................................................................670 Wiele akcji w warunku ...............................................................................................................672 Korzystanie ze zmiennych tymczasowych ........................................................................................673 Rozszerzanie utworzonego makra ..............................................................................................673 Upraszczanie makr za pomocą zmiennych tymczasowych .........................................................675 Korzystanie ze zmiennych tymczasowych w kodzie VBA .........................................................677 Obsługa błędów i debugowanie makr ...............................................................................................678 Akcja PrzyBłędzie ......................................................................................................................679 Obiekt MacroError .....................................................................................................................681 Debugowanie makr .....................................................................................................................682 Makra osadzone ................................................................................................................................683 Makra kontra kod VBA ....................................................................................................................685 Makra czy VBA? ........................................................................................................................686 Konwersja istniejących makr na kod VBA .................................................................................687
18
Access 2013 PL. Biblia Rozdział 23. Podstawy programowania w języku VBA ................................. 689 Wprowadzenie do języka Visual Basic for Applications ..................................................................690 Terminologia związana z językiem VBA .........................................................................................691 Wprowadzenie do pisania kodu w języku VBA ...............................................................................692 Tworzenie programów w języku VBA .............................................................................................693 Moduły i procedury ....................................................................................................................694 Korzystanie z okna kodu ............................................................................................................700 Konstrukcje sterujące języka VBA ...................................................................................................705 Instrukcje warunkowe .................................................................................................................705 Pętle ............................................................................................................................................711 Obiekty i kolekcje .............................................................................................................................714 Wprowadzenie do obiektów .......................................................................................................714 Metody i właściwości .................................................................................................................715 Instrukcja With ...........................................................................................................................716 Instrukcja For Each .....................................................................................................................718 Przegląd edytora VBE ......................................................................................................................719 Okno Immediate .........................................................................................................................719 Project Explorer ..........................................................................................................................720 Object Browser ...........................................................................................................................721 Opcje edytora VBE .....................................................................................................................722 Rozdział 24. Typy danych i procedury w języku VBA .................................... 727 Zmienne ............................................................................................................................................728 Nazewnictwo zmiennych ............................................................................................................729 Deklarowanie zmiennych ...........................................................................................................730 Typy danych .....................................................................................................................................735 Porównanie niejawnego i jawnego deklarowania zmiennych .....................................................737 Wymuszanie jawnego deklarowania zmiennych ........................................................................738 Stosowanie konwencji nazewniczej ............................................................................................739 Zasięg i czas życia zmiennych ....................................................................................................741 Stosowanie stałych .....................................................................................................................745 Stosowanie tablic ........................................................................................................................747 Procedury Sub i funkcje ....................................................................................................................753 Gdzie można utworzyć procedurę? .............................................................................................755 Wywoływanie procedur w języku VBA .....................................................................................755 Tworzenie procedur Sub .............................................................................................................756 Tworzenie funkcji .............................................................................................................................759 Obsługa przekazywanych parametrów .......................................................................................760 Wywoływanie funkcji i przekazywanie parametrów ..................................................................761 Tworzenie funkcji wyznaczającej kwotę podatku ......................................................................762 Upraszczanie kodu za pomocą argumentów identyfikowanych przez nazwę ...................................765 Rozdział 25. Model zdarzeń ............................................................................ 767 Programowanie zdarzeń ....................................................................................................................768 W jaki sposób zdarzenia uruchamiają kod VBA? .......................................................................769 Tworzenie procedur zdarzeń .......................................................................................................770 Często używane zdarzenia ................................................................................................................771 Procedury zdarzeń formularza ....................................................................................................772 Procedury obsługi zdarzeń formantów .......................................................................................775
Spis treści
19
Procedury zdarzeń związane z raportami ...................................................................................777 Procedury zdarzeń dotyczących sekcji raportów ........................................................................778 Kolejność zdarzeń .............................................................................................................................780 Często występujące sekwencje zdarzeń ......................................................................................780 Pisanie prostych procedur obsługi zdarzeń formularzy i formantów ..........................................782 Rozdział 26. Debugowanie aplikacji Accessa ................................................. 789 Porządkowanie kodu VBA ...............................................................................................................790 Testowanie aplikacji .........................................................................................................................791 Testowanie funkcji .....................................................................................................................792 Kompilowanie kodu VBA ..........................................................................................................795 Tradycyjne techniki debugowania ....................................................................................................797 Używanie instrukcji MsgBox .....................................................................................................797 Korzystanie z instrukcji Debug.Print ..........................................................................................798 Korzystanie z mechanizmów debugowania Accessa ........................................................................801 Uruchamianie kodu w oknie Immediate .....................................................................................801 Wstrzymywanie wykonywania kodu z wykorzystaniem pułapek ...............................................802 Podgląd zmiennych w oknie Locals ...........................................................................................807 Ustawianie czujek w oknie Watches ..........................................................................................808 Czujki warunkowe ......................................................................................................................810 Używanie stosu wywołań ...........................................................................................................811 Przechwytywanie błędów w kodzie ..................................................................................................812 Na czym polega przechwytywanie błędów? ...............................................................................812 Obiekt Err ...................................................................................................................................815 Dodawanie obsługi błędów do procedur .....................................................................................815
Część VII. Zaawansowane techniki programowania w Accessie ................................................................... 817 Rozdział 27. Dostęp do danych za pomocą kodu VBA ................................... 819 Praca z danymi ..................................................................................................................................819 Wprowadzenie do obiektów ADO ....................................................................................................823 Obiekt Connection w ADO ........................................................................................................824 Obiekt Command w ADO ..........................................................................................................827 Obiekt Recordset w ADO ...........................................................................................................829 Obiekty DAO ....................................................................................................................................835 Obiekt DBEngine w DAO ..........................................................................................................836 Obiekt Workspace w DAO .........................................................................................................836 Obiekt Database w DAO ............................................................................................................837 Obiekt TableDef w DAO ............................................................................................................837 Obiekty typu QueryDef w DAO .................................................................................................839 Obiekty typu Recordset w DAO .................................................................................................840 Obiekty typu Field (ze zbiorów rekordów) w DAO ...................................................................841 Pisanie kodu VBA do aktualizowania tabeli .....................................................................................843 Aktualizacja pól rekordu z zastosowaniem ADO .......................................................................844 Aktualizacja pola obliczeniowego w rekordzie ..........................................................................848 Wstawienie nowego rekordu ......................................................................................................853 Usuwanie rekordu .......................................................................................................................854 Usuwanie powiązanych rekordów znajdujących się w kilku tabelach ........................................855
20
Access 2013 PL. Biblia Rozdział 28. Zaawansowany dostęp do danych z wykorzystaniem kodu VBA ................................................... 859 Wyszukiwanie danych w formularzach za pomocą niezwiązanych pól kombi .................................860 Wykorzystanie metody FindRecord ...........................................................................................862 Wykorzystywanie zakładek ........................................................................................................863 Filtrowanie danych formularza .........................................................................................................866 Filtrowanie za pomocą kodu .......................................................................................................867 Wykorzystanie kwerend .............................................................................................................868 Rozdział 29. Integrowanie baz SQL Server i Access ....................................... 875 Wprowadzenie do serwera SQL Server Express ...............................................................................876 Typy danych w bazach SQL Server ..................................................................................................878 Instalowanie serwera SQL Server Express .......................................................................................881 Instalowanie silnika bazy danych ...............................................................................................882 Instalowanie przykładowej bazy danych ....................................................................................885 Wprowadzenie do narzędzia Management Studio ......................................................................887 Posługiwanie się wierszem poleceń ............................................................................................891 Podłączanie się do serwera SQL Server ............................................................................................893 Tworzenie źródła danych ............................................................................................................893 Łączenie serwera SQL Server z Accessem .................................................................................897 Używanie ADO do baz SQL Server ...........................................................................................899 Praca z obiektami serwera SQL Server .............................................................................................905 Używanie tabel z serwera SQL Server w Accessie ....................................................................905 Widoki ........................................................................................................................................910 Procedury składowane ................................................................................................................911 Wyzwalacze ................................................................................................................................913 Rozdział 30. Dostosowywanie wstążek ......................................................... 915 Hierarchia wstążki ............................................................................................................................916 Formanty dla wstążek .................................................................................................................916 Specjalne mechanizmy wstążki ..................................................................................................919 Modyfikowanie domyślnej wstążki ..................................................................................................921 Praca z paskiem narzędzi Szybki dostęp ...........................................................................................923 Tworzenie niestandardowych wstążek ..............................................................................................925 Proces tworzenia wstążki ............................................................................................................926 Korzystanie z wywołań zwrotnych w języku VBA ....................................................................926 Tworzenie niestandardowej wstążki .................................................................................................928 Krok 1.: Projektowanie wstążki i rozwijanie kodu w XML-u ....................................................928 Krok 2.: Pisanie procedur wywołań zwrotnych ..........................................................................930 Krok 3.: Tworzenie tabeli USysRibbons ....................................................................................931 Krok 4.: Dodawanie kodu w XML-u do tabeli USysRibbons ....................................................932 Krok 5.: Określenie niestandardowych właściwości wstążki użytkownika ................................933 Podstawowy XML-owy kod wstążki ................................................................................................934 Dodawanie formantów do wstążki ....................................................................................................937 Określanie atrybutu imageMso ...................................................................................................937 Formant etykiety .........................................................................................................................938 Przycisk ......................................................................................................................................939 Separator .....................................................................................................................................940 Pola wyboru ................................................................................................................................940
Spis treści
21
Formant Lista rozwijana .............................................................................................................941 Przycisk rozdzielenia ..................................................................................................................944 Wiązanie wstążek z formularzami i raportami ..................................................................................945 Całkowite usuwanie wstążek ............................................................................................................946 Rozdział 31. Dystrybucja aplikacji Accessa .................................................... 949 Definiowanie opcji bieżącej bazy danych .........................................................................................950 Opcje aplikacji ............................................................................................................................951 Opcje nawigacji ..........................................................................................................................955 Opcje wstążki i paska narzędzi ...................................................................................................956 Opcje autokorekty nazw .............................................................................................................957 Tworzenie aplikacji ..........................................................................................................................957 Budowanie aplikacji zgodnie ze specyfikacją ............................................................................958 Dokumentacja aplikacji ..............................................................................................................960 Testowanie aplikacji przed dystrybucją ......................................................................................961 Dopracowywanie aplikacji ...............................................................................................................963 Nadanie aplikacji spójnego wyglądu i wrażenia .........................................................................963 Dodawanie popularnych, profesjonalnych komponentów ..........................................................964 Ułatwienie uruchamiania aplikacji .............................................................................................973 Dodatkowa ochrona aplikacji ...........................................................................................................975 Przechwytywanie błędów wszystkich procedur języka Visual Basic .........................................975 Oddzielanie tabel od pozostałej części aplikacji .........................................................................979 Tworzenie formularzy odpornych na błędy ................................................................................979 Sprawdzanie poprawności danych wprowadzanych przez użytkownika ....................................980 Korzystanie z opcji /runtime .......................................................................................................980 Szyfrowanie i kodowanie bazy danych .......................................................................................982 Zabezpieczanie kodu Visual Basica ...........................................................................................983 Zabezpieczanie środowiska ..............................................................................................................986 Ustawianie opcji startowych w kodzie .......................................................................................986 Blokada omijania opcji startowych .............................................................................................987 Ustawianie wartości właściwości ...............................................................................................988 Pobieranie wartości właściwości ................................................................................................989
Część VIII. Access i Windows SharePoint Services ...................... 991 Rozdział 32. Wprowadzenie do programu Windows SharePoint Services .... 993 Wprowadzenie do SharePointa .........................................................................................................993 Przegląd typów witryn SharePointa ..................................................................................................994 Witryny SharePointa .........................................................................................................................995 Dokumenty SharePointa .............................................................................................................995 Listy SharePointa ........................................................................................................................996 Omówienie podstaw integrowania Accessa z SharePointem ............................................................997 Rozdział 33. Integrowanie Accessa z SharePointem ..................................... 999 Współużytkowanie danych Accessa z SharePointem .....................................................................1000 Dołączanie list SharePointa ......................................................................................................1000 Importowanie list SharePointa ..................................................................................................1003 Eksportowanie tabel Accessa do SharePointa ..........................................................................1004 Przenoszenie tabel Accessa do SharePointa .............................................................................1006 Korzystanie z szablonów SharePointa ............................................................................................1009
22
Access 2013 PL. Biblia Rozdział 34. Wprowadzenie do usług Access Services ................................ 1013 Aplikacje zarządzane ......................................................................................................................1013 Publikowanie w internecie za pomocą Accessa ..............................................................................1015 Dlaczego SharePoint? ...............................................................................................................1016 Wykorzystanie funkcji SharePointa ..........................................................................................1016 Usługi Access Services ...................................................................................................................1017 Ograniczenia aplikacji internetowych Accessa ...............................................................................1018 Limity w usługach Access Services ..........................................................................................1019 Limity w zakresie transakcji .....................................................................................................1019 Rozdział 35. Instalowanie aplikacji Accessa w SharePoincie ...................... 1023 Publikowanie niestandardowej aplikacji Accessa w SharePoincie .................................................1024 Przygotowywanie modelu danych Accessa ..............................................................................1024 Inicjowanie i konfigurowanie niestandardowej aplikacji sieciowej ..........................................1026 Uruchamianie aplikacji sieciowej i zarządzanie nią .................................................................1034 Rozdział 36. Makra danych ........................................................................... 1039 Wprowadzenie do makr danych ......................................................................................................1040 Zdarzenia tabel ...............................................................................................................................1041 Zdarzenia „przed” .....................................................................................................................1041 Zdarzenia „po” .........................................................................................................................1042 Używanie edytora makr do tworzenia makr danych .......................................................................1043 Posługiwanie się wykazem akcji ....................................................................................................1045 Przepływ sterowania w programie ............................................................................................1046 Bloki danych .............................................................................................................................1046 Akcje danych ............................................................................................................................1047 Tworzenie pierwszego makra danych .............................................................................................1049 Zarządzanie elementami makr ........................................................................................................1052 Zwijanie i rozwijanie elementów makr .....................................................................................1052 Przenoszenie elementów makr .................................................................................................1052 Zapisywanie makr w plikach XML ..........................................................................................1053 Ograniczenia makr danych .............................................................................................................1054
Dodatki ..................................................................................... 1057 Dodatek A. Specyfikacja Accessa 2013 ........................................................ 1059 Specyfikacje dotyczące baz danych Accessa ..................................................................................1060 Specyfikacja bazy danych Microsoft SQL Server Express .............................................................1063 Dodatek B. Optymalizowanie aplikacji Accessa .......................................... 1065 Ładowanie modułu na żądanie ........................................................................................................1066 Organizowanie modułów ..........................................................................................................1066 Przycinanie drzewa wywołań ...................................................................................................1066 Dystrybucja plików .accde ..............................................................................................................1068 Czym jest stan skompilowany? .......................................................................................................1070 Przekształcenie kodu aplikacji na postać skompilowaną ..........................................................1071 Utrata stanu skompilowanego ...................................................................................................1071
Spis treści
23
Poprawianie szybkości działania aplikacji ......................................................................................1072 Dostrajanie systemu ..................................................................................................................1073 Optymalne wykorzystanie tabel ...............................................................................................1073 Optymalne wykorzystanie kwerend ..........................................................................................1075 Optymalne wykorzystanie formularzy i raportów ....................................................................1076 Optymalne wykorzystanie modułów ........................................................................................1078 Zwiększenie wydajności działania w sieci ...............................................................................1083 Praca z dużymi bazami danych Accessa .........................................................................................1083 Jak zwiększa się rozmiar baz danych? ......................................................................................1084 Ograniczenie się do kompilowania i scalania może nie wystarczyć .........................................1084 Wprowadzanie małych zmian w dużych bazach danych ..........................................................1086 Dodatek C. Wydajność kwerend i uszkodzenia baz danych ....................... 1087 Optymalizowanie wydajności kwerend ..........................................................................................1087 Normalizowanie projektu bazy danych ....................................................................................1087 Stosowanie indeksów dla odpowiednich pól ............................................................................1088 Optymalizowanie kwerend przez ulepszenie ich projektu ........................................................1089 Regularne kompaktowanie i naprawianie bazy danych ............................................................1090 Radzenie sobie z uszkodzeniami baz danych ..................................................................................1090 Wykrywanie uszkodzonych baz danych ...................................................................................1091 Przywracanie uszkodzonej bazy danych ...................................................................................1092 Zapobieganie uszkodzeniom baz danych ..................................................................................1092 Dodatek D. Przegląd funkcji dla analityków danych .................................. 1095 Skorowidz ................................................................................................... 1127
24
Access 2013 PL. Biblia
O autorach Michael Alexander posiada certyfikat MCAD (ang. Microsoft Certified Application Developer) i jest autorem kilku książek poświęconych zaawansowanym analizom biznesowym z wykorzystaniem programów Microsoft Access i Microsoft Excel. Ma ponad 15 doświadczenia w zakresie doradztwa i tworzenia rozwiązań opartych na pakiecie Microsoft Office. Ponadto uzyskał tytuł Microsoft MVP za nieustający wkład w życie społeczności użytkowników Excela. W wolnym czasie prowadzi witrynę z bezpłatnymi samouczkami, http://www.datapigtechnologies.com, gdzie udostępnia wskazówki dotyczące Excela i Accessa. Dick Kusleika otrzymywał nagrodę Microsoft MVP przez 12 kolejnych lat, a z pakietem Microsoft Office pracuje od ponad 20 lat. Rozwija dla swoich klientów rozwiązania oparte na Accessie i Excelu, a także prowadzi w Stanach Zjednoczonych i Australii szkolenia dotyczące produktów z pakietu Office. Pisze też na popularnym blogu poświęconym Excelowi — http://www.dailydoseofexcel.com.
26
Access 2013 PL. Biblia
Wprowadzenie Witaj na stronach książki Access 2013 PL. Biblia — Twojego osobistego przewodnika po najbardziej rozbudowanym systemie zarządzania bazami danych. Jeśli sięgnąłeś po tę książkę, prawdopodobnie stwierdziłeś, że Microsoft Access pozwoli Ci zarządzać danymi w sposób, którego nie umożliwiają inne aplikacje. Nawet najpopularniejsza z nich, Microsoft Excel, nie oferuje możliwości dostępnych w Accessie. Porównywanie Accessa (systemu zarządzania bazami danych) do Excela (programu do obsługi arkuszy kalkulacyjnych) może się wydawać nieuzasadnione, jednak w wielu firmach Excela używa się do zarządzania dużymi ilościami danych i ich analizowania. Możliwe, że czytasz tę książkę, ponieważ chcesz się pozbyć ograniczeń związanych z Excelem. Poznanie Accessa to doskonały (a zdaniem wielu — logiczny) następny krok w rozwoju dla analityków, którzy muszą pracować z wciąż rosnącymi zbiorami danych. Access pozwala na bardzo wydajne zarządzanie dużymi zbiorami danych i nie ma wbudowanego ograniczenia liczby wierszy. Umożliwia też skuteczne zarządzanie relacjami między odrębnymi tabelami i oferuje narzędzia pomagające w pisaniu własnych aplikacji, które można udostępniać innym. Obecnie, gdy ilość danych jest większa niż kiedykolwiek wcześniej i rośnie zapotrzebowanie na zaawansowane analizy danych, doświadczeni analitycy muszą zacząć stosować dodatkowe narzędzia, aby nie pozostać na etapie „operatora arkusza kalkulacyjnego”. To dlatego niniejsza książka jest tak ważna przy rozwijaniu umiejętności zawodowych. Znajdziesz w niej nie tylko wprowadzenie do Accessa, ale też poznasz różne sposoby pozwalające wykorzystać ten program do usprawnienia zarządzania danymi i ich analizowania.
Czy ta książka jest przeznaczona dla Ciebie? Książka zawiera wszystko, co konieczne, aby poznać Accessa 2013 na średnim poziomie. Zaczynamy od podstaw, a w każdym kolejnym rozdziale opieramy się na wiedzy przedstawionej wcześniej. Książka ta ma umożliwić zdobycie nowych umiejętności użytkownikom na wszystkich poziomach zaawansowania (początkującym, średnio zaawansowanym, a nawet doświadczonym użytkownikom Accessa). Jeśli dopiero poznajesz Accessa, zacznij lekturę od
28
Access 2013 PL. Biblia
początku książki. Natomiast czytelnicy, którzy znają program i potrafią tworzyć w nim aplikacje, mogą od razu przejść do dalszych rozdziałów. Dla nowicjuszy w świecie zarządzania bazami danych ta książka jest wszystkim, czego potrzebują, aby rozpocząć pracę z Accessem 2013. Przedstawia też bardziej zaawansowane tematy w sposób ułatwiający naukę, a także stanowiąc swego rodzaju leksykon. Osoby początkujące powinny zwrócić szczególną uwagę na część I, w której opisaliśmy niezbędne umiejętności potrzebne do tworzenia skutecznych i wydajnych baz danych. Umiejętności projektanta baz danych podlegają nieustannej ocenie pod kątem wydajności tworzonych aplikacji oraz skuteczności obsługi danych powierzonych przez użytkowników. Jeśli korzystałeś z wcześniejszych wersji Accessa, jest to książka dla Ciebie. Możliwe, że znasz już mechanizmy Accessa, jednak w każdej nowej wersji zmieniają się nie tylko dostępne funkcje, ale też sposób wykonywania niektórych zadań. Ta książka pomoże Ci zapoznać się z wszystkimi wprowadzonymi zmianami. Jeżeli chcesz poznać podstawy programowania w języku VBA (ang. Visual Basic for Applications), znajdziesz tu wszystko, czego potrzebujesz. Wprawdzie język ten jest rozbudowany i zasługuje na odrębną książkę, tu zamieściliśmy pokaźny zestaw rozdziałów, które pozwolą Ci rozpocząć korzystanie z języka VBA do wzbogacania baz danych Accessa. W części VI znajdziesz omówienie różnych aspektów (w tym wielu szczegółów technicznych) pisania procedur VBA i tworzenia aplikacji Accessa na podstawie kodu dodanego do baz danych.
Konwencje stosowane w książce W niniejszej książce zastosowano następujące konwencje:
Kiedy przedstawiana jest kombinacja klawiszy (tzn. kiedy należy nacisnąć jeden klawisz i, nie puszczając go, nacisnąć inny), to poszczególne klawisze oddzielone są znakiem plusa (+). Na przykład Ctrl+Esc oznacza, że trzeba przytrzymać klawisz Ctrl, nacisnąć klawisz Esc, a następnie dopiero puścić obydwa klawisze.
Wskaż kursorem myszy oznacza, że trzeba tak przesunąć mysz, aby jej wskaźnik znajdował się nad określonym elementem. Kliknięcie oznacza pojedyncze naciśnięcie oraz zwolnienie lewego przycisku myszy. Podwójne kliknięcie to dwukrotne naciśnięcie i zwolnienie lewego przycisku myszy w krótkim odstępie czasu. Kliknięcie prawym przyciskiem myszy polega na naciśnięciu i zwolnieniu prawego przycisku myszy. Przeciąganie elementu to kliknięcie go lewym przyciskiem myszy oraz przesuwanie wskaźnika myszy przy stale przytrzymywanym przycisku.
Kursywą oznaczone są pojęcia nowe lub o szczególnym znaczeniu oraz nazwy różnych etykietek ekranowych.
Pogrubiona czcionka o stałej szerokości znaków
oznacza tekst, który należy
bezpośrednio wprowadzić do komputera. Czcionką o stałej szerokości znaków
ukazujące się na ekranie.
wydrukowane są kod i informacje
Wprowadzenie
29
Jak książka jest zorganizowana? Książka ta jest podzielona na dziewięć części:
Część I. Komponenty Accessa. Część I zapewnia solidne opanowanie podstawowych elementów baz danych oraz zawiera wyjaśnienie najważniejszych pojęć z zakresu zarządzania bazami danych, a także omówienie planowania tabel i pracy z typami danych Accessa. W tej części po raz pierwszy przyjrzysz się Accessowi i jego interfejsowi.
Część II. Tabele Accessa. W trakcie lektury części II zdobędziesz wiedzę potrzebną do tworzenia tabel Accessa, zarządzania relacjami między tabelami i łączenia się z różnymi źródłami danych (plikami Excela, plikami tekstowymi, bazami SQL Server i innymi bazami Accessa).
Część III. Kwerendy Accessa. W części III przedstawiliśmy wybrane podstawowe narzędzia analityczne dostępne w Accessie. Poznasz tu kreator kwerend, a także sposoby tworzenia prostych i zaawansowanych analiz tabel Accessa. Opisaliśmy też podstawy kwerend, kwerendy podsumowujące, kwerendy funkcjonalne i kwerendy krzyżowe.
Część IV. Analizowanie danych w Accessie. W części IV opisaliśmy wiele zaawansowanych technik, które pozwalają przenieść analizy danych na następny poziom. Dowiesz się tu, jak przekształcać dane za pomocą kwerend, jak przeprowadzać niestandardowe obliczenia i analizy warunkowe, jak tworzyć przydatne podzapytania, a także jak przeprowadzać analizy statystyczne dla kwerend.
Część V. Formularze i raporty Accessa. W części V skoncentrowaliśmy się na tworzeniu formularzy i raportów w Accessie. Dowiesz się, jak przekształcić dane w elegancki interfejs użytkownika i w raporty Accessa (przypominają one wyglądem pliki PDF). Poznasz też metody wzbogacania wyglądu i stylu aplikacji Accessa za pomocą zaawansowanych formantów formularzy.
Część VI. Podstawy programowania w Accessie. W części VI zrobisz następny krok i zajmiesz się programowaniem. W rozdziałach z tej części najpierw opisaliśmy makra Accessa, następnie podstawy języka VBA, a na końcu korzystanie z tego języka do usprawniania baz danych Accessa. Dzięki tej części lepiej zrozumiesz złożone modele (obiektowy i zdarzeń), na których oparte są aplikacje Accessa, a także dowiesz się, jak tworzyć kod w języku VBA potrzebny do wykorzystania możliwości bogatego środowiska programowania.
Część VII. Zaawansowane techniki programowania w Accessie. W części VII omówiliśmy automatyzację i integrację. Dowiesz się tu, jak wzbogacić mechanizmy tworzenia raportów przez wykorzystanie innych programów i platform. Rozdziały z tej części nie tylko pozwolą Ci zdobyć podstawowe umiejętności potrzebne do sprawnego posługiwania się językiem VBA, ale też pomogą odkryć wiele zaawansowanych sztuczek, które możesz wykorzystać w rozwijanych aplikacjach Accessa. Poznasz tu też wiele zaawansowanych technik, np. modyfikowanie wstążki Accessa 2013.
30
Access 2013 PL. Biblia
Część VIII. Access i Windows SharePoint Services. W części VIII przedstawiliśmy usługi Microsoft Windows SharePoint. Poznasz tu rozbudowane możliwości z zakresu integrowania usług Microsoft SharePoint z Accessem. Pozwalają one na publikowanie tabel, formularzy i raportów Accessa w witrynach SharePointa. Choć obiekty Accessa publikowane w platformie SharePoint nie dają aż tylu możliwości co same aplikacje Accessa, umożliwiają udostępnianie danych Accessa zdalnym użytkownikom.
Dodatki. Znajdują się w nich przydatne dodatkowe materiały, które pomogą Ci w codziennej pracy z Accessem. W dodatku A znajdziesz dokumentację Accessa 2013. Poznasz tu maksymalną i minimalną wielkość baz danych oraz wiele formantów Accessa. W dodatku B przedstawiliśmy pomysły na poprawę szybkości i wydajności aplikacji Accessa. Z dodatku C dowiesz się, jak uniknąć uszkodzenia danych podczas korzystania z baz Accessa i jak radzić sobie z tym problemem. Dodatek D zawiera szczegółowy opis wielu wbudowanych funkcji Accessa dostępnych analitykom danych.
Jak korzystać z tej książki? Choć każdy rozdział jest integralną częścią całej książki, stanowi też niezależną całość i powiązane są z nim odrębne przykładowe pliki, które można pobrać z poświęconej książce witryny. Książkę tę możesz czytać w dowolnej kolejności, przeskakując między poszczególnymi rozdziałami lub zagadnieniami. Wyjątkowo rozbudowany indeks pozwoli Ci znaleźć miejsca, w których opisane jest interesujące Cię zagadnienie.
Zawartość witryny Zaprezentowane w książce przykłady znajdziesz w poświęconej książce witrynie — http://www.wiley.com/go/access2013bible. Spolszczona wersja przykładów znajduje się w witrynie wydawnictwa Helion (ftp://ftp.helion.pl/przyklady/ac13bi.zip). Dodatkowa pomoc na temat Accessa W trakcie eksperymentowania z nowymi funkcjami i narzędziami poznawanymi w tej książce czasem możesz potrzebować wskazówek. Pierwszym ich źródłem jest system pomocy Accessa. Nie jest on jednak doskonały. Dla początkujących użytkowników może wyglądać jak niewygodny dodatek, który zwraca onieśmielającą listę zagadnień zupełnie niepowiązanych z szukanym tematem. Prawda jest jednak taka, że gdy nauczysz się skutecznie posługiwać systemem pomocy Accessa, będzie to jeden z najszybszych i najłatwiejszych w użyciu sposobów na uzyskanie dodatkowych informacji.
Poniżej znajdziesz kilka porad, które pomogą Ci optymalnie wykorzystać system pomocy Accessa:
Przy szukaniu pomocy lokalizacja ma znaczenie. Być może pamiętasz, że system pomocy w starszych wersjach Accessa był dużo bardziej przyjazny i skuteczny niż w nowych edycjach. To nie złudzenie. Microsoft znacznie zmienił działanie systemu pomocy Accessa.
Wprowadzenie
31
W Accessie 2013 działają dwa systemy pomocy. Jeden dotyczy funkcji Accessa, a drugi zagadnień związanych z programowaniem w języku VBA. Zamiast przeprowadzać globalne wyszukiwanie na podstawie podanych kryteriów Access szuka informacji tylko w systemie powiązanym z bieżącą lokalizacją użytkownika. Dlatego jeśli potrzebujesz pomocy z zakresu programowania w VBA, wpisz zapytanie w edytorze VBA. Jeżeli natomiast chcesz się dowiedzieć więcej na temat budowania kwerend, najlepiej poszukać informacji w projektancie kwerend. Dzięki temu uzyskasz pewność, że wyszukiwanie będzie przeprowadzane w odpowiednim systemie pomocy.
Pomoc z internetu jest lepsza od tej z komputera. Gdy szukasz pomocy na dany temat, Access sprawdza, czy komputer jest podłączony do internetu. Jeśli jest, Access zwraca informacje na podstawie bieżącej zawartości witryny Microsoftu. Jeżeli połączenie jest niedostępne, używane są pliki pomocy przechowywane lokalnie razem z pakietem Microsoft Office. Jednym ze sposobów na uzyskanie optymalnej pomocy jest wykorzystanie jej internetowej wersji. Pomoc z internetu jest zwykle lepsza od tej z komputera, ponieważ zawiera bardziej szczegółowe i zaktualizowane informacje, a także odnośniki do innych, niedostępnych w komputerze zasobów.
Rozwijaj swoją wiedzę na podstawie zasobów internetowych. Zapoznaj się z kilkoma witrynami i forami poświęconymi Accessowi. Znajdziesz tam dodatkową pomoc z zakresu podstaw Accessa, a także wskazówki i sztuczki dotyczące konkretnych sytuacji. Poniższa lista witryn to dobry punkt wyjścia:
Witryny te są bezpłatne, a ponadto wyjątkowo pomocne, gdy potrzebujesz dodatkowych wskazówek.
32
Access 2013 PL. Biblia
Część I
Komponenty Accessa W tej części:
Rozdział 1. Wprowadzenie do projektowania baz danych
Rozdział 2. Wprowadzenie do Accessa
Każda część niniejszej książki bazuje na częściach poprzednich, a rozdziały w każdej części zawierają przykłady wykorzystujące techniki opisane w poprzednich częściach i rozdziałach. Czytelnicy, tworząc swoje aplikacje, mogą korzystać z umiejętności, które zdobyli, czytając poszczególne rozdziały tej książki i wykonując zamieszczone w niej ćwiczenia. Każdy jednak, kto postanawia poznać nową dziedzinę, musi od czegoś zacząć. W części I niniejszej książki zaprezentowaliśmy podstawowe umiejętności, które powinien poznać każdy, kto chce osiągnąć sukces w projektowaniu baz danych w Accessie. Tematy omówione w tej części pozwalają zrozumieć zagadnienia i techniki niezbędne do efektywnego korzystania ze środowiska bazodanowego oraz zdobyć umiejętności potrzebne do normalizowania danych, a także planowania i tworzenia wydajnych tabel. Jeśli znasz już zagadnienia z obszaru projektowania baz danych, możesz pominąć rozdziały z tej części. Jeżeli jednak dopiero poznajesz świat baz danych, poświęć czas na staranne zapoznanie się z przedstawionymi tu ważnymi tematami.
34
Część I Komponenty Accessa
Rozdział 1.
Wprowadzenie do projektowania baz danych W tym rozdziale:
Różnice między bazami danych, tabelami, rekordami, polami i wartościami
Dlaczego w bazie danych wykorzystywanych jest wiele tabel
Omówienie obiektów baz danych
Projektowanie systemu bazy danych
Projektowanie baz danych znacząco się różni od innych dziedzin zastosowań komputerów. W odróżnieniu od takich programów jak Microsoft Word lub Excel, których używanie jest stosunkowo intuicyjne, projektowanie baz danych wymaga odpowiedniej wiedzy. Użytkownik musi poznać szereg podstawowych informacji, w tym terminologię dotyczącą baz danych, główne zagadnienia związane z bazami i najlepsze praktyki z tego obszaru. W tym rozdziale opisaliśmy podstawy projektowania baz danych. Aby rozpocząć od razu pracę z Accessem, przejdź bezpośrednio do rozdziału 2.
Terminologia związana z bazami danych występująca w Accessie W Accessie stosuje się (w większości miejsc, choć nie wszędzie) tradycyjną terminologię baz danych. Pojęcia baza danych, tabela, rekord, pole i wartość uporządkowane są od najszerszego do najbardziej szczegółowego. Takie same pojęcia występują niemal we wszystkich systemach baz danych.
36
część 1 ł Komponenty Accessa
Bazy danych Baza danych jest pojęciem informatycznym oznaczającym zbiór informacji dotyczących określonego tematu czy zastosowania biznesowego. Bazy danych ułatwiają logiczne zorganizowanie powiązanych ze sobą informacji i oferują do nich łatwy dostęp. Uwaga
W niektórych starszych systemach baz danych terminu tego używano do opisania indywidualnych tabel. Obecnie terminem baza danych opisuje się wszystkie elementy systemu.
Bazy danych nie są przeznaczone wyłącznie dla komputerów. Istnieją również tzw. fi zyczne bazy danych, określane także jako ręczne ,..,ystemy kartotekowe. Systemy tego typu składają się zwykle z ludzi, dokumentów papierowych, teczek oraz szafek - kluczowym elementem fizycznej bazy danych jest papier. W istniejących fizycznych bazach danych można zazwyczaj wyróżnić pojemniki wejściowo-wyjściowe oraz określoną formalną metodę ich wypełniania. Informację najczęściej pobiera się w � tępujący sposób: należy papieru. Jako wejście otworzyć szafkę, wyjąć teczkę i odnaleźć w niej odpowiedni wykorzystywane są papierowe formularze wypełniane na pr ł d za pomocą klawiatuty Infotmację można odnaleźć ręcznie, smtując papiety ZQPt �ąc żądane dane z wielu dokumentów papierowych na jeden (lub nawet do rowego arkusza kalkulacyj sposób dane lub wyświetlić je nego w Excelu). Aby przeanalizować otrzym � w określony sposób, można posłużyć się kalkul �m lub arkuszem kalkulacyjnym.
�
��
�� k� "!'�
� �;� �� �
Baza danych Accessa jest niczym inny -, utomatyzowaną wersją funkcji składo wania i odczytywania informacji z pap temu kartotekowego. W bazach danych Accessa informacje są zapisane z w zystaniem dokładnie zdefiniowanej struktury. e w różnorodnej postaci - od zwykłego tekstu W tabelach Accessa dane są za ormatów, takich jak i ustracje,_ d więki czy klipy (np. nazwis_ka i a esy) do zło wtdeo. Zaptsywante dan c w�cyzyJnym, znanym fotmacie umożhwta systemom zaa�e Management System - DBMS) takim jak Access przerządzania danych (ang. tne informacje. kształcanie danych ' rium danych w bazach danych ccess� są tab�le._ D_ostęp do da Podstawowyml... nych można c za pomocą kwerend, formularzy 1 raportow. Dz1ęk1 mm użytkow nicy mogą wprowadzać i odczytywać dane oraz przedstawiać je w użyteczny sposób. Większość projektantów w formularzach i raportach używa makr lub kodu w języku Visual Basic for Applications (VBA). Dzięki temu używanie ich aplikacji staje się łatwiejsze.
�
�
� ���
�
�
�
�
� � �
�
W systemie zarządzania relacyjnymi bazami danych (ang. Relational Database Mana gement System- RDBMS), takim jak Access, dane przechowuje się w wielu powiązanych ze sobą tabelach. Na przykład tabela z danymi o pracownikach (zawierająca nazwiska i adresy) może być powiązana z tabelą danych opisujących listę płac (data wypłaty, kwota i numer czeku). Dzięki kwerendom użytkownicy mogą zadawać złożone pytania o dane umieszczone w powiązanych tabelach (np. "Ile wynosi suma wszystkich wypłat zrealizowanych dla Jana Kowalskiego w roku 20 12?"). Odpowiedzi można wyświetlić w formularzach na ekranie lub wydrukować w postaci raportów.
Rozdział
1.
ł Wprowadzenie do projektowania baz danych
37
Jedną z podstawowych różnic między relacyjną bazą danych a papierowym systemem kartotekowym jest możliwość przechowywania w relacyjnej bazie danych informacji o pojedynczej osobie czy też o pojedynczym towarze w kilku tabelach. N a przykład w systemie bazy danych o pacjentach takie dane, jak nazwisko pacjenta, jego adres czy inne dane kontaktowe, zwykle są gromadzone w innej tabeli niż informacje o leczeniu. Przeważnie w osobnej tabeli są przechowywane informacje o leczeniu wszystkich pacjen tów, a identyfikator pacjenta (standardowo jego numer) służy do wyszukania w niej da nych o leczeniu określonej osoby.
Baza danych w Accessie jest ogólnym "opakowaniem" na wszystkie dane oraz związane
z nimi obiekty. Nie jest to tylko zestaw tabel - baza danych mieści w sobie obiekty wielu typów, takie jak kwerendy, fotmularze, raporty, makra i moduły kodu.
Po otwarciu bazy danych Accessa można zacząć pracę z obiektami tej bazy (tabelami, kwerendami itd.). Można jednocześnie otworzyć wiele kopii Accessa i w razie potrzeby pracować w danym momencie z więcej niż jedną bazą danyc
�
�
Wiele baz danych Accessa zawiera setki, a nawet tysiące !, formularzy, kwerend, obiekty w bazie danych raportów, makr i modułów. Poza kilkoma wyjątk Accessa są zapisane w pojedynczym pliku z rozsz .accdb, .accde, .mdb, .mde lub .adp.
��zy� ��)i.h
'>s.-'{)-
Tabele
� � � �y ć2}�·
Tabela jest po prostu opakowaniem na w naturalnej postaci - odpowiednikiem owych. Każda tabela w bazie danych Accessa teczki w papierowych systemach k zawiera informacje opisujące o podmiot, np. osobę lub produkt, a dane są zor ganizowane w postaci wierszy
�
�DO� � relacyjnych baz
� �
W rozdziałach 3. i 4. � ztwlmy się z bardzo istotnymi regułami rządzącymi projektem an z ze sposobami ich wykorzystania w bazach danych Accessa. Wymienione regu wsKazówki zapewniają działanie aplikacji z najwyższą wydajnością, a jednocześni niają ochronę danych zapisanych w tabelach.
tern jest tabela. W czasie projektowania i tworzenia baz danych Ac W Accessie cessa, a nawet w trakcie korzystania z istniejącej aplikacji trzeba uwzględnić to, w jaki sposób tabele i inne obiekty bazy reprezentują fizyczne jednostki, któtymi baza ma za rządzać, a także jak poszczególne elementy są ze sobą powiązane.
�
Po utworzeniu tabeli można przeglądać zapisane w niej dane w postaci podobnej do ar kusza kalkulacyjnego - w tzw. widoku arkusza danych, który składa się z wierszy i ko lumn (nazywanych odpowiednio rekordami i polami; więcej informacji na ten temat można znaleźć w podrozdziale "Rekordy i pola"). Chociaż widok arkusza danych w ba zie danych wygląda podobnie do arkusza kalkulacyjnego, to jednak te dwa typy obiektów znacząco się od siebie różnią. Widok arkusza danych w Accessie został szczegółowo opisany w rozdziale 5. Dokładnie �DO� � omówiono w nim również różnice między arkuszami kalkulacyjnymi a widokiem arkusza danych. Więcej informacji na temat pól i ich właściwości można znaleźć w rozdziale 3.
38
część 1 ł Komponenty Accessa
Rekordy i pola Arkusz danych jest podzielony na wiersze zwane rekordami i na kolumny zwane polami, gdzie pierwszy wiersz (nagłówki wszystkich kolumn) zawiera nazwy pól w bazie danych. Każdy wiersz reprezentuje pojedynczy rekord zawierający pola charaktetyzujące re kord. W systemach fizycznych wiersze można porównać do pojedynczych fotmularzy (kartek papieru), natomiast pola do pustych pól formularza, których zawartość wypełnia stę samemu. Każde kolumna to pole zawierające wiele właściwości opisujących typ danych, które są w nim zapisane, oraz sposób, w jaki Access obsługuje dane w tym polu. Właściwości te obejmują nazwę pola (Company) i typ danych (Krótk4 tekst). Dla pola można określić także inne właściwości. Na przykład właściwość Rozm4 ar pol a Address definiuje w Ac cessie liczbę znaków, z jakiej może się składać adres.
""' � � �
W kontekście Accessa termin pole oznacza atrybut rekordu: .wielu innych systemach ia pole używa się baz danych, w tym także w systemie SQL Server, zami � n terminologia w pewnym pojęcia kolumna. Pola i kolumny oznaczają to samo Uż sensie zależy od kontekstu systemu bazy danych ra� j tabelę z określonym rekordem. "\...
Uwaga
-
�� �
�� \/S-� �?z� �
wartosci
Na przecięciu wiersza (rekordu) i kolumnv znajduje się wartość- właściwy ele a firmy reprezentuje pojedynczą war ment danych. Na przykład w polu Comp tość danych. Dane w tabelach Acces zorganizowane zgodnie z pewnymi regułami.
�
oa::=>
�
Opis tych reguł znajdziesz w
łach 3. i 4.
�·
Relacyjne ba� anych � �
Access jest s;: em projektowania relacyjnych baz danych. Dane Accessa są zapisane w powiązany sobą tabelach - dane z jednej tabeli (np. infmmacje o klientach) są powiązane z danymi z innej tabeli (np. informacje o zamówieniach). Access obsługuje relacje pomiędzy powiązanymi ze sobą tabelami. Dzięki nim można z łatwością uzyskać informacje o kliencie i wszystkich jego zamówieniach bez utraty jakichkolwiek danych oraz bez konieczności przeglądania rekordów, które nie dotyczą wybranego klienta. Większa liczba tabel upraszcza wprowadzanie danych i ich przeglądanie, ponieważ zmniejsza ilość niepotrzebnie powielanych informacji. Na przykład definiując dwie ta bele dla aplikacji obsługującej klientów, nie trzeba za każdym razem, gdy klient coś kupi, wpisywać od nowa jego nazwiska i adresu. Po utworzeniu tabel trzeba je ze sobą powiązać. Jeżeli na przykład w bazie danych jest tabela klientów i tabela transakcji, należy te tabele powiązać ze sobą na podstawie wspólnego pola. Tu w obu tabelach można umieścić pole z identyfikatorem klienta. Po zwala to pobrać z tabeli transakcji dane dla osoby, której identyfikator pasuje do identy fikatora z tabeli klientów.
Rozdział
1.
ł Wprowadzenie do projektowania baz danych
39
Dlaczego należy tworzyć wiele tabel? Perspektywa tworzenia wielu tabel zawsze przeraża początkujących użytkowników baz danych. Zazwyczaj chcą oni utworzyć tylko jedną dużą tabelę zawierającą wszystkie informacje - w na szym przypadku byłaby to tabela klientów zawierająca także informacje na temat wszystkich do konanych przez nich transakcji oraz inne informacje, w tym również nazwisko czy adres klienta. Zwłaszcza użytkownikom Excela wydaje się sensowne, by zastosować takie samo podejście do tworzenia tabel w Accessie. Zarządzanie pojedynczą tabelą szybko stanie się problematyczne. Przy każdej nowej transakcji dokonywanej przez klienta trzeba wpisywać wszystkie dotyczące go informacje (wielokrotnie powta rzając w każdym wierszu jego nazwisko i adres). To samo dotyczy elementów wchodzących w skład każdej transakcji, gdy w skład jednej transakcji wchodzi więcej elementów niż jeden. System staje się mało wydajny i podatny na pomyłki przy wprowadzaniu danych. Informacje w tabeli są prze chowywane w sposób bardzo nieefektywny, wiele pól bowiem nie ma zastosowania dla wszystkich rekordów i pozostają one puste. Bardzo ważną rzeczą jest utworzenie takich tabel, w których będzie zapisana minimalna ilość in formacji, a które zapewnią łatwe posługiwanie się systemem i umożlb, .jego rozwój. Aby osią gnąć ten cel, należy stworzyć więcej niż jedną tabelę, przy czym każd a l powinna zawierać utworzeniu tych tabel, rekordy z polami opisującymi wyłącznie podmiot tabeli. Nast ni , acji. Chociaż brzmi to h iif można je ze sobą powiązać, co umożliwi pobieranie z nich użyte JS unkowo prosta. bardzo skomplikowanie, praktyczna realizacja tych zagadnień
� � � �
��
'"
��-��
Zaletą tego modelu jest to, że nie trzeba e ych dotyczących klienta (np. na zwiska, ulicy, miasta, województwa, odu wego) za każdym razem, gdy do tabeli transakcji dodawany jest nowy rekord. W st zy podać identyfikator klienta. Gdy zmieni 1kować go tylko w jednym rekordzie tabeli się adres danego klienta, wystarczy klientów.
� �
Rozdzielenie danych w bazie iele tabel ułatwia zarządzanie systemem, ponieważ wszystkie rekordy okreś g� typu znajdą się w jednej tabeli. Poświęcając czas na po prawne dzielenie dany ędzy tabele, oszczędzimy go znacznie więcej przy póź niejszym projektow..i.[l u oraz pracy z systemem. Proces dzielenia danych pomiędzy ta bele nosi nazw
!2..._� � \
�
oa::=>
Więcej in
���zacji. �
ji na temat normalizacji można znaleźć w rozdziale 4.
Obiekty baz danych Accessa Osoby, dla których bazy danych są nowością (a nawet te, które są doświadczonymi użytkownikami baz danych), powinny przed rozpoczęciem korzystania z programu za poznać się z kilkoma pojęciami specyficznymi dla Accessa. Baza danych Accessa za wiera sześć rodzajów obiektów, na które składają się dane oraz narzędzia potrzebne do korzystania z niego: ł ł
Formularze- umożliwiają wprowadzanie i wyświetlanie danych w zdefiniowanym wcześniej formacie.
ł
Raporty- umożliwiają wyświetlanie i drukowanie sfmmatowanych danych.
ł
Makra- umożliwiają automatyzację pewnych działań bez konieczności
programowania. ł
Moduły- zawierają programy w języku VBA (ang. Visual Basic for Applications).
Arkusze danych Arkusze danych to jeden z wielu sposobów umożliwiających przeglądanie danych w Ac cessie.Chociaż nie są obiektami bazy danych, wyświetlają listę rekordów z tabeli w forma cie podobnym do arkusza kalkulacyjnego Excela (w wierszach i kolumnach). Dane te są pobierane z tabeli w swojej pierwotnej postaci- bez przekształceń i bez filtrowania. Jest to domyślny tryb wyświetlania wszystkich pól dla wszystkich �ordów. Po arkuszu można się pomszać za pomocą klawiszy strzał�"\tawiaturze. W widoku arkusza danych mo�na �ak że wyświetlić powiązane �or� innych tabel . Ponadto _ można modyfikowac wysw1etlone dane.
� Kwerendy '\>s,'(>Kwerendy służą do pobierania informacji �t,;danych, umożliwiając wybranie i zde
=
finiowanie gmpy rekordów spełniając�'JC:dane warunki. Na kwerendach bazuje większość fotmularzy i raport · w. Ie �iem jest łączenie, filtrowanie i sortowanie danych przed wyświetleniem. K ęsto wywołuje się z poziomu makr bądź procedur języka VBA w celu modyfikow ., dawania lub usuwania rekordów w bazie danych.
�
Przykładem wykorzyst�i\ k�erendy jest sytua�ja, gdy ktoś z pracowników . działu sprzedaży wyda polec�1e danych: Pokaż rm posortowanych alfabetyczrue według " nazwiska wszystkic��ientów z Wrocławia, którzy kupili coś w ostatnich sześciu mie siącach" lub wszystkich klientów, którzy w ciągu ostatnich sześciu miesięcy kupili modele�chodu Chevrolet,. posortowanych według nazwiska i daty transakcji".
"=.L�\�
W takim przypadku, zamiast zadać pytanie w języku polskim czy angielskim, wykorzy stuje się metodę QBE (ang.Query by Example - zapytanie przez przykład).Po wpisaniu instrukcji w projektancie kwerend i ich uruchomieniu kwerenda przekształca polecenia na język SQL (ang. Struciured Query Language), a następnie pobiera określone dane.
�
oa::=>
Okno projektanta kwerend i proces tworzenia kwerend opisano w rozdziale 8.
Formularze do wprowadzania danych i ich wyświetlania Formularze do wprowadzania danych pomagają użytkownikom szybko, łatwo i popraw nie wprowadzać infmmacje do bazy danych.Umożliwiają prezentację danych w sposób bardziej strukturalny niż w przypadku użycia arkusza danych.Z poziomu tego struktu ralnego widoku rekordy można przeglądać, dodawać, modyfikować bądź usuwać. Fannu larze są najbardziej popularnym sposobem wprowadzania danych do tabeli bazy.
Rozdział 1. Wprowadzenie do projektowania baz danych
41
Formularze można wykorzystać do ograniczenia dostępu do niektórych pól w tabeli. Do formularzy można też dodać reguły sprawdzania poprawności lub kod w języku VBA, który sprawdza poprawność danych przed zapisaniem ich w tabeli bazy. Większość użytkowników woli wpisywać informacje do formularzy niż do arkuszy danych. Formularze można utworzyć w taki sposób, że będą przypominały dokumenty papierowe. Dzięki temu wprowadzanie danych jest łatwiejsze. Dzięki formularzom wprowadzanie danych jest też proste do zrozumienia — użytkownik po kolei wypełnia wszystkie pola występujące w odpowiedniej tabeli. Formularze i ekrany tylko do wyświetlania służą do przeglądania informacji. Za ich pomocą można wybiórczo wyświetlić niektóre pola z określonej tabeli. Oznacza to, że ograniczają dostęp użytkowników do pewnych danych, udostępniając im jednocześnie pozostałe.
Raporty Raporty prezentują dane w postaci przeznaczonej do drukowania. Access zapewnia bardzo dużą swobodę w zakresie tworzenia raportów. Można na przykład wyświetlić listę wszystkich rekordów z danej tabeli (np. z tabeli klientów) lub listę tylko tych rekordów, które spełniają określone warunki (np. wszystkich klientów z województwa pomorskiego). Taki efekt uzyskuje się poprzez wykorzystanie odpowiedniej kwerendy jako źródła danych raportu. Kwerenda ta wybiera dane wykorzystywane w raporcie. W raportach można łączyć dane pochodzące z wielu tabel i w ten sposób prezentować złożone zależności pomiędzy różnymi zbiorami danych. Przykładem może być drukowanie faktury. Z tabeli klientów pobiera się wtedy nazwisko i adres (ewentualnie wraz z dodatkowymi informacjami), a z tabeli transakcji dane dotyczące konkretnej sprzedaży w celu wyświetlenia poszczególnych pozycji faktury. Raport umożliwia także obliczenie potrzebnych sum i wydrukowanie ich w określonym formacie. Dodatkowo za pomocą Accessa można umieścić rekordy w raporcie z fakturą — drukowanym dokumencie z podsumowaniem informacji na temat faktury. Podczas projektowania tabel bazy danych należy uwzględnić wszystkie informacje, które w przyszłości będzie trzeba drukować. Dzięki temu ma się pewność, że w tabelach znajdują się dane potrzebne do utworzenia różnych raportów.
Obiekty bazy danych Aby utworzyć obiekty bazy danych, takie jak tabele, formularze czy raporty, najpierw należy wykonać szereg zadań projektowych. Im lepszy projekt, tym lepsza aplikacja, która na nim bazuje. Im więcej czasu programista poświęci na etapie projektowania, tym szybciej uda mu się stworzyć cały system. Projekt nie jest złem koniecznym i nie służy także do produkowania tomów dokumentacji. Jedynym celem zaprojektowania obiektu jest stworzenie jednoznacznej charakterystyki, na podstawie której można go później zaimplementować.
42
Część I Komponenty Accessa
Pięcioetapowa metoda projektowania Pięć etapów projektowania wraz z systemem bazy danych opisanych w tym podrozdziale zapewnia doskonałe podstawy do tworzenia aplikacji baz danych — w tym tabel, kwerend, formularzy, raportów, makr i prostych modułów VBA. Ilość czasu, jaką należy poświęcić na każdy etap, w całości zależy od uwarunkowań tworzonej bazy danych. Na przykład czasami użytkownik prezentuje przykład raportu, jaki ma drukować baza danych Accessa, a źródła danych są tak oczywiste, że zaprojektowanie raportu zajmuje kilka minut. Innym razem, kiedy wymagania użytkowników są szczególnie złożone lub procesy biznesowe obsługiwane przez aplikację wymagają gruntownych badań, realizacja pierwszego etapu może zająć wiele dni. Czytając opisy poszczególnych etapów procesu projektowania, zawsze należy analizować projekt pod kątem danych wyjściowych i wejściowych.
Krok 1.: Ogólny projekt systemu — od koncepcji do rzeczywistości Wszyscy twórcy oprogramowania mają wiele podobnych problemów. Pierwszym z nich jest określenie sposobu zaspokojenia oczekiwań użytkowników systemu. Przed przejściem do szczegółów bardzo ważne jest zrozumienie wszystkich ogólnych wymagań użytkownika stawianych systemowi. Użytkownicy mogą zażądać bazy danych, która obsługuje następujące zadania:
Wprowadzanie informacji o klientach (nazwisko, adres, historia finansowa) i zarządzanie tymi informacjami.
Wprowadzanie informacji o dokonanych transakcjach (data sprzedaży, metoda płatności, kwota brutto, identyfikator nabywcy i inne pola) i zarządzanie tymi informacjami.
Wprowadzanie informacji dotyczących poszczególnych pozycji transakcji (szczegóły sprzedawanych produktów) i zarządzanie tymi informacjami.
Przeglądanie informacji pochodzących z wszystkich tabel (transakcji, klientów, poszczególnych pozycji transakcji i informacji o płatnościach).
Zadawanie wszelkiego rodzaju pytań na temat informacji zawartych w bazie danych.
Tworzenie miesięcznego raportu sprzedaży.
Tworzenie historii sprzedaży dla poszczególnych klientów.
Tworzenie etykiet adresowych i raportów korespondencyjnych.
Powyższe osiem zadań opisali przyszli użytkownicy systemu. W trakcie projektowania może się również pojawić potrzeba uwzględnienia innych zadań. Przed przejściem do projektowania należy się dowiedzieć, jak działają istniejące procesy. Oznacza to, że trzeba przeprowadzić analizę wymagań systemu i określić, w jaki sposób można go zautomatyzować.
Rozdział 1. Wprowadzenie do projektowania baz danych
43
Jednym ze sposobów zapoznania się z systemem jest przygotowanie serii pytań. Odpowiedzi na te pytania powinny przybliżyć procesy biznesowe klienta i sposób wykorzystania przez niego danych. Na przykład podejmując próbę zautomatyzowania działalności dowolnej firmy, można posłużyć się następującymi pytaniami:
Jakie raporty i formularze były dotychczas używane?
Jak dotychczas były przechowywane informacje o transakcjach, klientach i inne dane?
W jaki sposób były wystawiane rachunki?
Tego typu pytania sprawią, że klient prawdopodobnie przypomni sobie jeszcze o innych rzeczach związanych z prowadzoną przez niego działalnością, o których powinien wiedzieć projektant systemu. Aby w pełni poczuć sposób działania firmy, należy dokładnie przeanalizować przebieg wykorzystywanych procesów. Najlepiej wybrać się do niej kilka razy i zaobserwować przebieg różnych procedur i metody pracy pracowników. Po zakończeniu przygotowań do następnych etapów nie należy zrywać kontaktu z klientem — należy go na bieżąco informować o wykonanych czynnościach, pytać o kolejne szczegóły, sprawdzać, czy wykonywane działania spełniają jego wymagania.
Krok 2.: Projektowanie raportów Chociaż rozpoczynanie od raportów może się wydawać dziwne, w wielu przypadkach użytkownicy są bardziej zainteresowani wydrukami z bazy danych niż wszelkimi innymi elementami aplikacji. Raporty bardzo często zawierają niemal wszystkie dane zarządzane przez aplikację. Ponieważ raporty zwykle są obszerne, często są najlepszym sposobem zbierania informacji dotyczących wymagań dla bazy danych. Podczas analizy raportów tworzonych w tym kroku nasuwa się pytanie: „Co było pierwsze: jajko czy kura?”. Czy najpierw należy opracować układ raportu, czy też wcześniej należy zdecydować o elementach danych i etykietach tekstowych, które go tworzą? W rzeczywistości te dwa elementy są analizowane w tym samym czasie. Sposób rozmieszczenia pól w raporcie nie jest zbyt ważny. Jednak im więcej czasu poświęcimy teraz, tym łatwiej będzie nam skonstruować raport. Niektórzy są tak dokładni, że posługują się liniami siatki podczas projektowania raportu. Dzięki temu dokładnie znają lokalizację wszystkich danych.
Krok 3.: Projektowanie danych Następnym etapem procesu projektowania jest zgromadzenie informacji na temat wszystkich danych, które są konieczne do utworzenia żądanych raportów. Jedną z najlepszych metod jest wypisanie wszystkich elementów znajdujących się na poszczególnych raportach. W przypadku podjęcia decyzji o takim sposobie należy zwracać uwagę na elementy znajdujące się na więcej niż jednym raporcie. Trzeba pamiętać, aby nadać im te same nazwy, w rzeczywistości bowiem są to te same elementy Rozpoczniemy od danych dotyczących klienta — wypiszemy je w taki sposób, w jaki przedstawiono je w tabeli 1.1.
44
Część I Komponenty Accessa
Tabela 1.1. Dane związane z klientem występujące w raportach Raporty klientów
Raport faktur
Imię i nazwisko klienta
Imię i nazwisko klienta
Ulica
Ulica
Miasto
Miasto
Województwo
Województwo
Kod pocztowy
Kod pocztowy
Numery telefonów
Numery telefonów
Adres e-mail Strona internetowa Rabat Data zostania klientem Data ostatniej transakcji Stawka podatkowa dla transakcji Informacja na temat kredytu (4 pola)
Jak widać z porównania informacji związanych z klientem występujących w poszczególnych raportach, istnieje wiele pól wspólnych. Większość danych dotyczących klienta znajduje się w obydwóch raportach. Tabela 1.1 zawiera tylko niektóre pola występujące w każdym raporcie — te, które odnoszą się do klienta. Ponieważ nazwy pól występujących w odpowiadających sobie wierszach są takie same, łatwo można sprawdzić, czy uwzględniono wszystkie elementy. Chociaż możliwość łatwego zlokalizowania elementów w przypadku tak małej bazy nie ma kluczowego znaczenia, to w przypadku dużych baz, zawierających wiele pól, staje się bardzo ważna. Po wyodrębnieniu informacji dotyczących klienta można przejść do danych związanych z transakcjami. W tym przypadku trzeba przeanalizować jedynie raport faktur i określić elementy dotyczące transakcji. Pola raportu zawierające informacje dotyczące transakcji zamieszczono w tabeli 1.2. Przeglądając informacje związane z transakcjami konieczne do utworzenia raportu, można zauważyć, że pewne elementy (pola) się powtarzają (np. Zakupiony produkt, Liczba sztuk i Cena produktu). Każda faktura może zawierać wiele pozycji, a każda pozycja wymaga informacji tego samego typu — o zamówionej liczbie i cenie za sztukę. Każda faktura może też zawierać więcej niż jedną sztukę danego towaru. Podobnie na każdej fakturze mogą występować informacje dotyczące częściowych płatności. Istnieje prawdopodobieństwo, że będą się one także składały z kilku pozycji — te powtarzające się elementy można połączyć w osobną grupę. Wszystkie informacje dotyczące pojedynczych produktów występujące w grupie informacji związanych z transakcjami wspomnianej w poprzednim punkcie można wyodrębnić i utworzyć dla nich nową grupę. Informacje związane z poszczególnymi elementami transakcji zamieszczono w tabeli 1.2.
Rozdział 1. Wprowadzenie do projektowania baz danych
45
Tabela 1.2. Dane związane z transakcjami występujące w raportach Raport faktur
Liczba sztuk (wiele pozycji) Opis zakupionego produktu (wiele pozycji) Cena produktu (wiele pozycji) Rabat dla produktu (wiele pozycji) Typ wpłaty (wiele pozycji) Data wpłaty (wiele pozycji) Kwota wpłaty (wiele pozycji) Numer karty kredytowej (wiele pozycji) Data ważności (wiele pozycji)
Krok 4.: Projektowanie tabel Teraz najtrudniejsza część: trzeba określić pola w tabelach, na podstawie których będą generowane raporty. Po przeanalizowaniu wielu pól i obliczeń potrzebnych do utworzenia żądanych dokumentów można wywnioskować, że poszczególne pola raportów powinny pochodzić z różnych tabel w bazie danych (dużą część wstępnych czynności wykonaliśmy już wcześniej, łącząc pola w logiczne grupy). Na razie uwzględnimy wszystkie wyodrębnione pola. Później (z różnych powodów) być może będzie trzeba dodać inne pola. Będą też takie pola raportu, które nie pojawią się w żadnej tabeli. Należy pamiętać, że uwzględnianie w tabelach bazy danych wszystkich, nawet najmniejszych szczegółów nie jest konieczne. Na przykład może się zdarzyć, że użytkownik zażąda umieszczenia w bazie danych informacji o urlopach i innych dniach wolnych w celu łatwego wyszukiwania informacji o tym, którzy pracownicy są dostępni określonego dnia. Łatwo może jednak dojść do zaciemnienia ogólnego projektu aplikacji z powodu uwzględnienia zbyt wielu wątków podczas wstępnej fazy projektowania. Ponieważ tabele Accessa można z łatwością modyfikować w dowolnym momencie, najlepszą strategią jest odłożenie mniej ważnych elementów na późniejsze etapy projektowania —
46
Część I Komponenty Accessa
do czasu, kiedy wstępny projekt będzie gotowy. Ogólnie rzecz biorąc, uwzględnienie żądań użytkowników po zakończeniu fazy projektowania bazy danych nie jest szczególnie trudne. Po wyodrębnieniu danych ze wszystkich raportów należy je scalić według funkcji, które pełnią (czyli na przykład podzielić na logiczne grupy), a następnie porównać dane w ramach poszczególnych funkcji. W tym celu najpierw należy sięgnąć do informacji związanych z klientami i połączyć wszystkie występujące tam pola w jeden zbiór elementów danych. Następnie to samo należy wykonać dla informacji dotyczących transakcji oraz informacji dotyczących pojedynczej pozycji transakcji. Zestawienie elementów danych pochodzących z tych trzech grup informacji zamieszczono w tabeli 1.3. Tabela 1.3. Porównanie elementów danych Dane klientów
Dane faktur
Dane pojedynczej pozycji faktury
Nazwa firmy klienta
Numer faktury
Zakupiony produkt
Ulica
Data sprzedaży
Liczba sztuk
Miasto
Data wystawienia faktury
Opis zakupionego produktu
Województwo
Sposób płatności
Cena produktu
Kod pocztowy
Rabat (ogólny dla transakcji)
Rabat dla produktu
Numery telefonów (2 pola)
Stawka podatkowa
Opodatkowany?
Adres e-mail
Typ wpłaty (wiele pozycji)
Strona internetowa
Data wpłaty (wiele pozycji)
Rabat Data zostania klientem
Kwota wpłaty (wiele pozycji)
Data ostatniej transakcji
Numer karty kredytowej (wiele pozycji)
Stawka podatkowa dla transakcji
Data ważności (wiele pozycji)
Informacja na temat kredytu (4 pola)
Scalenie i porównanie danych jest dobrym sposobem na rozpoczęcie tworzenia indywidualnych definicji tabel, ale do zrobienia pozostało jeszcze wiele. Kiedy Czytelnik lepiej zapozna się z procesem projektowania danych, dowie się, że informacje w kolumnie dotyczącej klientów należy rozbić na dwie osobne kolumny. Niektóre elementy w niej zawarte są używane wobec każdego klienta tylko raz, dla innych może istnieć więcej wpisów. Przykładem może być kolumna transakcji — informacje o wpłatach mogą składać się z kilku pozycji. Rozbicie tego rodzaju informacji na osobne kolumny jest konieczne, w ten sposób bowiem wszystkie powiązane ze sobą typy elementów znajdą się w osobnych kolumnach — jest to przykład normalizacji będącej częścią procesu projektowania. Na przykład jeden klient może mieć wiele kontaktów z firmą. Jeden klient może również dokonać wielu operacji płatności związanych z jedną transakcją. Wcześniej rozbiliśmy dane na trzy kategorie: klientów, faktury i pojedyncze pozycje faktury.
Rozdział 1. Wprowadzenie do projektowania baz danych
47
Należy także pamiętać o tym, że dla jednego klienta można wystawić wiele faktur, z których każda może zawierać wiele pozycji. Kategoria faktury reprezentuje informacje na temat poszczególnych transakcji, natomiast kategoria pozycji transakcji to dane dotyczące pojedynczej pozycji na fakturze. Należy zwrócić uwagę, że wszystkie te trzy kolumny są ze sobą powiązane — na przykład jednemu klientowi można wystawić wiele faktur, a każda faktura może zawierać wiele pozycji szczegółowych. Relacje między tabelami mogą być różne. Na przykład każdej fakturze sprzedaży odpowiada jeden i tylko jeden klient, natomiast z jednym klientem może być związanych wiele transakcji. Podobna relacja zachodzi między fakturą a zawartymi na niej pozycjami. Zdefiniowanie relacji w bazie danych wymaga istnienia niepowtarzalnego identyfikatora w obu tabelach. Unikatowy identyfikator w każdej tabeli pozwala silnikowi bazy danych prawidłowo łączyć i wyodrębniać powiązane ze sobą dane. W naszym projekcie tylko tabela transakcji zawiera unikatowy identyfikator (numer faktury). Oznacza to, że trzeba do każdej z nich dodać co najmniej jedno pole, które będzie pełniło rolę łącza potrzebnego do zdefiniowania relacji z innymi tabelami. Na przykład można dodać pole identyfikatora klienta do tabeli klientów, następnie dodać to samo pole w tabeli faktur i w ten sposób zdefiniować relację między tabelami za pomocą pola z identyfikatorem klienta. Silnik bazy danych wykorzystuje relację między tabelami klientów i faktur do powiązania informacji między klientami a wystawionymi dla nich fakturami. Relacje między tabelami są realizowane dzięki kluczom. Więcej informacji na temat relacji i procesu normalizacji można znaleźć w rozdziale 4.
Rozumiejąc potrzebę łączenia między sobą grup danych, można dodać do każdej grupy wymagane pola kluczowe. Dwie nowe grupy pól i pola łączące umieszczone w każdej z nich zamieszczono w tabeli 1.4. Pola te, nazywane kluczami głównymi i kluczami obcymi, służą do łączenia tabel ze sobą. Tabela 1.4. Tabele wraz z kluczami Dane klientów
Dane faktur
Dane pozycji faktur
Dane płatności faktur
ID klienta
ID faktury
ID faktury
ID faktury
Nazwa klienta
ID klienta
Numer pozycji
Typ płatności
Ulica
Numer faktury
Zakupiony produkt
Data płatności
Miasto
Data sprzedaży
Liczba sztuk
Kwota wpłaty
Województwo
Data wystawienia faktury
Opis zakupionego produktu
Numer karty kredytowej
Kod pocztowy
Sposób płatności
Cena produktu
Data ważności
Numery telefonów (2 pola)
Przedstawiciel
Rabat dla produktu
Adres e-mail
Stawka podatkowa
Strona WWW Rabat Data zostania klientem Data ostatniej transakcji Stawka podatkowa dla transakcji
48
Część I Komponenty Accessa
Pole, które w unikatowy sposób identyfikuje każdy wiersz w tabeli, to tzw. klucz główny. Odpowiadające mu pole w powiązanej tabeli nazywa się kluczem obcym. W naszym przykładzie pole identyfikatora klienta w tabeli klientów jest kluczem głównym, natomiast pole identyfikator klienta w tabeli faktur to klucz obcy. Załóżmy, że określony rekord z tabeli klientów ma wartość 12 w polu identyfikatora klienta. Wszystkie rekordy w tabeli faktur z wartością 12 w polu identyfikator klienta dotyczą klienta o identyfikatorze 12. Po umieszczeniu pól łączących we wszystkich tabelach można w każdej tabeli znaleźć pole, za pomocą którego można połączyć tabelę z innymi tabelami w bazie danych. Na przykład w tabeli 1.4 pole identyfikator klienta występuje zarówno w tabeli klientów (gdzie jest kluczem głównym), jak i w tabeli faktur (gdzie jest kluczem obcym). Właśnie zidentyfikowaliśmy zasadniczą część trzech podstawowych tabel systemu — przedstawiono go w trzech pierwszych kolumnach w tabeli 1.4. Jest to pierwszy szkic ostatecznego projektu tabel. Utworzyliśmy także dodatkową tabelę przeznaczoną do przechowywania danych o wpłatach za transakcje. Zazwyczaj szczegółów dotyczących wpłat (np. numeru karty kredytowej) nie można znaleźć na fakturze. Poświęcenie czasu na poprawne zaprojektowanie bazy danych i tabel w niej zawartych jest, w opinii wielu osób, najważniejszym etapem konstruowania aplikacji opartej na bazie danych. Efektywne zaprojektowanie bazy danych umożliwia precyzyjne kontrolowanie danych — eliminuje kosztowne pomyłki przy wprowadzaniu danych i ogranicza ich wpisywanie tylko do niezbędnych pól. Chociaż niniejsza książka nie jest poświęcona teorii baz danych i wszystkich niuansów z nią związanych, to niezbędne wydaje się przedstawienie w niej pokrótce sztuki normalizacji bazy danych. Szczegółowe informacje na temat normalizacji można znaleźć w rozdziale 4. Na razie wystarczy, jeśli powiemy, że normalizacja jest procesem przydziału danych do poszczególnych tabel. We wcześniejszej części tego rozdziału wspomniałem o tym, że wiele osób używających Accessa umieszcza niezwiązane ze sobą informacje, na przykład dane dotyczące klientów, faktury i pozycji sprzedaży, w jednej, rozbudowanej tabeli. Rozbudowana tabela zawierająca dane różnego rodzaju szybko staje się trudna do zarządzania i aktualizacji. Ponieważ numer telefonu klienta występuje w każdym wierszu zawierającym dane tego klienta, zmiana numeru telefonu wymaga wprowadzenia modyfikacji w wielu miejscach.
Krok 5.: Projektowanie formularzy Po utworzeniu danych i określeniu relacji między tabelami przyszedł czas na zaprojektowanie formularzy. Formularze składają się z pól, poprzez które można wprowadzać dane lub które je wyświetlają w trybie edycji. Jeżeli to możliwe, formularze wyświetlane na ekranie powinny przypominać formularze funkcjonujące w systemie fizycznym.
Rozdział 1. Wprowadzenie do projektowania baz danych
49
Podczas projektowania formularzy na ekranie należy rozmieścić na nim trzy rodzaje pól:
Etykiety i pola tekstowe do wprowadzania danych (pola w formularzach i raportach Accessa zwykle nazywa się kontrolkami lub formantami).
Formanty specjalne (wielowierszowe pola tekstowe, przyciski opcji, pola list, pola wyboru, wykresy i obrazy).
Obiekty graficzne poprawiające wygląd ekranu (kolory, linie, prostokąty i efekty trójwymiarowe).
Idealna sytuacja występuje w przypadku, gdy formularz jest tworzony na podstawie istniejącego, wydrukowanego dokumentu — formularz Accessa powinien przypominać jego wersję papierową. Jego pola powinny wtedy znaleźć się mniej więcej w tych samych miejscach co na wersji papierowej. Etykiety służą do wyświetlania komunikatów, tytułów i podpisów. Pola tekstowe udostępniają miejsce, w którym można wpisywać (lub w którym są wyświetlane) tekst lub liczby zawarte w bazie danych. Pola wyboru wskazują na jakiś warunek i mogą być zaznaczone lub niezaznaczone. Inne typy formantów dostępnych w Accessie to między innymi pola list, pola kombi, przyciski opcji, przyciski przełączników i grupy opcji. Szczegółowe omówienie tworzenia formularzy znajdziesz w rozdziale 17. i dalszych rozdziałach.
50
Część I Komponenty Accessa
Rozdział 2.
Wprowadzenie do Accessa W tym rozdziale:
Ekran powitalny
Tworzenie bazy danych od podstaw
Otwieranie nowej bazy danych
Zapoznanie z interfejsem
W tym rozdziale poznasz główne komponenty interfejsu użytkownika. Nawet jeśli jesteś doświadczonym użytkownikiem Accessa, możesz się zdziwić, jak bardzo różni się interfejs wersji 2013 od wcześniejszych edycji tego programu.
Ekran powitalny Gdy otworzysz Accessa 2013 w systemie Windows (Start/Programy/Access 2013), zobaczysz domyślny ekran powitalny widoczny na rysunku 2.1. Ekran ten udostępnia kilka sposobów na otwarcie istniejącej bazy danych Accessa lub utworzenie nowej bazy. Jeśli otwierasz bazę danych bezpośrednio za pomocą Eksploratora Windows (klikając bazę dwukrotnie), nie zobaczysz ekranu powitalnego. Zamiast tego przejdziesz bezpośrednio do omówionego w dalszej części rozdziału interfejsu bazy danych.
W lewym górnym rogu ekranu powitalnego znajduje się sekcja Ostatnie. Wymienione w niej pliki to bazy danych otwierane wcześniej w Accessie 2013. Możesz kliknąć dowolny z tych plików, aby go otworzyć. Access w trakcie zapełniania sekcji Ostatnie nie odróżnia istniejących baz danych od usuniętych. Oznacza to, że baza może się pojawić w tej sekcji, nawet jeśli została usunięta. Gdy klikniesz taką bazę, pojawi się komunikat o błędzie z informacją, że Access nie może znaleźć bazy.
52
Część I Komponenty Accessa
Rysunek 2.1. Ekran powitalny Accessa umożliwia rozpoczęcie pracy z tym programem na kilka sposobów
Pod sekcją Ostatnie znajduje się pozycja Otwórz inne pliki. Należy ją kliknąć, aby móc przeglądać i otwierać bazy danych z komputera lub sieci. W górnej części ekranu powitalnego można wyszukiwać szablony baz danych Accessa w internecie. Szablony te to zwykle wyjściowe bazy danych o różnym przeznaczeniu. Microsoft udostępnia je bezpłatnie. W środkowej części ekranu powitalnego widoczne są różne szablony wbudowane. Można je kliknąć, aby je pobrać i zacząć ich używać. Microsoft utworzył internetowe repozytorium szablonów, aby umożliwić użytkownikom pobieranie niepełnych lub kompletnych aplikacji Accessa. Szablonowe bazy danych dotyczą wielu częstych sytuacji biznesowych. Pozwalają na przykład na zarządzanie stanem magazynu lub transakcjami. Warto poświęcić chwilę na zapoznanie się z tymi szablonami, jednak nie omawiamy ich w tej książce. Środkowa część ekranu powitalnego zawiera też dwa polecenia — Niestandardowa aplikacja sieci Web i Pusta baza danych dla komputerów stacjonarnych. Te dwie opcje umożliwiają utworzenie bazy danych od podstaw. Jeśli chcesz zbudować nową bazę Accessa przeznaczoną do użytku na komputerach PC (Twoich lub należących do
Rozdział 2. Wprowadzenie do Accessa
53
klientów), wybierz opcję Pusta baza danych dla komputerów stacjonarnych. Jeżeli zamierzasz opublikować aplikację Accessa za pomocą SharePointa, wybierz opcję Niestandardowa aplikacja sieci Web. Omówienie tworzenia niestandardowych aplikacji sieciowych znajdziesz w części VIII tej książki.
Tworzenie pustej bazy danych dla komputerów stacjonarnych Aby utworzyć nową pustą bazę danych, należy kliknąć opcję Pusta baza danych dla komputerów stacjonarnych na ekranie powitalnym (zobacz rysunek 2.1). Pojawi się wtedy okno dialogowe widoczne na rysunku 2.2. Można w nim określić nazwę i lokalizację bazy. Rysunek 2.2. Wprowadź nazwę nowej bazy w polu Nazwa pliku
Domyślną lokalizacją nowych baz danych jest katalog Dokumenty. Jeśli chcesz zapisywać bazy w innym miejscu, kliknij przycisk przeglądania (przypomina wyglądem katalog z Eksploratora Windows) na prawo od pola Nazwa pliku, aby przejść do odpowiedniej lokalizacji.
Po utworzeniu nowej bazy danych Access automatycznie ją otworzy. Na rysunku 2.3 zwróć uwagę na to, że Access otwiera nową bazę danych z pustą tabelą, dla której można określić nazwy pól i inne aspekty projektu.
Rysunek 2.3. Nowa baza danych po utworzeniu
54
Część I Komponenty Accessa
Formaty plików Accessa Od Accessa 2007 domyślnym formatem plików baz danych Accessa jest .accdb, który zastąpił format .mdb. Warto poświęcić czas na zrozumienie, dlaczego wprowadzono tę zmianę i jak wpływa ona na korzystanie ze starszych plików baz danych w Accessie 2013. W Accessie od początku używano aparatu bazy danych Jet (ang. Joint Engine Technology). W wersji 2007 zespół pracujący nad Accessem chciał dodać kilka nowych mechanizmów, np. pola zawierające różne wartości i pola załączników. Ponieważ nowe funkcje były zaawansowane, nie udało się dodać do aparatu Jet kodu potrzebnego do ich obsługi. Dlatego Microsoft opracował zupełnie nowy aparat bazy danych, a mianowicie ACE (ang. Access Connectivity Engine). Access 2013 obsługuje kilka formatów plików włącznie z następującymi:
.accdb z Accessa 2007 – 2013,
.mdb z Accessa 2002 – 2003,
.mdb z Accessa 2000,
.mdb z Accessa 97.
We wcześniejszych wersjach Accessa (starszych niż 2007) nie można otwierać ani dołączać plików w nowym formacie .accdb. Ponadto format .accdb nie obsługuje replikacji ani zabezpieczeń na poziomie użytkownika. Jeśli musisz używać bazy danych z Accessa 2013 we wcześniejszych wersjach tej aplikacji lub potrzebujesz replikacji albo zabezpieczeń na poziomie użytkownika, zastosuj format .mdb. Format .accdb można wykorzystać w środowisku programu Access jedynie wtedy, gdy wszyscy użytkownicy wykorzystują program Access 2007 lub jego nowszą wersję. Jednak w mieszanym środowisku użytkowników programów Access w wersjach starszych i nowszych niż 2007, w celu zachowania zgodności, należy pozostać przy formacie pliku Access 2002 – 2003. Ta sama zasada dotyczy zgodności z Accessem 2000 — w środowisku użytkowników z wersją 2000 należy pozostać przy formacie bazy danych Accessa 2000. W wersji 2013 można otwierać pliki .mdb z programów Access 2002 – 2003 i 2000 oraz wprowadzać w nich potrzebne zmiany, przy czym dostępne są tylko funkcje z owych wersji. Niektóre nowe mechanizmy Accessa są niedostępne (dotyczy to przede wszystkim funkcji z aparatu ACE). Pliki .mdb z Accessa 97 można otworzyć, a nawet uruchomić, jednak nie można modyfikować ich projektu. Aby przekształcić bazę danych zapisaną w starszym formacie, należy otworzyć ją w Accessie 2013, wybrać opcję Plik/Zapisz jako, a następnie w oknie dialogowym Zapisz jako wskazać odpowiedni format plików Accessa.
Interfejs Accessa 2013 Po utworzeniu lub otwarciu nowej bazy danych ekran Accessa wygląda podobnie jak na rysunku 2.4. W górnej części ekranu znajduje się wstążka, dodana w Accessie 2007. Po lewej stronie widoczne jest okienko nawigacji. Te dwa elementy stanowią podstawę interfejsu Accessa. Oprócz nich dostępny jest pasek szybkiego dostępu, na którym można umieścić najczęściej używane polecenia.
Rozdział 2. Wprowadzenie do Accessa
55
Rysunek 2.4. Podstawą interfejsu Accessa jest wstążka (w górnej części okna) i okienko nawigacji (po lewej stronie)
Okienko nawigacji Okienko nawigacji wyświetlające się z lewej strony ekranu jest podstawowym narzędziem do poruszania się podczas pracy z Accessem. W okienku nawigacji wyświetlają się kwerendy, formularze, raporty i obiekty Accessa innych typów. Mogą się w nim wyświetlać także kombinacje różnych typów obiektów. Aby wyświetlić dostępne opcje, kliknij listę rozwijaną na pasku tytułu okienka nawigacji (zobacz rysunek 2.5). Rysunek 2.5. Wybór alternatywnego sposobu wyświetlania okienka nawigacji
Opcje nawigacji są podzielone na dwie sekcje — Przejdź do kategorii i Filtruj według grup. Najpierw należy wybrać opcję z listy Przejdź do kategorii, a następnie opcję w sekcji Filtruj według grup. Opcje dostępne w sekcji Filtruj według grup zależą od opcji wybranej na liście Przejdź do kategorii. Dalej znajdziesz opis każdej opcji z sekcji Przejdź do kategorii i powiązanych opcji z sekcji Filtruj według grup.
56
Część I Komponenty Accessa
Dostępne są następujące opcje nawigacji: Niestandardowe Jej wybór powoduje utworzenie nowej zakładki w okienku nawigacji. Zakładka ta domyślnie nosi nazwę Grupa niestandardowa 1 i zawiera obiekty, które użytkownik przeciągnie do obszaru zakładki. Elementy dodane do niestandardowej grupy w dalszym ciągu wyświetlają się w widoku odpowiednim dla ich typu obiektu zgodnie z opisem zamieszczonym poniżej. Po wybraniu opcji Niestandardowe sekcja Filtruj według grupy jest zapełniana wszystkimi utworzonymi wcześniej niestandardowymi grupami. Pozwala to przefiltrować obiekty na podstawie dodanych niestandardowych grup. Niestandardowe grupy to doskonały sposób grupowania obiektów niejednorodnego typu (np. tabel, kwerend i formularzy) powiązanych ze sobą funkcjonalnie. Można na przykład stworzyć niestandardową grupę Klienci i dodać do niej wszystkie obiekty bazy danych powiązane z działaniami klientów. Elementy dodane do niestandardowej grupy mogą się wyświetlać także w innych grupach.
Typ obiektu Opcja ta jest najbardziej podobna do opcji z poprzednich wersji Accessa. Po jej wybraniu w sekcji Filtruj według grupy pojawiają się następujące opcje:
Tabele,
Kwerendy,
Formularze,
Raporty,
Wszystkie obiekty programu Access.
Domyślnie w okienku nawigacji widoczne są wszystkie obiekty z bieżącej bazy danych. Wybierz opcję Wszystkie obiekty programu Access, jeśli wcześniej ustawiłeś jeden z filtrów, a teraz chcesz zobaczyć wszystkie obiekty z bazy. Tabele i powiązane widoki Opcja ta wymaga pewnego komentarza. W Accessie poczyniono starania, aby projektant był informowany o ukrytych połączeniach między obiektami w bazie danych. Na przykład określona tabela może być wykorzystywana w wielu kwerendach, formularzach lub raportach. W poprzednich wersjach Accessa związki te były bardzo trudne do określenia i nie było skutecznego narzędzia wbudowanego w Accessie, które pomagałoby w zrozumieniu tych relacji. Opcja Tabele i powiązane widoki pozwala zrozumieć, które obiekty są powiązane z poszczególnymi tabelami. Po wybraniu opcji Tabele i powiązane widoki sekcja Filtruj według grupy jest zapełniana obiektami bazy danych. Gdy klikniesz jeden z tych obiektów, na liście pozostanie on sam oraz obiekty zależne od niego i nadrzędne.
Rozdział 2. Wprowadzenie do Accessa
57
Data utworzenia Ta opcja grupuje obiekty bazy danych według daty utworzenia. Ustawienie to przydaje się w przypadku, gdy chcemy się dowiedzieć, kiedy obiekt utworzono. Po wybraniu opcji Data utworzenia w sekcji Filtruj według grupy pojawiają się następujące opcje:
Dzisiaj,
Wczoraj,
W ostatnim tygodniu,
Dwa tygodnie temu,
Starsze.
Data modyfikacji Ta opcja grupuje obiekty bazy danych według daty modyfikacji. Ustawienie to przydaje się w przypadku, gdy chcemy się dowiedzieć, kiedy obiekt po raz ostatni zmodyfikowano. Po wybraniu opcji Data modyfikacji w sekcji Filtruj według grupy pojawiają się następujące opcje:
Dzisiaj,
Wczoraj,
W ostatnim tygodniu,
Dwa tygodnie temu,
Starsze.
Okna z zakładkami Osoby projektujące aplikacje we wcześniejszych wersjach Accessa bardzo często narzekały, że w przypadku otwarcia w środowisku Accessa wielu obiektów obiekty te nachodziły na siebie i przykrywały się wzajemnie, co utrudniało poruszanie się pomiędzy nimi. Microsoft wprowadził do interfejsu użytkownika Accessa zakładki, które zapobiegają przykrywaniu obiektu przez inne obiekty wyświetlające się w tym samym czasie. Na poniższym rysunku otwartych jest wiele obiektów (jedna kwerenda i cztery tabele). Można się między nimi bardzo łatwo przełączać — wystarczy kliknąć zakładkę powiązaną z danym obiektem, a pojawi się on na wierzchu.
58
Część I Komponenty Accessa Nie odpowiadają Ci nowe okna z zakładkami? Możesz przywrócić dawne, nakładające się okna za pomocą opcji Plik/Opcje. W oknie dialogowym Opcje programu Access otwórz zakładkę Bieżąca baza danych, a następnie zmień wartość ustawienia Opcje okna dokumentu z Dokumenty kartotekowe na Nakładające się okna. Aby zmiany zostały wprowadzone, trzeba zamknąć bazę i ponownie ją otworzyć.
Wstążka Wstążka zajmuje górną część głównego ekranu i od Accessa 2007 zastępuje menu i paski narzędzi znane z poprzednich wersji tego programu. Wstążka zawiera pięć zakładek, z których każda obejmuje zestaw kontrolek i poleceń (zobacz rysunek 2.5). Oto te zakładki:
PLIK — Microsoft, w mylący sposób, nazywa zakładkę Plik przyciskiem. Niezależnie od nazwy kliknięcie zakładki Plik powoduje otwarcie widoku Backstage. Znajduje się w nim wiele opcji związanych z tworzeniem, otwieraniem, zapisywaniem i konfigurowaniem baz danych. Dokładny opis widoku Backstage znajdziesz w ramce.
NARZĘDZIA GŁÓWNE — tu umieszczono często używane elementy. Znajdziesz tu zwykle niepowiązane ze sobą polecenia, z których użytkownicy wielokrotnie korzystają w trakcie pracy z Accessem. Są to między innymi polecenia dotyczące formatowania, kopiowania, wklejania, sortowania i filtrowania.
TWORZENIE — tu znajdują się polecenia do tworzenia różnych obiektów Accessa. To z tej zakładki będziesz korzystać najczęściej. Można w niej rozpocząć tworzenie tabel, kwerend, formularzy, raportów i makr. W trakcie lektury tej książki nieustannie będziesz posługiwać się tą zakładką.
DANE ZEWNĘTRZNE — służy do integrowania Accessa z innymi źródłami danych. Dostępne są tu polecenia, które umożliwiają importowanie i eksportowanie danych, nawiązywanie połączeń z zewnętrznymi bazami danych, a także pracę z SharePointem i innymi systemami.
NARZĘDZIA BAZY DANYCH — zawiera polecenia dotyczące działania bazy danych. Znajdziesz tu narzędzia do tworzenia relacji między tabelami, analizowania wydajności bazy danych, pisania dokumentacji dla bazy, a także jej kompaktowania i naprawiania.
Oprócz pięciu standardowych zakładek wstążki istnieją też zakładki kontekstowe. Są to zakładki specjalnego typu, pojawiające się tylko po zaznaczeniu określonych obiektów. Na przykład w trakcie pracy z projektantem kwerend pojawia się widoczna na rysunku 2.6 zakładka NARZĘDZIA KWEREND PROJEKTOWANIE.
Pasek narzędzi Szybki dostęp Pasek narzędzi Szybki dostęp (zobacz rysunek 2.7) to modyfikowalny pasek, na którym można umieścić polecenia najbardziej przydatne w codziennej pracy. Domyślnie znajdują się na nim trzy polecenia: Zapisz, Cofnij i Ponów.
Rozdział 2. Wprowadzenie do Accessa
59
Rysunek 2.6. Zakładki kontekstowe zawierają polecenia związane z aktywnym obiektem Rysunek 2.7. Pasek narzędzi Szybki dostęp znajduje się nad wstążką
Widok Office Backstage Widok Office Backstage (zobacz poniższy rysunek) jest bramą do wielu opcji umożliwiających tworzenie, otwieranie bądź konfigurowanie baz danych Accessa. Aby otworzyć widok Backstage, należy kliknąć zakładkę Plik na wstążce (zobacz wcześniejszy punkt).
Widok Backstage jest wspólny dla wszystkich aplikacji pakietu Office 2013, a jego funkcje są podobne w Accessie, Wordzie, Excelu i Outlooku. Daje on dostęp do działań, które są niezbyt często wykorzystywane podczas pracy w głównym oknie Accessa. Są jednak konieczne do zapisywania, drukowania bądź utrzymywania baz danych Accessa. Dzięki umieszczeniu tych opcji w obszarze Backstage wyeliminowano konieczność występowania podobnych funkcji na wstążce Accessa. Omówienie poleceń z widoku Backstage znajdziesz w dalszych rozdziałach.
60
Część I Komponenty Accessa
Gdy klikniesz strzałkę przy pasku narzędzi Szybki dostęp, zobaczysz, że możesz dodać znacznie więcej poleceń (zobacz rysunek 2.8). Zaznacz wybrane opcje, aby dodać je do omawianego paska. Rysunek 2.8. Polecenia, które można dodać do paska narzędzi Szybki dostęp
Użytkownik nie jest ograniczony do stosowania poleceń z listy rozwijanej. Do paska narzędzi Szybki dostęp można dodać dowolne polecenia. Aby to zrobić, wykonaj następujące operacje: 1. Kliknij strzałkę obok paska narzędzi Szybki dostęp i wybierz opcję Więcej poleceń. Pojawi się okno dialogowe Opcje programu Access z otwartą zakładką Pasek narzędzi Szybki dostęp (zobacz rysunek 2.9). 2. Na widocznej po lewej stronie liście rozwijanej Wybierz polecenia z zaznacz opcję Wszystkie polecenia. 3. Na alfabetycznie uporządkowanej liście poleceń zaznacz te, które chcesz dodać, i kliknij przycisk Dodaj. 4. Następnie kliknij przycisk OK. Aby zmienić kolejność ikon na pasku narzędzi Szybki dostęp, otwórz zakładkę Pasek narzędzi Szybki dostęp w oknie dialogowym Opcje programu Access (zobacz rysunek 2.9). Na liście widocznej po prawej stronie znajdują się wszystkie polecenia umieszczone obecnie na pasku narzędzi Szybki dostęp. Można kliknąć dowolne polecenie i za pomocą przycisków ze strzałkami skierowanymi w górę i w dół zmienić jego pozycję na liście. Spowoduje to zmianę kolejności poleceń.
Rozdział 2. Wprowadzenie do Accessa
Rysunek 2.9. Dodawanie poleceń do paska narzędzi Szybki dostęp
61
62
Część I Komponenty Accessa
Część II
Tabele Accessa W tej części:
Rozdział 3. Tworzenie tabel
Rozdział 4. Relacje między tabelami
Rozdział 5. Praca z tabelami
Rozdział 6. Importowanie i eksportowanie danych
Rozdział 7. Dołączanie danych zewnętrznych
W tej części znajdziesz omówienie zagadnień związanych z tworzeniem tabel Accessa i zarządzaniem nimi. Tabele są podstawą każdej aplikacji rozwijanej w Accessie. W rozdziałach z tej części znacznie wykraczamy poza opis tworzenia tabel. Poznasz tu najważniejsze zagadnienia pozwalające wykorzystać mechanizmy omówione w pozostałych częściach książki. Rozdział 3. dotyczy podstaw. Dowiesz się z niego, czym są tabele i z jakich elementów się składają. W rozdziale 4. poznasz znaczenie relacji i nauczysz się skutecznie tworzyć relacje między tabelami bazy oraz zarządzać nimi. W rozdziale 5. omówiliśmy techniki sortowania, filtrowania i używania tabel z surowymi danymi oraz arkuszy danych. W rozdziałach 6. i 7. wyjaśniliśmy, jak wyjść poza bazę danych, aby tworzyć tabele na podstawie importowanych lub dołączanych zewnętrznych źródeł danych.
64
Część II Tabele Accessa
Rozdział 3.
Tworzenie tabel W tym rozdziale:
Tworzenie nowej tabeli
Modyfikowanie projektu tabeli
Definiowanie właściwości pól
Określanie klucza głównego
Tworzenie indeksów
Tworzenie dokumentacji projektu tabeli
Zapisywanie nowej tabeli
Korzystanie z tabel
Wprowadzanie danych do tabeli
Posługiwanie się polami typu Załącznik
W tym rozdziale nauczysz się, jak rozpocząć proces tworzenia bazy danych i jej tabel. Utworzysz przestrzeń bazy, w której przechowywane będą tabele, formularze, kwerendy, raporty i kod, konstruowane w miarę poznawania Accessa. Na końcu utworzymy rzeczywiste tabele używane w przykładowej bazie danych MiniAuta dla Kolekcjonerów. W tym rozdziale wykorzystano bazę danych Rozdział03.accdb. Czytelników, którzy jeszcze nie skopiowali tej bazy danych na swój dysk twardy, zachęcamy, by zrobili to teraz.
Rodzaje tabel Dla Accessa tabela zawsze jest tabelą. Jednak w aplikacjach Accessa różne tabele mają odmienne przeznaczenie. Są trzy rodzaje tabel baz danych: obiektowe, transakcyjne i łączące. Rodzaj tworzonej tabeli pozwala określić, w jaki sposób należy ją zbudować.
66
Część II Tabele Accessa
Tabele obiektów Tabele obiektów występują najczęściej. Każdy rekord w takich tabelach przechowuje informacje dotyczące obiektu z realnego świata. Klient jest tego rodzaju obiektem, a rekord w tabeli klientów przechowuje dane na temat określonej osoby. Pola w tabeli obiektów odpowiadają cechom reprezentowanego obiektu. Pole z nazwą miasta Kraków odpowiada miastu, w którym klient mieszka. W trakcie tworzenia tabeli obiektów pomyśl o cechach, które sprawiają, że dany obiekt jest wyjątkowy, i o ważnych aspektach obiektu.
Tabele transakcyjne Drugim popularnym typem tabel są tabele transakcyjne. Każdy rekord w takiej tabeli przechowuje informacje na temat pewnego zdarzenia. Zamówienie książki to przykładowe zdarzenie. Na potrzeby przechowywania informacji o wszystkich zamówieniach można utworzyć tabelę zamówień książek. W tabelach transakcyjnych prawie zawsze znajduje się pole z datą i godziną, ponieważ moment zajścia zdarzenia zwykle jest ważną informacją. Ponadto często tworzone jest pole prowadzące do tabeli obiektów, np. pole z numerem zapisanej w tabeli klientów osoby, która złożyła zamówienie. W czasie tworzenia tabeli transakcyjnej należy pomyśleć o danych i osobach związanych z określonym zdarzeniem.
Tabele łączące Tabele łączące tworzy się najłatwiej i są one bardzo ważne w dobrze zaprojektowanej bazie danych. Łączenie dwóch tabel to zwykle prosty proces. Gdy klient zamawia książkę, można łatwo powiązać zamówienie z danym klientem. Czasem jednak relacje nie są równie oczywiste. Książka może mieć wielu autorów, a jedna osoba może być autorem wielu książek. Występuje wtedy relacja typu wiele do wielu, a tabela łącząca znajduje się pomiędzy dwoma głównymi tabelami. Nazwy tabel łączących zwykle odzwierciedlają ich przeznaczenie — np. tblAutorKsiążka. W tabelach tego rodzaju znajdują się zwykle tylko trzy pola: pole z niepowtarzalnym identyfikatorem rekordu, pole z referencją do jednej strony relacji i pole z referencją do drugiej strony relacji.
Tworzenie nowej tabeli Tworzenie tabel baz danych jest w równym stopniu sztuką co nauką. Podstawą powodzenia każdego nowego projektu bazy danych jest dobra znajomość wymagań użytkowników. Opis stosowania reguł projektowania baz danych w przypadku tworzenia tabel Accessa znajdziesz w rozdziale 4.
W tym rozdziale zaprezentujemy czynności, jakie należy wykonać w celu utworzenia prostych tabel Accessa. W kolejnych podrozdziałach przestudiujemy proces dodawania tabel do baz danych Accessa włącznie ze stosunkowo złożonym zagadnieniem wyboru właściwego typu danych dla każdego z pól w tabeli.
Rozdział 3. Tworzenie tabel
67
Ważność konwencji nazewnictwa Większość projektantów korzystających z Accessa stosuje określoną konwencję nazewnictwa obiektów bazy danych. Zazwyczaj konwencje nazewnictwa są stosunkowo proste — polegają na przykład na poprzedzeniu nazw obiektów prefiksami wskazującymi na typ obiektu. Na przykład formularzowi danych pracownika można nadać nazwę frmPracownicy. W miarę powiększania się rozmiarów i podwyższania się stopnia złożoności bazy danych wzrasta konieczność ustalenia konwencji nazewnictwa dla obiektów w bazie danych. Nawet jeśli włączy się Opcje autokorekty nazw (Plik/Opcje/Bieżąca baza danych/Opcje autokorekty nazw), Access skoryguje tylko najbardziej oczywiste sytuacje modyfikacji nazw. Zmiana nazwy tabeli powoduje zaprzestanie działania praktycznie każdej kwerendy, formularza czy raportu, które z niej korzystają. Najlepszą linią obrony jest stosowanie sensownych nazw obiektów i przyjęcie właściwej konwencji nazewnictwa na wczesnym etapie projektowania baz danych Accessa i przestrzeganie jej w całym projekcie. W Accessie obowiązuje bardzo niewiele ograniczeń dotyczących nazw przypisywanych obiektom baz danych. W związku z tym istnieje możliwość istnienia dwóch zupełnie różnych obiektów (np. formularza i raportu lub tabeli i makra) o tych samych nazwach (nie można jednak zastosować tej samej nazwy dla tabeli i kwerendy, ponieważ tabele i kwerendy zajmują tę samą przestrzeń nazw w bazie danych). Chociaż proste nazwy, takie jak Klienci i Zamówienia, są jak najbardziej właściwe, w miarę rozrastania się bazy danych łatwo się pogubić i stracić orientację, do którego obiektu odnosi się określona nazwa. Na przykład w dalszej części tej książki zapoznamy się z wykonywaniem operacji na obiektach bazy danych za pomocą kodu i makr. Podczas pracy z wbudowanym w Accessie językiem programowania Visual Basic for Applications (VBA) nie może być niejednoznaczności co do nazw używanych obiektów. Jeśli zarówno formularz, jak i raport mają nazwę Klienci, może to być mylące dla programisty oraz tworzonego przez niego kodu. Najprostszą konwencją nazewnictwa jest poprzedzenie nazw obiektów ciągiem trzech lub czterech znaków określających typ obiektu, którego ta nazwa dotyczy. Zgodnie z tą konwencją nazwy tabel poprzedza się prefiksem tbl, natomiast kwerend — qry. Prefiksy dla formularzy, raportów, makr i modułów to odpowiednio frm, rpt, mcr i bas lub mod. W tej książce w większości złożonych nazw występują zarówno wielkie, jak i małe litery: tblZamówienia Książek, tblKlienci itd. Dla większości osób nazwy zawierające zarówno małe, jak i wielkie litery są łatwiejsze do czytania i zapamiętania niż nazwy składające się wyłącznie z wielkich bądź wyłącznie z małych liter (np. TBLZAMÓWIENIAKSIĄŻEK lub tblzamówieniaksiążekszczegóły). Czasami będziemy stosowali nieformalne odwołania do obiektów bazy danych. Na przykład formalna nazwa tabeli zawierającej informacje o klientach w poprzednich przykładach to tblKlienci. Nieformalne odwołanie do tej tabeli może mieć postać „tabela klientów”. W większości przypadków użytkownicy baz danych nigdy nie stykają się z formalnymi nazwami obiektów bazy danych. Jednym z najtrudniejszych zadań projektanta aplikacji jest stworzenie interfejsu użytkownika, który ukrywa wszystkie elementy związane z zarządzaniem i przechowywaniem danych wyświetlanych w tym interfejsie. Bez trudu można modyfikować tekst wyświetlający się w paskach tytułów oraz w formularzach, raportach i innych komponentach interfejsu użytkownika w taki sposób, aby ukryć nazwy struktur danych i składników interfejsu. W Accessie nazwy tabel mogą mieć do 64 znaków. Należy to wykorzystać i nadawać długie, opisowe nazwy tabelom, kwerendom, formularzom i raportom. Nie ma powodu, aby skracać nazwę tabeli do postaci KsZam, skoro Access równie łatwo obsługuje znacznie bardziej zrozumiałą nazwę tblZamówieniaKsiążek. Oczywiście z opisowymi nazwami nie należy przesadzać. Nie ma sensu nazywać formularza frmAktualizacjaInformacjiOKlientach, skoro wystarczy zastosować nazwę frmAktualizujInfo.
68
Część II Tabele Accessa
W dłuższych nazwach o wiele łatwiej popełnić pomyłkę w pisowni, zatem należy zachować rozsądek. Chociaż Access zezwala na używanie spacji w nazwach obiektów bazy danych, należy unikać ich stosowania. Spacje nie poprawiają czytelności nazw, a mogą spowodować poważne problemy, zwłaszcza w środowiskach klient-serwer lub w przypadku wykorzystania automatyzacji OLE z innymi aplikacjami. Nawet jeśli nie przewidujemy instalacji aplikacji Accessa w środowisku klientserwer i nie mamy zamiaru wykorzystywać automatyzacji OLE lub DDE, warto wyrobić sobie nawyk niestosowania spacji w nazwach obiektów bazy danych. W nazwach tabel można też stosować znaki specjalne, np. podkreślenia. Niektórzy programiści stosują ogólną konwencję nazewnictwa, w ramach której używają podkreślenia do rozdzielania słów w nazwach tabel. Jeśli jednak nie posługujesz się określoną konwencją, która obejmuje znaki specjalne, powinieneś ich unikać.
Przed przystąpieniem do tworzenia tabel w bazie danych za pomocą narzędzi Accessa warto wcześniej zaprojektować tabele na papierze. Wiele tabel, zwłaszcza tych nieskomplikowanych, nie wymaga wielkiego planowania przed wprowadzeniem ich do bazy danych. W szczególności nie trzeba zbyt wiele planować, jeśli chce się zaprojektować tabelę zawierającą informacje przeglądowe, takie jak nazwy miast i województw. Prawidłowe zaprojektowanie tabel z informacjami o bardziej złożonych podmiotach, np. klientach lub produktach, wymaga jednak znacznego wysiłku i przemyśleń. Chociaż tabelę można utworzyć z marszu bez żadnego planowania, to jednak precyzyjne zaprojektowanie systemu bazy danych jest jak najbardziej wskazane. Wprawdzie wszelkie zmiany można wprowadzać później, ale jest to marnowanie czasu — powstaje wtedy system trudny do konserwacji i zarządzania, w przeciwieństwie do takiego, który od początku był poprawnie zaplanowany. W następnych podrozdziałach opiszemy czynności wykonywane z nową pustą tabelą dodaną do bazy danych Rozdział03.accdb. Z procesem dodawania nowych tabel do bazy danych Accessa należy dokładnie się zapoznać. Ponieważ czynności potrzebne do dodawania tabel bardzo się zmieniły w porównaniu z wcześniejszymi wersjami Accessa, nawet doświadczeni projektanci powinni przestudiować poniższe punkty.
Projektowanie tabel Projektowanie tabeli to proces, który dzieli się na kilka etapów. Wykonując je kolejno, można utworzyć czytelną strukturę tabeli przy minimalnym wysiłku: 1. Utworzenie nowej tabeli. 2. Wpisanie nazwy, typu danych, właściwości oraz (opcjonalnie) opisu dla każdego pola. 3. Ustalenie klucza głównego tabeli. 4. Utworzenie indeksów dla wybranych pól. 5. Zapisanie struktury tabeli. Ogólnie rzecz biorąc, projektowanie niektórych tabel nigdy się nie kończy. Jeśli zmienią się potrzeby użytkowników bądź reguły biznesowe rządzące aplikacją, czasami trzeba otworzyć tabelę w widoku projektu. W tej książce, podobnie jak w większości książek
Rozdział 3. Tworzenie tabel
69
na temat Accessa, opisano proces tworzenia tabel w taki sposób, jakby każda tabela była tworzona zupełnie od początku. W rzeczywistości jednak większość pracy w aplikacjach Accessa wykonuje się na istniejących obiektach bazy danych. Niektóre z tych obiektów zdefiniowaliśmy sami, inne dodali inni programiści pracujący nad aplikacją w przeszłości. Jednak proces konserwacji istniejącego komponentu bazy danych przebiega dokładnie tak samo jak tworzenie tego samego obiektu od podstaw. Oto krótka uwaga na temat modyfikowania tabel po ich utworzeniu. Dodanie nowego pola do tabeli niemal nigdy nie stwarza problemów. Istniejące wcześniej kwerendy, formularze i raporty, a nawet kod VBA będą korzystały z tabeli tak, jak dotychczas. Obiekty te nie będą się przecież odwoływały do nowego pola, ponieważ pole to dodano już po ich utworzeniu. Nowe pole nie jest automatycznie dodawane do istniejących obiektów, natomiast można dodać nowe pole i wykorzystywać je tam, gdzie trzeba w aplikacji, i wszystko będzie działało zgodnie z oczekiwaniami. Problemy powstają w przypadku usunięcia bądź zmiany nazwy pola w tabeli. Nawet przy włączonej opcji autokorekty nazw Access nie uaktualni odwołań do nazw pola w kodzie VBA, właściwościach formantów i wyrażeniach używanych w bazie danych. Modyfikacja istniejącego pola (lub dowolnego obiektu bazy danych) zawsze jest złym pomysłem. Cały czas należy dążyć do tego, by tabele, pola i inne obiekty bazy danych miały dobre, opisowe nazwy już w momencie ich dodawania do bazy danych. Nigdy nie należy planować poprawiania nazw w późniejszym czasie. Wielu projektantów posługujących się Accessem rutynowo wyłącza opcję autokorekty (należy wybrać zakładkę Plik w celu przejścia do widoku Backstage, a następnie wybrać Opcje/Bieżąca baza danych; w grupie Opcje autokorekty nazw opcja Śledź informacje autokorekty nazw nie powinna być zaznaczona). Włączenie opcji autokorekty ujemnie wpływa na wydajność, ponieważ Access stale śledzi zmiany nazw w aplikacji i dokonuje odpowiednich korekt, jeśli jest taka potrzeba. Co więcej, ponieważ opcja autokorekty nigdy nie skoryguje wszystkich nazw w aplikacji, zawsze jest więcej pracy do wykonania w przypadku, gdy chcemy zmienić nazwę obiektu bazy danych.
Najpierw należy wybrać zakładkę TWORZENIE na wstążce wyświetlającej się w górnej części ekranu Accessa. Zakładka TWORZENIE (zobacz rysunek 3.1) zawiera wszystkie narzędzia potrzebne do tworzenia nie tylko tabel, ale także formularzy, raportów i innych obiektów bazy danych.
Rysunek 3.1. Zakładka TWORZENIE zawiera narzędzia potrzebne do dodawania nowych obiektów do bazy danych Accessa W poniższych przykładach wykorzystano bazę danych Rozdział03.accdb, którą można znaleźć w przykładach dołączonych do książki.
Są dwa główne sposoby dodawania nowych tabel do bazy danych Accessa. Obydwa wywołuje się z grupy Tabele na zakładce TWORZENIE:
70
Część II Tabele Accessa
Kliknięcie przycisku Tabela — powoduje dodanie zupełnie nowej tabeli do bazy danych. Tabela jest wyświetlana w arkuszu danych i ma jedno pole Identyfikator typu Autonumerowanie.
Kliknięcie przycisku Projekt tabeli — dodaje tabelę do bazy danych i wyświetla ją w widoku projektu.
W naszym przykładzie skorzystamy z przycisku Projekt tabeli, najpierw jednak przyjrzyjmy się przyciskowi Tabela. Kliknięcie przycisku Tabela powoduje dodanie nowej tabeli w środowisku Accessa. Nowa tabela wyświetli się w widoku arkusza danych w obszarze po prawej stronie okienka nawigacji. Nową tabelę pokazano na rysunku 3.2. Zwróć uwagę, że wyświetla się ona w widoku arkusza danych z dodaną kolumną Identyfikator. Z prawej strony pola Identyfikator wyświetla się kolumna z nagłówkiem Kliknij, aby dodać. Rysunek 3.2. Nowa tabela w widoku arkusza danych
Kolumna z nagłówkiem Kliknij, aby dodać ma na celu umożliwienie szybkiego dodawania pól do tabeli. Wystarczy zacząć wprowadzać dane w nowej kolumnie. Aby przypisać nazwę polu, wystarczy kliknąć prawym przyciskiem myszy nagłówek pola, wybrać polecenie Zmień nazwę kolumny i wprowadzić nazwę pola. Mówiąc inaczej, tworzenie tabeli Accessa pod wieloma względami przypomina tworzenie arkuszy kalkulacyjnych w programie Microsoft Excel. W poprzednich wersjach programu Microsoft Access o tym sposobie zwykle mówiło się jako o „tworzeniu tabeli w widoku arkusza danych”.
Po dodaniu nowej kolumny można skorzystać z narzędzi z zakładki POLA wstążki (zobacz rysunek 3.3). Za ich pomocą można ustawić określony typ danych pola, a także wybrać format, reguły sprawdzania poprawności i inne właściwości.
Rysunek 3.3. Narzędzia do projektowania pól znajdują się w zakładce POLA na wstążce
Drugi sposób dodawania nowych tabel polega na wykorzystaniu przycisku Projekt tabeli w grupie Tabele na zakładce TWORZENIE. Powoduje to otwarcie nowej tabeli w widoku projektu. Można w nim dodawać pola do projektu tabeli. Na rysunku 3.4 pokazano projekt nowej tabeli po dodaniu kilku nowych pól. Wykorzystanie widoku projektu tabeli to bardziej sensowny sposób tworzenia tabel.
Rozdział 3. Tworzenie tabel
71
Rysunek 3.4. Nowa tabela dodana w widoku projektu
Posługiwanie się narzędziem do projektowania tabel jest proste, a każda kolumna jest czytelnie opisana. Skrajna lewa kolumna to Nazwa pola. Służy ona do wprowadzania nazw pól dodawanych do tabeli. Do każdego pola tabeli należy przypisać typ danych i (opcjonalnie) wprowadzić opis. W przykładzie zaprezentowanym poniżej utworzymy tabelę klientów w przykładowej bazie danych MiniAuta dla Kolekcjonerów. Podstawowy projekt tej tabeli został przedstawiony w tabeli 3.1. Szczegółowe informacje dotyczące projektu tej tabeli opisano w podrozdziale „Tworzenie tabeli klientów” w dalszej części niniejszego rozdziału. Domyślny rozmiar pola dla pól typu Krótki tekst w przedstawionej tabeli to 255 znaków. Choć istnieje małe prawdopodobieństwo, aby czyjeś nazwisko miało 255 znaków, nie ma nic złego w przygotowaniu bazy danych do przechowywania bardzo długich nazwisk. Access zapisuje tylko tyle znaków, ile użytkownik wprowadzi w polu tekstowym. W związku z tym przydzielenie 255 znaków na nazwisko nie powoduje zużycia 255 znaków na każde nazwisko zapisane w bazie danych. Jeśli jeszcze raz spojrzymy na rysunek 3.4, zauważymy, że okno Projekt tabeli składa się z dwóch obszarów:
Obszar wprowadzania pól — w tym obszarze (w górnej części okna) wprowadza się nazwy i typy danych poszczególnych pól. Można w nim również wprowadzać opcjonalne opisy pól.
Obszar właściwości pól — obszar ten (w dolnej części okna) służy do wprowadzania właściwości każdego z pól. Do właściwości pól należy między innymi ich rozmiar, format, maska wprowadzania i wartość domyślna. Zbiór dostępnych właściwości w tym obszarze zależy od typu danych wybranego dla pola. Więcej informacji na temat właściwości pól można znaleźć w punkcie „Przypisywanie właściwości pól” w dalszej części tego rozdziału.
72
Część II Tabele Accessa
Tabela 3.1. Tabela klientów w bazie danych MiniAuta dla Kolekcjonerów Nazwa pola
Typ danych
Opis
CustomerID
Autonumerowanie
Klucz główny
Company
Krótki tekst
Pracodawca klienta lub inna instytucja z nim związana
Address
Krótki tekst
Adres klienta
City
Krótki tekst
Miasto klienta
State
Krótki tekst
Województwo klienta
ZipCode
Krótki tekst
Kod pocztowy klienta
Phone
Krótki tekst
Telefon klienta
Fax
Krótki tekst
Faks klienta
Email
Krótki tekst
Adres e-mail klienta
WebSite
Krótki tekst
Strona internetowa klienta
OrigCustomerDate
Data/Godzina
Data, w której klient po raz pierwszy kupił coś w firmie MiniAuta dla Kolekcjonerów
CreditLimit
Waluta
Limit kredytowy klienta w złotych
CurrentBalance
Waluta
Saldo kredytowe klienta w złotych
CreditStatus
Krótki tekst
Opis statusu kredytu klienta
LastSalesDate
Data/Godzina
Data, w której klient ostatnio kupił coś w firmie MiniAuta dla Kolekcjonerów
TaxRate
Liczba (Podwójna Stawka podatku stosowana dla klienta precyzja)
DiscountPercent
Liczba (Podwójna Procent rabatu przypisany do klienta precyzja)
Notes
Długi tekst
Uwagi i komentarze dotyczące klienta
Active
Tak/Nie
Informacja o tym, czy klient w dalszym ciągu kupuje od firmy MiniAuta dla Kolekcjonerów lub sprzedaje jej towary
Aby przełączyć się pomiędzy górnym i dolnym obszarem okna projektanta tabeli, można kliknąć myszką w czasie, gdy jej wskaźnik znajduje się w określonym obszarze, lub wcisnąć klawisz F6. Klawisz F6 powoduje przechodzenie po kolei po wszystkich otwartych okienkach (m.in. po okienku nawigacji i pola wyszukiwania właściwości), dlatego aktywowanie docelowego elementu może wymagać wielu kliknięć.
Posługiwanie się zakładką Projektowanie Zakładka PROJEKTOWANIE na wstążce Accessa (zobacz rysunek 3.5) zawiera wiele formantów ułatwiających tworzenie definicji nowej tabeli.
Rozdział 3. Tworzenie tabel
73
Rysunek 3.5. Zakładka PROJEKTOWANIE na wstążce Accessa
Formanty na zakładce PROJEKTOWANIE mają wpływ na istotne aspekty projektowania tabel. W poniższych punktach opiszemy tylko kilka spośród formantów przedstawionych na rysunku 3.5. Znacznie więcej informacji o innych przyciskach można znaleźć w podrozdziale „Tworzenie tabeli klientów” w dalszej części tego rozdziału oraz w kolejnych rozdziałach książki. Klucz podstawowy Przycisk ten umożliwia wskazanie pól w tabeli, które będą pełniły funkcję klucza podstawowego (nazywanego też kluczem głównym). Tradycyjnie klucz podstawowy wyświetla się na początku listy pól tabeli, choć może się wyświetlać w dowolnym miejscu projektu tabeli. Aby przenieść pole, wystarczy kliknąć lewym przyciskiem myszy szary znacznik po lewej stronie nazwy pola w widoku projektu tabeli, a następnie przeciągnąć pole do nowej pozycji.
Wstaw wiersze Chociaż dla mechanizmu obsługi bazy danych kolejność pól w tabeli nie ma zbyt dużego znaczenia, wielu projektantów zwraca na to ogromną uwagę. W wielu kreatorach Accessa pola są wyświetlane w tej samej kolejności, w jakiej występują w tabeli. Dlatego na przykład umieszczenie pola z ulicą i numerem domu nad polem z nazwą miasta ułatwia pracę. Klucze złożone, czyli kilka pól składających się na jeden klucz, zostaną szczegółowo omówione w rozdziale 4.
Przycisk Wstaw wiersze powoduje wstawienie pustego wiersza bezpośrednio nad pozycją wskazywaną przez kursor myszy. Na przykład jeśli kursor znajduje się w drugim wierszu w oknie projektu tabeli, kliknięcie przycisku Wstaw wiersze powoduje wstawienie pustego wiersza na drugiej pozycji i przeniesienie wiersza, który znajdował się wcześniej w tym miejscu, na pozycję trzecią. Usuń wiersze Przycisk Usuń wiersze działa odwrotnie do przycisku Wstaw wiersze — usuwa wiersze z projektu tabeli. Access nie wyświetla pytania o potwierdzenie zamiaru usunięcia wiersza przed jego faktycznym usunięciem.
74
Część II Tabele Accessa
Arkusz właściwości Przycisk Arkusz właściwości powoduje otwarcie okna Właściwości dla tabeli (zobacz rysunek 3.6). Właściwości umożliwiają zdefiniowanie ważnych cech tabeli, takich jak reguła poprawności obowiązująca dla całej tabeli lub alternatywny porządek sortowania dla danych w tabeli. Rysunek 3.6. Arkusz właściwości
Indeksy Indeksy opisano bardziej szczegółowo w podrozdziale „Indeksowanie tabel” w dalszej części tego rozdziału. Kliknięcie przycisku Indeksy powoduje otwarcie okna dialogowego Indeksy, w którym można wprowadzić szczegółowe informacje na temat indeksów zdefiniowanych dla pól tabeli.
Praca z polami Pola są tworzone poprzez wpisanie nazwy i typu danych w górnym obszarze widoku projektu tabeli. Opcjonalna właściwość Opis umożliwia wprowadzenie opisu przeznaczenia danego pola. Podczas wprowadzania danych opis będzie się wyświetlał na pasku stanu. Opis może się przydać użytkownikom pracującym z aplikacją. Po wpisaniu wszystkich nazw pól i określeniu ich typów danych można bardziej precyzyjnie zdefiniować sposób wykorzystywania pola poprzez zdefiniowanie dla niego właściwości. Określanie nazwy pola Nazwa pola powinna być wystarczająco czytelna dla projektanta tabeli, dla użytkownika systemu oraz dla Accessa. Nazwy powinny być na tyle długie, aby na ich podstawie można było szybko zdefiniować funkcję pola. Nie powinny być jednak zbyt długie (później, przy wpisywaniu reguł sprawdzania poprawności lub wykorzystywaniu nazw pól w obliczeniach, wprowadzanie zbyt długich nazw jest niewygodne). Aby wpisać nazwę pola, należy umieścić kursor w pierwszym wierszu okna widoku projektu w kolumnie Nazwa pola. Następnie należy wpisać poprawną nazwę, zwracając uwagę na następujące zasady:
Rozdział 3. Tworzenie tabel
75
Nazwy pól mogą mieć długość od 1 do 64 znaków.
Nazwy pól mogą zawierać litery, cyfry i wiele znaków specjalnych.
Nazwy pól mogą zawiera odstępy, jednak warto ich unikać z tych samych powodów, dla których nie należy ich stosować w nazwach tabel.
Nazwy pól nie mogą zawierać kropek (.), wykrzykników (!), nawiasów kwadratowych ([]) i akcentu (`).
Nie można używać tzw. niskich znaków ASCII, np. Ctrl+J, Ctrl+L (znaki ASCII o wartościach od 0 do 31).
Nazwa nie może rozpoczynać się od spacji.
W nazwach plików projektów Accessa nie można używać znaku cudzysłowu (").
W nazwach pól można używać jednocześnie wielkich i małych liter. W przypadku pomyłki podczas wpisywania nazwy należy ustawić kursor w miejscu, w którym chcemy dokonać poprawki, i wprowadzić zmianę. Nazwy pól można zmieniać w dowolnej chwili — nawet jeżeli tabela zawiera już dane. Access nie odróżnia małych liter od wielkich, zatem dla bazy danych nie ma znaczenia, czy nadamy tabeli nazwę tblCustomers, czy TblCustomers. Decyzja o wyborze liter wielkich, małych bądź różnej wielkości należy wyłącznie do projektanta. Jej celem powinno być umożliwienie tworzenia opisowych nazw i zapewnienie optymalnej czytelności nazw. Jeśli po zapisaniu tabeli zmieni się nazwę pola, która jest wykorzystywana także w kwerendach, formularzach czy raportach, trzeba ją uaktualnić również we wszystkich tych obiektach. Jedną z najczęstszych przyczyn błędów w aplikacjach Accessa jest zmiana nazw podstawowych obiektów (takich jak tabele lub pola) bez wprowadzenia zmian we wszystkich obiektach. Bardzo łatwo przeoczyć odwołanie do nazwy pola zaszyte w źródle formantu formularza lub raportu albo umieszczone głęboko w kodzie VBA.
Określanie typu danych Po dodaniu pola trzeba określić typ przechowywanych w nim danych. W Accessie można wybrać dla pola dowolne spośród kilku dostępnych typów danych (bardziej szczegółowo zostały one opisane w dalszej części rozdziału). Dostępne typy danych znajdziesz w tabeli 3.2. Na rysunku 3.7 pokazano listę rozwijaną Typ danych, służącą do określania typu danych utworzonych pól. Dla każdego pola trzeba określić typ danych. Niektóre typy mają dodatkowe opcje (np. pola typu Krótki tekst i Liczba udostępniają opcję Rozmiar pola). Poniżej znajduje się lista podstawowych kwestii, które należy uwzględnić przy określaniu typu danych nowych pól tabeli:
Który typ danych wybrać? Typ danych powinien odpowiadać danym przechowywanym w polu. Do zapisywania liczby sztuk lub cen należy więc wybrać jeden z liczbowych typów danych. Tego rodzaju typów danych nie należy jednak używać do przechowywania numerów telefonów lub numerów PESEL.
76
Część II Tabele Accessa
Tabela 3.2. Typy danych dostępne w programie Microsoft Access Typ danych
Typ przechowywanych informacji
Pojemność
Krótki tekst
Znaki alfanumeryczne
Do 255 znaków
Długi tekst
Znaki alfanumeryczne
Do 1 gigabajta znaków
Liczba
Wartości liczbowe
1, 2, 4 lub 8 bajtów (16 bajtów na identyfikatory GUID)
Data/Godzina
Data i godzina
8 bajtów
Waluta
Wartości pieniężne
8 bajtów
Autonumerowanie
Automatycznie zwiększane liczby
4 bajty (16 bajtów na identyfikatory GUID)
Tak/Nie
Wartości logiczne (tak/nie, prawda/fałsz)
1 bit (0 lub –1)
Obiekt OLE
Zdjęcia, wykresy, dźwięk, filmy
Do 1 gigabajta (ograniczone pojemnością dysku)
Hiperłącze
Odnośnik do zasobów internetowych
Do 1 gigabajta znaków
Załącznik
Specjalne pole, które pozwala dołączyć pliki zewnętrzne do bazy Accessa
Zależy od załącznika
Kreator odnośników
Wyświetla dane z innej tabeli
Zwykle 4 bajty
Rysunek 3.7. Lista rozwijana Typ danych
Aplikacja nie wykonuje na numerach telefonów operacji arytmetycznych (np. dodawania lub mnożenia). Dlatego dla informacji tego rodzaju należy stosować pola tekstowe. W polach liczbowych początkowe zera są pomijane. Gdy umieścisz w polu liczbowym kod pocztowy 02173, zapisane zostaną tylko cztery ostatnie cyfry.
Rozdział 3. Tworzenie tabel
77
Jakie wymagania pamięciowe ma wybrany typ danych? Choć można zastosować typ danych o rozmiarze Liczba całk. długa zamiast o rozmiarze Liczba całkowita lub Bajt, wartości o rozmiarze Liczba całk. długa zajmują dwukrotnie więcej pamięci niż wartości o rozmiarze Liczba całkowita. Oznacza to, że do używania liczb i operowania na nich trzeba będzie wykorzystać dwukrotnie więcej pamięci roboczej, a do ich przechowywania — dwa razy więcej pamięci dyskowej. Dlatego jeśli to możliwe, do przechowywania prostych danych liczbowych używaj rozmiaru Bajt lub Liczba całkowita.
Czy zamierzasz używać danego pola do sortowania lub indeksowania? Z uwagi na binarny charakter pól typu Długi tekst i Obiekt OLE nie można ich wykorzystać przy sortowaniu lub indeksowaniu. Staraj się nie nadużywać pól typu Długi tekst. Przechowywanie i używanie danych tego typu związane jest z dużymi kosztami.
Jaki wpływ ma zastosowanie danego typu danych na sortowanie? Dane liczbowe sortuje się inaczej niż tekst. Gdy używasz liczbowego typu danych, ciąg liczb jest porządkowany w oczekiwany sposób: 1, 2, 3, 4, 5, 10, 100. Jeśli ten sam ciąg zapiszesz jako dane tekstowe, zostanie posortowany tak: 1, 10, 100, 2, 3, 4, 5. Jeżeli dane tekstowe mają być sortowane tak jak liczby, przed rozpoczęciem procesu sortowania dane trzeba przekształcić. Gdy dane tekstowe reprezentujące liczby mają być sortowane w odpowiedniej kolejności, można poprzedzić wartości zerami (001, 002 itd.). Wtedy wartości tekstowe pojawią się w oczekiwanej kolejności: 001, 002, 003, 004, 005, 010, 100.
Czy dane należy zapisać jako tekst czy jako datę? Przy stosowaniu dat prawie zawsze lepiej jest zapisywać je w polach typu Data/Godzina niż typu Krótki tekst. Wartości tekstowe są sortowane inaczej niż daty (daty wewnętrznie są zapisywane jako liczby), co może zaburzyć układ raportów i innych materiałów wymagających wyświetlania danych w kolejności chronologicznej. Nie zapisuj daty w jednym polu typu Data/Godzina, a godziny w innym polu tego typu. Typ Data/Godzina jest zaprojektowany do przechowywania dat i godzin, a z dalszych rozdziałów dowiesz się, że można łatwo wyświetlać samą datę lub samą godzinę z wartości typu Data/Godzina. Ponadto pola typu Data/Godzina służą do zapisywania konkretnej daty i godziny, a nie przedziałów czasu. Jeśli chcesz rejestrować przedziały czasu, możesz wykorzystać dwa pola typu Data/Godzina (jedno na początek i drugie na koniec danego okresu) lub pole liczbowe o rozmiarze Liczba całk. długa, w którym można zapisać liczbę sekund, minut, godzin itp.
Jakie raporty będą potrzebne? W raportach nie można sortować bądź grupować danych typu Obiekt OLE. Jeśli trzeba przygotować raport na podstawie danych typu Obiekt OLE, należy dodać pole znacznika, np. datę lub numer porządkowy, i wykorzystać je jako klucz sortowania tabeli.
Typ danych Krótki tekst
Typ danych Krótki tekst służy do przechowywania prostych informacji składających się ze znaków (liter, cyfr i znaków przestankowych). Danymi tekstowymi są nazwiska, adresy czy opisy, a także dane liczbowe, które nie są wykorzystywane do obliczeń (np. numery telefonów, NIP-y, kody pocztowe).
78
Część II Tabele Accessa
Chociaż dla każdego pola typu Krótki tekst w obszarze właściwości określa się jego rozmiar, nie można wpisać wartości większej niż 255 znaków. Do przechowywania danych tego typu Access używa pól o zmiennej długości. Jeżeli na przykład ustalimy długość pola na 25 znaków, ale w poszczególnych rekordach będą występować wpisy nie dłuższe niż 5 znaków, to w przestrzeni bazy danych będzie zajęta ilość miejsca potrzebna do zapisania 5 znaków. Po jakimś czasie można zauważyć, że plik bazy danych (.accdb) wykazuje tendencję do szybkiego rozrostu, ale to nie pola tekstowe są tego przyczyną. Mimo to dobrym nawykiem jest ograniczenie pól typu Krótki tekst do maksymalnej długości, jakiej zgodnie z naszymi przewidywaniami wpisy nie przekroczą. Z nazwiskami należy być ostrożnym, gdyż w niektórych kulturach są one bardzo długie. Jednak bezpiecznie można założyć, że kody pocztowe w Polsce zawsze będą miały długość sześciu znaków (wliczając kreskę). Ograniczając długość pola typu Krótki tekst, ogranicza się także liczbę znaków, jakie użytkownik może wpisać w odpowiednim polu formularza. Typ danych Długi tekst
Pola typu Długi tekst przechowują dane o zmiennej wielkości, przy czym ich maksymalna długość to 1 gigabajt. Pola tego typu zajmują tyle pamięci, ile potrzeba na zapisanie danych. Jeśli więc jeden rekord wymaga 100 znaków, inny tylko 10, a jeszcze inny 3000, w każdym zajmowana jest tylko niezbędna ilość pamięci. Dla pól typu Długi tekst nie trzeba określać rozmiaru. Access przydziela im tyle pamięci, ile zajmują dane. W wersjach wcześniejszych od Accessa 2013 typ Krótki tekst nosił nazwę Tekst, a typ Długi tekst — Nota. Jeśli korzystasz ze starszych wersji Accessa, musisz się posługiwać dawnymi nazwami typów danych. Właściwości i ograniczenia tych typów się nie zmieniły — zmodyfikowano tylko nazwy. Typ danych Liczba
Typ danych Liczba umożliwia przechowywanie danych liczbowych, czyli wartości, które będą brały udział w obliczeniach matematycznych lub reprezentują wartości skalarne (np. liczbę sztuk produktu w magazynie). W przypadku danych wykorzystywanych w obliczeniach finansowych należy ustalić dla nich typ Waluta, który pozwala na wykonywanie obliczeń bez błędów zaokrągleń. Dokładny typ danych liczbowych zapisanych w polu typu Liczba jest określony przez właściwość Rozmiar pola. W tabeli 3.3 zestawiono różne liczbowe typy danych wraz z ich maksymalną i minimalną wartością, liczbą miejsc dziesiętnych oraz rozmiarem (w bajtach) potrzebnym do ich przechowywania. Podczas projektowania tabel trzeba być bardzo ostrożnym i wybierać typy danych umożliwiające zapisywanie w bazie danych znacznie większych wartości niż spodziewane. Nie oznacza to, że należy używać typu Podwójna precyzja dla wszystkich pól liczbowych. Rozmiar danych typu Podwójna precyzja jest bardzo duży (8 bajtów), a operacje obliczeniowe z wykorzystaniem danych tego typu wykonują się powoli. Typ danych Pojedyncza precyzja najbardziej się nadaje do wykonywania większości obliczeń zmiennoprzecinkowych, natomiast typ Liczba całk. długa jest najlepszy do obliczeń, w których część dziesiętna liczby nie ma znaczenia.
Rozdział 3. Tworzenie tabel
79
Tabela 3.3. Właściwości typów liczbowych Ustawienie w polu Rozmiar pola
Zakres
Miejsca dziesiętne Rozmiar w pamięci
Bajt
0 do 255
Brak
1 bajt
Liczba całkowita
–32 768 do 32 767
Brak
2 bajty
Liczba całk. długa
–2 147 483 648 do 2 147 483 647
Brak
4 bajty
15
8 bajtów
Podwójna precyzja
–1,797 × 10
308
308
do 1,797 × 10
38
38
Pojedyncza precyzja
–3,4 × 10 do 3,4 × 10
7
4 bajty
Identyfikator replikacji
Nie dotyczy
Nie dotyczy
16 bajtów
Dziesiętne
Dokładność 1 – 28
15
8 bajtów
Wybór niewłaściwego typu dla pól liczbowych jest przyczyną wielu błędów. Zwróćmy uwagę, że maksymalna wartość dla danych typu Liczba całkowita wynosi 32 767. Znam przypadek bazy danych, która doskonale działała przez kilka lat, a potem zaczęły się w niej pojawiać błędy przepełnienia. Okazało się, że przyczyną błędu było ustawienie typu Liczba całkowita dla jednego z pól. Kiedy w pewnym momencie firma podjęła próbę przetwarzania bardzo rozbudowanej listy zamówień, nastąpiło przekroczenie maksymalnej wartości 32 767. Należy pamiętać, że przepełnienie może wystąpić w wyniku dodania do siebie dwóch liczb albo wykonania dowolnego działania matematycznego, którego wynik jest wartością zbyt dużą, aby mogła się zmieścić w polu. Sytuacje, kiedy w pewnych okolicznościach występujących w czasie działania aplikacji (np. podczas dodawania lub mnożenia dwóch liczb) dochodzi do przepełnienia, należą do najtrudniejszych do wykrycia błędów. Typ danych Data/Godzina
Typ danych Data/Godzina to specjalny typ liczbowy do przechowywania dat lub godzin (lub dat razem z godzinami). Po zapisaniu dat w polach typu Data/Godzina można z łatwością obliczyć liczbę dni między dwoma datami oraz wykonać inne operacje dotyczące kalendarza. Daty zapisane w polach typu Data/Godzina można również bez przeszkód sortować i filtrować. Typ danych Data/Godzina umożliwia przechowywanie dat w zakresie od 1 stycznia 100 roku do 31 grudnia 9999 roku. Typ danych Waluta
Typ danych Waluta to kolejny specjalny typ danych liczbowych. Dane tego typu nie są zaokrąglane podczas obliczeń i zachowują 15 cyfr precyzji z lewej strony przecinka dziesiętnego i 4 cyfry z prawej. Ponieważ w danych tych pozycja przecinka dziesiętnego jest stała, obliczenia liczbowe na nich są szybsze w porównaniu z liczbami typu Podwójna precyzja. Typ danych Autonumerowanie
Typ danych Autonumerowanie to jeszcze jeden specjalny typ danych liczbowych. W przypadku dodania do tabeli pola typu Autonumerowanie Access automatycznie przypisuje liczbę całkowitą długą (32 bity) do pola (począwszy od 1) i inkrementuje tę wartość każ-
80
Część II Tabele Accessa
dorazowo po dodaniu rekordu do tabeli. Alternatywnie (w zależności od właściwości Nowe wartości) wartość pola typu Autonumerowanie jest losową liczbą całkowitą automatycznie wprowadzaną do nowych rekordów. W tabeli może występować tylko jedno pole typu Autonumerowanie. Po przypisaniu wartości Autonumerowanie wewnątrz rekordu nie można go zmienić ani programowo, ani przez użytkownika. Pola typu Autonumerowanie są odpowiednikami typu danych Liczba całk. długa i zajmują 4 bajty. Zakres dopuszczalnych wartości dla pól Autonumerowanie wynosi od 1 do 4 294 967 296 — to więcej niż wystarczająco do wykorzystania w roli kluczy głównych dla większości tabel. Pole typu Autonumerowanie nie gwarantuje generowania ciągłego zbioru kolejnych liczb. Jeżeli proces dodawania nowego rekordu zostanie przerwany (np. jeśli użytkownik wciśnie klawisz Esc podczas wprowadzania danych do nowego rekordu), to planowana dla tego rekordu wartość Autonumerowanie zostanie pominięta. Pól typu Autonumerowanie nie należy używać do generowania ciągu kolejnych liczb. Zamiast tego można skorzystać z makr osadzanych (ang. data macro) lub kodu VBA (makra osadzane zostaną szczegółowo omówione w rozdziale 22.) Gdy tworzysz relację między dwiema tabelami i jednym z pól uwzględnianych w relacji jest pole typu Autonumerowanie, drugie z tych pól powinno być typu Liczba całk. długa. Pozwala to uniknąć błędów przepełnienia. Omówienie tworzenia relacji między tabelami znajdziesz w rozdziale 4. Typ danych Tak/Nie
W polach typu Tak/Nie można zapisać tylko jedną z dwóch dozwolonych wartości. Pola te są wewnętrznie zapisane jako 1 (tak) lub 0 (nie) i służą do wskazywania wartości włączony/wyłączony, tak/nie lub prawda/fałsz. Pole typu Tak/Nie zajmuje 1 bit. Typ danych Obiekt OLE
Pola typu Obiekt OLE służą do zapisywania danych OLE — wysoko specjalizowanych obiektów binarnych, takich jak dokumenty Worda, arkusze kalkulacyjne Excela, klipy dźwiękowe i filmowe lub zdjęcia. Obiekty OLE tworzy się ze pomocą aplikacji rozpoznawanej przez system Windows jako serwer OLE. Można ją powiązać z aplikacją macierzystą lub osadzić w tabeli Accessa. W formularzach i raportach Accessa obiekty OLE można wyświetlać wyłącznie w powiązanych ramkach obiektów. Pól tego typu nie można indeksować. Typ danych Załącznik
Typ danych Załącznik został wprowadzony w Accessie 2007. Był on jednym z powodów, dla których Microsoft zmienił format pliku danych Accessa. Starszy format pliku (.mdb) nie pozwala na zapisywanie załączników. Typ danych Załącznik w porównaniu z innymi typami pól Accessa jest dość złożony. Wyświetlanie go w formularzach Accessa wymaga specjalnego postępowania. Więcej informacji na temat tego interesującego typu danych można znaleźć w podrozdziale „Posługiwanie się polami typu Załącznik” w dalszej części tego rozdziału.
Rozdział 3. Tworzenie tabel
81
Typ danych Hiperłącze
Typ Hiperłącze przechowuje kombinację tekstu i liczb zapisaną jako tekst i wykorzystywaną jako adres hiperłącza. Może zawierać do trzech części:
Tekst wyświetlany w polu (zazwyczaj sformatowany, aby wyglądał jak odnośnik).
Adres internetowy — ścieżka do pliku lub lokalizacja strony WWW.
Dowolny podadres wewnątrz pliku lub strony. Przykładem podadresu jest zdjęcie na stronie WWW. Poszczególne części adresu hiperłącza są oddzielone znakiem krzyżyka (#).
Hiperłącza Accessa umożliwiają nawet odwołania do formularzy i raportów w innych bazach danych Accessa. Oznacza to, że można skorzystać z tego typu danych w celu otwarcia formularza bądź raportu pochodzącego z zewnętrznej bazy danych Accessa. Kreator odnośników
Kreator odnośników tworzy pole, które umożliwia wybieranie wartości z innej tabeli lub z listy wyników instrukcji SQL-a. Wartości mogą być również wyświetlane w postaci pola kombi lub listy. W czasie projektowania tabeli Kreator odnośników przeprowadza programistę przez proces definiowania własności odnośników. Proces ten rozpoczyna się w momencie przypisania tego typu danych do pola. Przeciągnięcie pola utworzonego za pomocą kreatora odnośników z listy pól podczas tworzenia formularza, powoduje automatyczne utworzenie na formularzu pola kombi lub pola listy. Pole listy lub pole kombi wyświetli się również w arkuszu danych kwerendy zawierającej pole tego typu. Wprowadzanie opisu pola Pole Opis jest całkowicie opcjonalne — pomaga wyłącznie zapamiętać funkcję pola lub przedstawić ją innym użytkownikom. Zazwyczaj wcale nie korzysta się z kolumny opisu lub wypełnia się ją tylko dla tych pól, których przeznaczenie nie jest oczywiste na pierwszy rzut oka. Jeżeli wprowadzi się opis dla danego pola, to przy ustawieniu się na tym polu w widoku arkusza danych lub w formularzu wyświetla się on na pasku stanu. Opisy pomagają w wyjaśnieniu funkcji pól o niejednoznacznym przeznaczeniu lub w przedstawieniu użytkownikowi pełniejszych informacji na temat poprawności danych wprowadzanych do pola. Projektowanie reguł weryfikacji poprawności danych Ostatnia ważna decyzja podczas projektowania dotyczy sprawdzania poprawności danych, które ma bardzo istotne znaczenie, gdy użytkownicy wprowadzają dane. Trzeba zapewnić, aby do systemu przedostały się tylko poprawne dane (tzn. takie, które spełniają określone testy). Jest kilka rodzajów sprawdzania poprawności danych. Można sprawdzać, czy pole zawiera znane, pojedyncze wartości, zastrzegając, że na przykład w polu Płeć dopuszczalne są tylko trzy wartości: Mężczyzna, Kobieta bądź Nieznana. Można również sprawdzać, czy wprowadzona wartość mieści się w dozwolonym zakresie, na przykład czy pole Waga ma wartość z przedziału 0 – 800 kilogramów. Więcej informacji na temat reguł poprawności danych można znaleźć w punkcie „Reguła sprawdzania poprawności i Tekst reguły sprawdzania poprawności” w dalszej części tego rozdziału.
82
Część II Tabele Accessa
Tworzenie tabeli klientów Po zapoznaniu się z dostępnymi typami danych można przystąpić do utworzenia ostatecznej działającej wersji tabeli tblCustomers.
Korzystanie z pól typu Autonumerowanie W Accessie do pól typu Autonumerowanie mają zastosowanie specjalne reguły. Otóż nie można zmienić na Autonumerowanie typu pola zdefiniowanego wcześniej w inny sposób, jeżeli do tabeli zostały już dodane jakieś dane. Przy próbie zmiany istniejącego pola na Autonumerowanie wyświetli się komunikat o błędzie: Po wprowadzeniu danych do tabeli nie można zmienić typu danych żadnego pola na Autonumerowanie, nawet jeśli do tego pola nie dodano jeszcze żadnych danych.
Zamiast tego należy dodać nowe pole typu Autonumerowanie i rozpocząć z nim pracę. W tabeli Accessa może występować tylko jedno pole typu Autonumerowanie. Ogólnie rzecz biorąc, należy korzystać z pól typu Autonumerowanie wtedy, gdy w aplikacji są potrzebne specjalne właściwości tego typu danych.
Kończenie definicji tabeli tblCustomers Kiedy tabela tblCustomers jest otwarta w widoku projektu, można przystąpić do finalizowania jej projektu. W tabeli 3.1 zamieszczonej we wcześniejszej części tego rozdziału zamieszczono definicje pól tabeli tblCustomers. Nazwy pól i typy danych należy wpisać dokładnie tak, jak przedstawiono w tabeli. Na kolejnych kilku stronach wyjaśniamy, w jaki sposób modyfikuje się zdefiniowane pola (m.in. w jaki sposób zmienia się ich kolejność i nazwy oraz jak się je usuwa). Oto kolejne czynności przy dodawaniu nowego pola do struktury tabeli: 1. Umieść kursor w kolumnie Nazwa pola, w wierszu, w którym chcesz umieścić nowe pole. 2. Wpisz nazwę pola, a następnie naciśnij klawisz Enter lub Tab, aby przejść do kolumny Typ danych. 3. Wybierz typ danych pola z rozwijanej listy w kolumnie Typ danych. 4. Jeśli jest taka potrzeba, dodaj opis pola w kolumnie Opis. Powyższe czynności należy powtarzać do czasu utworzenia wszystkich definicji pól w tabeli tblCustomers. Do przemieszczania się między wierszami można wykorzystać klawisz strzałki w dół (↓) lub po prostu kliknąć myszą w wybranym wierszu. Wciśnięcie klawisza F6 powoduje przełączanie między poszczególnymi elementami interfejsu Accessa (można go użyć do przełączania się między górną a dolną częścią okna widoku projektu tabeli).
Rozdział 3. Tworzenie tabel
83
Zmiana projektu tabeli Nawet najlepiej zaprojektowana tabela od czasu do czasu wymaga wprowadzenia zmian. Może się okazać, że potrzebne jest nowe pole lub że istniejące pole trzeba usunąć, zmienić jego nazwę bądź typ danych czy po prostu zmienić kolejność występowania pól. Chociaż projekt tabeli można zmieniać w dowolnej chwili, należy zachować ostrożność w przypadku zmiany projektu tabel zawierających dane. Trzeba uważać, aby wprowadzane zmiany nie zniszczyły danych w tabeli, co może się zdarzyć na przykład wtedy, gdy zmniejszamy rozmiar pola tekstowego bądź też właściwość Rozmiar pola pól liczbowych. Zawsze można bezproblemowo dodawać pola do tabeli, natomiast zmienianie istniejących pól może być kłopotliwe. Ponadto, z wyjątkiem kilku specyficznych sytuacji, zmiana nazwy pola po tym, kiedy zostało ono użyte w aplikacji, jest zazwyczaj złym pomysłem.
Wstawianie pola Aby wstawić nowe pole w oknie widoku projektu tabeli, należy ustawić kursor na istniejącym polu, po czym kliknąć prawym przyciskiem myszy w oknie projektowym tabeli i wybrać z menu opcję Wstaw wiersze, lub kliknąć przycisk Wstaw wiersze na wstążce. W tabeli pojawi się nowy wiersz, a wszystkie istniejące zostaną przesunięte w dół. W nowym wierszu można wpisać definicję pola. Wstawienie nowego wiersza do tabeli nie narusza innych pól, nie wpływa także na dane istniejące w tabeli. Jeżeli w bazie danych są już kwerendy, formularze czy raporty bazujące na tej tabeli, może wystąpić potrzeba dodania do nich nowego pola.
Usuwanie pola Istnieją trzy sposoby usuwania pola. Kiedy tabela wyświetla się w widoku projektu, wykonaj jedną z następujących czynności:
Zaznacz wybrane pole, klikając selektor wiersza, a następnie naciśnij klawisz Delete.
Kliknij prawym przyciskiem myszy wybrane pole, a następnie z menu podręcznego wybierz polecenie Usuń wiersze.
Zaznacz wybrane pole, a następnie kliknij przycisk Usuń wiersze znajdujący się w grupie Narzędzia w zakładce PROJEKTOWANIE na wstążce.
W przypadku usuwania pola zawierającego dane wyświetla się ostrzeżenie informujące o tym, że wszystkie dane zawarte w tym polu zostaną usunięte. Jeśli tabela zawiera dane, upewnij się, czy na pewno chcesz usunąć dane z tego pola (kolumny). Wybrane pole trzeba także usunąć z kwerend, formularzy, raportów, makr i kodu VBA odwołujących się do niego. Po usunięciu pola można je szybko przywrócić, klikając przycisk Cofnij. Trzeba to jednak zrobić przed zapisaniem zmian wprowadzonych w definicji tabeli oraz przed wprowadzeniem innych zmian w jej projekcie. Przy próbie usunięcia pola, które wchodzi w skład relacji (pole klucza głównego lub klucza obcego) Access wyświetli informację, że nie można usunąć tego pola, dopóki nie usunie się odpowiedniego powiązania z okna relacji.
84
Część II Tabele Accessa
Relacje między tabelami i okno Relacje omówiono w rozdziale 4.
Jeżeli usunie się pole, trzeba także usunąć wszystkie odwołania Accessa do tego pola. Ponieważ nazwy pola można używać w formularzach, kwerendach, raportach, a nawet regułach sprawdzania poprawności danych, trzeba dokładnie prześledzić cały system i odnaleźć wszystkie miejsca, w których wykorzystano usuwane pole.
Zmiana położenia pola Kolejność wpisania pól w widoku projektu decyduje o kolejności ich wyświetlania w widoku arkusza danych. Aby zmienić kolejność pól, wystarczy dwukrotnie kliknąć selektor pola, a następnie przeciągnąć je w nowe miejsce.
Zmiana nazwy pola Nazwę pola można zmienić, zaznaczając istniejącą nazwę w oknie widoku projektu tabeli, a następnie wpisując nową. Access automatycznie uaktualni strukturę tabeli. W czasie trwania procesu tworzenia nowej tabeli ta operacja nie nastręcza żadnych trudności.
Zmiana rozmiaru pola Zwiększanie rozmiaru pola podczas projektowania tabeli jest prostą czynnością. Należy jednak pamiętać, że zmieniać można jedynie rozmiary pól tekstowych i pól liczbowych. Wystarczy jedynie wpisać inną wartość jako właściwość Rozmiar pola w polu tekstowym lub wybrać jedną z możliwych wartości tej właściwości dla pola liczbowego. W przypadku pól liczbowych trzeba także zwrócić uwagę na właściwość Miejsca dziesiętne i upewnić się, że nie wybrano nowego rozmiaru pola, który ma mniej miejsc dziesiętnych niż aktualny. Aby zmniejszyć rozmiar pola, należy najpierw sprawdzić, czy w tabeli nie ma danych o większym rozmiarze niż nowa szerokość pola. Zmiana rozmiaru pola na mniejszy może skutkować utratą danych. Pamiętaj, że z każdego pola tekstowego wykorzystanych jest tylko tyle znaków, ile jest w nim wpisanych. Należy zawsze próbować tworzyć pola tekstowe o długości najdłuższego możliwego wpisu. Dzięki temu Access nie pozwoli użytkownikom na wpisanie wartości, która potem nie zmieści się w formularzu czy raporcie.
Problemy konwersji danych Jeśli pomimo wysiłków zdarzy się konieczność zmiany typu danych pola, w którym są zapisane dane, podczas wykonywania konwersji może dojść do utraty danych. Należy pamiętać o skutkach konwersji typu pola, dla którego wpisano dane w tabeli.
Dowolny typ danych na Autonumerowanie — niedozwolone. Pole tego typu można tworzyć tylko jako nowe pole w tabeli. na Liczba, Waluta, Data/Godzina lub Tak/Nie — w większości przypadków konwersję można przeprowadzić bez szkody dla danych. Niewłaściwe wartości są automatycznie usuwane. Na przykład pole tekstowe zawierające wartość
Krótki tekst
Rozdział 3. Tworzenie tabel
85
„28.01.12” można bez problemu przekształcić na typ Data/Godzina. Jednak próba zmiany typu pola zawierającego wartość „28.01.12” na typ Tak/Nie spowoduje usunięcie wartości. na Krótki tekst — oczywista konwersja bez utraty danych bądź ich uszkodzenia. Teksty, których długość przekracza rozmiar pola tekstowego, są obcinane i tracone.
Długi tekst
na Krótki tekst — bez utraty informacji. Wartość liczbowa jest przekształcana na tekst z wykorzystaniem formatu Liczba ogólna.
Liczba
na Waluta — ze względu na to, że dla typu danych Waluta wykorzystuje się stałą pozycję przecinka dziesiętnego, w przypadku konieczności obcięcia liczby może dojść do utraty niektórych cyfr po przecinku.
Liczba
Data/Godzina na Krótki tekst — bez utraty informacji.
Dane typu Data/Godzina są przekształcane na tekst z wykorzystaniem formatu Data ogólna. na Krótki tekst — bez utraty informacji. Wartość typu Waluta jest przekształcana na tekst bez uwzględnienia symbolu waluty.
Waluta
na Liczba — prosta i oczywista konwersja. Podczas przekształcania waluty na liczby niektóre dane mogą ulec utracie. Na przykład podczas konwersji typu Waluta na Liczba całk. długa część dziesiętna waluty jest obcinana.
Waluta
na Krótki tekst — konwersja nie powoduje utraty danych poza przypadkiem, w którym szerokość pola tekstowego jest niewystarczająca do zapisania całej wartości typu Autonumerowanie. W takim przypadku liczba będzie obcięta.
Autonumerowanie
na Liczba — prosta i oczywista konwersja. Podczas przekształcania danych typu Autonumerowanie na liczby niektóre dane mogą ulec utracie. Na przykład w przypadku konwersji liczb typu Autonumerowanie o wartości większej niż 32 767 na typ Liczba całkowita dane będą obcięte.
Autonumerowanie
Tak/Nie na Krótki tekst — prosta konwersja wartości Tak/Nie na tekst. Bez utraty
informacji. Pola typu Obiekt OLE nie mogą być konwertowane na żaden inny typ danych.
Przypisywanie właściwości pól Właściwości pól dostępne dla tabel Accessa to sprzymierzeńcy pomagający w zarządzaniu danymi w tabelach. W większości przypadków na straży przestrzegania właściwości pól stoi silnik bazy danych, co oznacza, że właściwości są przypisywane w spójny sposób w całej aplikacji. Jeśli na przykład ustawiono właściwość Wartość domyślna podczas projektowania tabeli, wartość ta będzie dostępna w widoku arkusza danych tabeli, a także w formularzach i raportach.
86
Część II Tabele Accessa
Istnienie właściwości pól to jedna z wielu różnic między tabelami Accessa a arkuszami kalkulacyjnymi Excela. Zapoznanie się z właściwościami pól to jedna z kilku umiejętności niezbędnych do tego, by do przechowywania danych używać tabel Accessa zamiast arkuszy Excela. Z każdym typem danych jest związany inny zbiór właściwości. Na przykład pola liczbowe mają właściwość Miejsca dziesiętne, natomiast pola tekstowe mają właściwość Wyrównanie tekstu. Chociaż pewna część właściwości jest wspólna dla wielu typów danych (np. Nazwa), właściwości jest wystarczająco dużo, aby się w nich pogubić lub używać ich niezgodnie z przeznaczeniem. W kolejnych punktach opisaliśmy niektóre ważniejsze i częściej wykorzystywane właściwości pól. W poniższych punktach użyto wielu odwołań do właściwości i ich ustawień w widoku projektu tabeli Accessa. Formalne nazwy właściwości (np. DefaultValue) nigdy nie zawierają spacji, natomiast w widoku projektu zwykle wyświetla się spacja dla lepszej czytelności (np. Wartość domyślna). Te nieznaczne różnice stają się ważne podczas odwoływania się do właściwości w wyrażeniach, kodzie VBA i makrach. W formalnych odwołaniach do właściwości w kodzie lub makrach zawsze należy używać oficjalnej wersji nazwy właściwości (bez spacji), nie zaś nazwy wyświetlanej w widoku projektu tabeli w Accessie.
Wspólne właściwości Poniżej zamieszczono listę właściwości wspólnych dla wielu typów danych (należy zwrócić uwagę, że w zależności od wybranego typu danych nie wszystkie wymienione właściwości będą dostępne):
Rozmiar pola — ogranicza rozmiar pola typu Krótki tekst do określonej liczby znaków (od 1 do 255). Domyślną wartością jest 255.
Nowe wartości — właściwość ma zastosowanie do pól typu Autonumerowanie. Umożliwia określenie, czy nowe wartości mają być generowane przyrostowo czy losowo.
Format — zmienia sposób wyświetlania danych po ich wprowadzeniu (tylko duże litery, daty itd.). Jest wiele różnych typów formatów, które można zastosować do danych Accessa. Wiele z nich opisano w punkcie „Format” w dalszej części tego rozdziału.
Maska wprowadzania — używana do narzucania wpisywania danych z wykorzystaniem predefiniowanych formatów (numery telefonów, kody pocztowe, NIP-y, daty, identyfikatory itp.). Właściwość ma zastosowanie zarówno do typów liczbowych, jak i do typów tekstowych.
Miejsca dziesiętne — określa liczbę miejsc dziesiętnych dla typów Waluta i dla typów liczbowych: Pojedyncza precyzja, Podwójna precyzja i Dziesiętne.
Tytuł — opcjonalna etykieta dla pól formularzy i raportów. Jeśli zdefiniowano właściwość Tytuł, Access użyje jej dla kontrolek w formularzach i raportach zamiast nazwy pola.
Wartość domyślna — wartość automatycznie wpisywana do pola dla nowych rekordów. Może to być dowolna wartość prawidłowa dla typu danych wybranego dla pola. Wartość domyślna to nic innego jak wartość początkowa. Podczas
Rozdział 3. Tworzenie tabel
87
wprowadzania danych można ją zmienić. Aby ją zdefiniować, wystarczy wprowadzić żądaną wartość w polu właściwości Wartość domyślna. Może ona być wyrażeniem, a także liczbą lub ciągiem znaków. Ponieważ właściwość Wartość domyślna dla typów danych Liczba i Waluta domyślnie ma wartość 0 (zero), pola tych typów po dodaniu nowego rekordu są automatycznie ustawiane na 0. W wielu przypadkach, na przykład w wynikach badań medycznych i w wielu aplikacjach finansowych, zero nie jest odpowiednią wartością domyślną dla pól liczbowych. Należy się upewnić, czy zero jest odpowiednią wartością domyślną w rozwijanej aplikacji Accessa.
Reguła poprawności — sprawdza, czy dane wprowadzone w polu spełniają określone reguły, np. „większa od zera”, „data po 1 stycznia 2000” itp.
Tekst reguły spr. poprawności — komunikat wyświetlany w przypadku niepoprawnych danych.
Wymagane — określa, czy wprowadzenie wartości w polu jest obowiązkowe.
Zerowa dł. dozwolona — określa, czy można do pola tekstowego wpisać pusty ciąg znaków ("") dla odróżnienia go od wartości null.
Indeksowane — przyspiesza dostęp do danych oraz ogranicza dane do niepowtarzalnych wartości (jeśli jest to wymagane). Więcej informacji na temat indeksowania można znaleźć w dalszej części rozdziału.
Kompresja Unicode — wykorzystywana w aplikacjach wielojęzycznych. Wymaga około dwóch razy więcej przestrzeni w bazie danych, ale umożliwia wyświetlanie dokumentów pakietu Office (w tym raportów Accessa) w poprawny sposób niezależnie od tego, jakiego języka znaki czy symbole w nich występują. Ogólnie rzecz biorąc, stosowanie kodów Unicode nie ma sensu, jeśli aplikacja nie będzie wykorzystywana w środowisku języków azjatyckich.
Tryb IME — zwany także trybem konwersji kanji. Określa, który tryb edytora IME ma być stosowany po przeniesieniu fokusu do pola. Stosowanie tej właściwości nie ma sensu w aplikacjach używających języków europejskich.
Tryb zdania edytora IME — używany do określania trybu IME dla pól tabeli lub formantów formularza w przypadku uzyskania i utraty fokusu. Stosowanie właściwości nie ma sensu w aplikacjach używających języków europejskich.
Format Właściwość Format określa sposób wyświetlania lub drukowania danych zapisanych w polu tabeli. Właściwość ustawiona na poziomie tabeli obowiązuje w całej aplikacji. Dla każdego typu danych są dostępne inne specyfikatory formatu. W Accessie dostępne są wbudowane specyfikatory formatu dla większości typów danych. Na format używany do wyświetlania wartości pól mają wpływ ustawienia regionalne w panelu sterowania systemu Windows. Właściwość Format ma wpływ jedynie na sposób wyświetlania wartości, a nie na sposób zapisania wartości w bazie danych.
88
Część II Tabele Accessa
Aby zdefiniować własny format, należy utworzyć odpowiedni ciąg w polu tekstowym właściwości Format. Dla każdego typu danych dostępny jest inny zbiór symboli do wykorzystania. W Accessie są również dostępne globalne symbole, które można zastosować w dowolnym ciągu definicji formatu.
(spacja) — wyświetla spacje.
"Jakiś tekst"
— wyświetla dosłownie tekst ujęty w cudzysłów.
!
(wykrzyknik) — wyrównanie do lewej.
*
(gwiazdka) — wypełnienie pustej przestrzeni następnym znakiem.
(lewy ukośnik) — wyświetla kolejny znak dosłownie, jako tekst. Lewego ukośnika należy używać do wyświetlania znaków o specjalnym znaczeniu dla Accessa.
\
[kolor] — wyświetla pole za pomocą koloru podanego w nawiasie (black — czarny,
blue — niebieski, green — zielony, cyan — niebiesko-zielony, red — czerwony, magenta — purpurowy, yellow — żółty, white — biały). Jeśli dla pola zdefiniowano zarówno właściwość Format, jak i maskę wprowadzania, właściwość Format ma wyższy priorytet. Formaty pól typu Liczba i Waluta
Istnieje szeroka gama prawidłowych formatów dla pól typu Liczba i Waluta. Można dla nich wykorzystać jeden z formatów wbudowanych albo utworzyć własny.
Liczba ogólna — wyświetla się w takim formacie, w jakim ją wprowadzono (jest to domyślny format dla liczbowych typów danych).
Waluta — wyświetla się z separatorem tysięcy (zazwyczaj jest nim spacja), przecinkiem dziesiętnym z dwoma cyframi po jej prawej stronie, a liczby ujemne są ujęte w nawias. Wartości pól typu Waluta wyświetlają się z symbolem waluty (np. znakiem dolara lub euro). Symbol ten definiuje się w panelu sterowania za pomocą apletu Opcje regionalne i językowe.
Stałoprzecinkowy — zawsze wyświetla się co najmniej jedna cyfra z lewej i dwie cyfry z prawej strony przecinka dziesiętnego.
Standardowy — wykorzystanie separatora tysięcy i dwóch cyfr po prawej stronie przecinka dziesiętnego.
Procentowy — wartość jest mnożona przez 100, a po prawej stronie wyświetla się znak procentu. Wartości procentowe wyświetlają się z dwoma miejscami po prawej stronie przecinka dziesiętnego.
Wykładniczy — notacja wykładnicza służy do wyświetlania liczb.
Euro — dodaje symbol waluty euro do liczby.
Wbudowane formaty liczbowe przedstawiono w tabeli 3.4. Wszystkie przedstawione powyżej formaty są domyślnymi formatami bazującymi na właściwości Miejsca dziesiętne ustawionej na Auto. Zastosowany format zależy także od ustawień regionalnych z panelu sterowania.
Rozdział 3. Tworzenie tabel
89
Tabela 3.4. Przykłady formatów liczbowych Typ formatu
Wpisywana liczba
Wyświetlana liczba
Zdefiniowany format
Ogólny
987654.321
987654.3
######.#
Waluta
987654.321
$987,654.32
$###,##0.00
Euro
987654.321
€987,654.32
€###,##0.00
Stałoprzecinkowy
987654.321
987654.32
######.##
Standardowy
987654.321
987,654.32
###,###.##
Procentowy
.987
98.7%
###.##%
Wykładniczy
987654.321
9.88E+05
###E+00
Niestandardowe formaty liczbowe
Formaty niestandardowe tworzy się poprzez połączenie kilku symboli tworzących specyfikator formatu. Symbole, które można stosować dla pól typu Liczba i Waluta, wyszczególniono poniżej: (kropka) — określa, czy w wyświetlanej wartości ma się wyświetlić kropka dziesiętna.
. ,
(przecinek) — separator tysięcy.
0
(zero) — znak-wypełniacz dla zera lub cyfry.
#
(krzyżyk) — znak-wypełniacz dla cyfry lub pustego miejsca.
$
(znak dolara) — wyświetla symbol dolara.
(znak procentu) — po pomnożeniu wartości przez 100 dodawany jest do niej znak procentu.
%
lub e– — wykorzystanie notacji wykładniczej do wyświetlania liczby. Wykorzystanie znaku minus do oznaczenia ujemnego wykładnika i brak znaku dla wykładników dodatnich.
E–
lub e+ — wykorzystanie notacji wykładniczej do wyświetlania liczby. Do oznaczania wykładników dodatnich wykorzystuje się znak plus (+).
E+
Niestandardowe formaty tworzy się poprzez definiowanie ciągów złożonych z jednej do czterech części i rozdzielonych średnikami. Każda część ma dla Accessa inne znaczenie:
Pierwsza część — specyfikator formatu dla wartości dodatnich.
Druga część — specyfikator formatu dla wartości ujemnych.
Trzecia część — specyfikator formatu dla wartości zerowych.
Czwarta część — specyfikator formatu dla wartości pustych.
90
Część II Tabele Accessa
Każda część to połączenie ciągu formatującego liczby z opcjonalną specyfikacją koloru. Oto przykład niestandardowego formatu: 0 000,00[Zielony];(0 000,00)[Czerwony];"Zero";"-"
Zgodnie z tym formatem liczby wyświetlą się z zerami na wszystkich pozycjach (nawet dla liczb mniejszych niż 1000), jako separator tysięcy będzie wykorzystana spacja, liczby ujemne będą ujęte w nawias, wartość zero będzie wyświetlona w postaci słowa „Zero”, a we wszystkich polach zawierających wartość null wyświetli się dywiz. Wbudowane formaty danych typu Data/Godzina
Oto wbudowane formaty danych typu Data/Godzina (w przykładach wykorzystano ustawienia regionalne dla języka polskiego):
Data ogólna — jeśli wartość zawiera tylko datę, nie wyświetla się godzina i odwrotnie: jeśli wartość zawiera tylko godzinę, nie wyświetla się data. Daty wyświetlają się z wykorzystaniem formatu Data krótka (rrrr-mm-dd) natomiast godziny jako Godzina długa.
Data długa — 13 czerwca 2013.
Data średnia — 13-cze-2013.
Data krótka — 2012-05-13.
Godzina długa — 9:21:17.
Godzina średnia — 09:21.
Godzina krótka — 09:21.
Na format dat i godzin mają wpływ opcje regionalne w panelu sterowania systemu Windows. Niestandardowe formaty danych typu Data/Godzina
Formaty niestandardowe tworzy się poprzez zdefiniowanie ciągu specyfikacji zawierającego następujące symbole: :
(dwukropek) — oddziela elementy godziny (godziny, minuty, sekundy).
/
(prawy ukośnik) — oddziela elementy daty (dni, miesiące, lata).
c
— instrukcja dla Accessa używania formatu Data ogólna.
d
— wyświetla dzień miesiąca w postaci jednej lub dwóch cyfr (1 – 31).
dd
— wyświetla dzień miesiąca w postaci dwóch cyfr (01 – 31).
ddd
— wyświetla skrót nazwy dnia tygodnia (N, Pn, Wt, Śr, Cz, Pt, So).
— wyświetla pełną nazwę dnia tygodnia (niedziela, poniedziałek, wtorek, środa, czwartek, piętek, sobota).
dddd
ddddd
— wykorzystanie wbudowanego formatu Data krótka.
dddddd
— wykorzystanie wbudowanego formatu Data długa.
Rozdział 3. Tworzenie tabel w
— wyświetla dzień tygodnia w postaci liczby.
ww m
91
— wyświetla numer tygodnia w roku.
— wyświetla numer miesiąca w roku w postaci jednej lub dwóch cyfr.
— wyświetla numer miesiąca w roku w postaci dwóch cyfr (z wiodącym zerem, jeśli jest taka potrzeba).
mm
— wyświetla trzyznakowy skrót nazwy miesiąca (sty, lut, mar, kwi, maj, cze, lip, sie, wrz, paź, lis, gru).
mmm
mmmm
— wyświetla pełną nazwę miesiąca (np. styczeń).
q
— wyświetla numer kwartału w roku odpowiadający wpisanej dacie.
y
— wyświetla numer dnia w roku (1 – 366).
yy
— wyświetla rok w postaci dwóch cyfr (np. 12).
yyyy h
— wyświetla godzinę w postaci jednej lub dwóch cyfr (0 – 23).
hh n
— wyświetla godzinę w postaci dwóch cyfr (00 – 23).
— wyświetla minuty w postaci jednej lub dwóch cyfr (0 – 59).
nn s
— wyświetla rok w postaci czterech cyfr (np. 2012).
— wyświetla minuty w postaci dwóch cyfr (00 – 59).
— wyświetla sekundy w postaci jednej lub dwóch cyfr (0 – 59).
ss
— wyświetla sekundy w postaci dwóch cyfr (00 – 59).
— czas dwunastogodzinny z oznaczeniem przed- i popołudnia ustalanym na podstawie ustawień regionalnych z panelu sterowania.
AMPM
Formaty danych typu Krótki tekst i Długi tekst
Specyfikatory formatów zastosowane w odniesieniu do pól typu Krótki tekst precyzują sposób wyświetlania danych zapisanych w polach. W tabeli tblCustomers zastosowano kilka formatów. W polu tekstowym State wprowadzono symbol > we właściwości Format po to, by wyświetlać dane wielkimi literami. W polu Active zastosowano format Tak/Nie oraz właściwość Typ formantu na zakładce Odnośnik ustawioną na wartość Pole tekstowe. Pola typu Krótki tekst i Długi tekst domyślnie wyświetlają się w postaci zwykłego tekstu. Jeśli dla pola Krótki tekst i Długi tekst ma być zastosowany specyficzny format, do utworzenia specyfikatora formatu można użyć następujących symboli:
92
Część II Tabele Accessa @
— wymagany znak bądź spacja.
&
— znak opcjonalny (nieobowiązkowy).
<
— zamienia wszystkie litery na małe.
>
— zamienia wszystkie litery na wielkie.
Specyfikatory formatu definiowane przez użytkowników mogą składać się z trzech różnych sekcji oddzielonych od siebie średnikami:
Pierwsza część — specyfikator pól zawierających tekst.
Druga część — format pól zawierających ciągi o zerowej długości.
Trzecia część — format dla pól zawierających wartości null.
Jeśli specyfikator formatu zawiera tylko dwie części, druga część dotyczy zarówno ciągów zerowej długości, jak i wartości null. Na przykład poniższy specyfikator powoduje wyświetlenie ciągu „Brak” w przypadku, gdy w polu nie zapisano żadnego ciągu znaków, oraz „Nieznany”, jeśli w polu występuje wartość null. W pozostałych przypadkach wyświetla się zwykły tekst zapisany w polu: @;"Brak";"Nieznany"
Kilka przykładów niestandardowych formatów tekstowych (dla ustawień regionalnych dla języka polskiego) zamieszczono w tabeli 3.5. Tabela 3.5. Przykłady formatów Zdefiniowany format
Wpisane dane
Wyświetlane sformatowane dane
>
Jan Kowalski
JAN KOWALSKI
<
Jan Kowalski
Jan kowalski
Adam
Ad-am
&-
Ad
-Ad
@;"Pusty"
""
Pusty
@;"Pusty"
Null
Pusty
-
Formaty danych Tak/Nie
W polu typu Tak/Nie wyświetlają się słowa Tak, Nie, Prawda, Fałsz, Wł, Wył w zależności od wartości zapisanej w polu oraz ustawienia właściwości Format dla pola. W Accessie występują następujące, dość oczywiste, specyfikacje formatów dla pól typu Tak/Nie: Tak/Nie
— wyświetla Tak lub Nie.
Prawda/Fałsz Wł/Wył
— wyświetla Prawda lub Fałsz.
— wyświetla Wł lub Wył.
Ciągi Tak, Prawda i Wł oznaczają wartość twierdzącą, natomiast Nie, Fałsz i Wył to wartości przeciwne (zaprzeczenia).
Rozdział 3. Tworzenie tabel
93
W Accessie dane typu Tak/Nie są przechowywane w inny sposób niż można by się spodziewać. Dane oznaczające Tak przechowywane są jako wartości –1, a dane oznaczające Nie — jako wartości 0. Można by przypuszczać, że będą to wartości 1 i 0, ale jest inaczej. Jeśli dla pola nie zdefiniowano formatu, Access wyświetla i zapisuje wartości -1 i 0. Niezależnie od ustawionego formatu dane w polach typu Tak/Nie można wpisywać za pomocą dowolnych słów z wbudowanych formatów lub jako liczby. Aby wprowadzić wartość „nie”, należy wpisać Fałsz, Nie, Wył lub 0. W celu wprowadzenia wartości „tak” należy wpisać Prawda, Tak, Wł lub dowolną liczbę różną od zera. Jeśli wprowadzisz liczbę inną niż 0 lub -1, Access przekształci ją na -1. Dla pól typu Tak/Nie można również zdefiniować własny format. Załóżmy na przykład, że mamy tabelę zawierającą pole wskazujące na to, czy pracownik uczestniczył w szkoleniu. Chociaż można by wykorzystać odpowiedzi Tak i Nie, można też użyć bardziej wyszukanego sposobu wyświetlania. Do wyświetlania wartości w polu Tak/Nie domyślnie wykorzystuje się pole wyboru (pole zaznaczone oznacza Tak). W celu zdefiniowania niestandardowego wyglądu pola typu Tak/Nie należy ustawić jego właściwość Format zgodnie z poniższym wzorcem: ;"Tekst dla wartości Tak";"Tekst dla wartości Nie"
Zwróćmy uwagę na średnik-wypełniacz na początku tego ciągu. Zauważmy też, że wszystkie elementy tekstowe trzeba ująć w cudzysłów. W przypadku tabeli danych o pracownikach można użyć następującego specyfikatora właściwości Format: ;"Uczestniczył w szkoleniu";"Musi wziąć udział w szkoleniu"
Aby zmienić domyślny sposób wyświetlania — pole wyboru — na tekst, trzeba również ustawić właściwość Typ formantu pola Tak/Nie na wartość Pole tekstowe. Formaty danych typu Hiperłącze
Hiperłącza Access także przechowuje i wyświetla w sposób niezgodny z oczekiwaniami. Format dla tego typu danych składa się z trzech części (rozdzielonych znakiem kratki — #):
Tekst wyświetlany — napis wyświetlany w polu lub formancie.
Adres — ścieżka dostępu do pliku (UNC) lub strony internetowej (URL).
Podadres — dokładna lokalizacja w obrębie pliku lub strony.
W polach lub formantach widoczny jest tylko Tekst wyświetlany, a Adres i Podadres są ukryte. W poniższym przykładzie tekst wyświetlany to „Strona WWW Microsoft MSN”, natomiast adres hiperłącza to http://www.msn.com. Strona WWW Microsoft MSN#http://www.msn.com
Maska wprowadzania Właściwość Maska wprowadzania ułatwia wprowadzanie danych w prawidłowym formacie. Maska wprowadzania ogranicza sposób, w jaki użytkownik wprowadza dane w aplikacji. Na przykład można pozwolić użytkownikowi na wprowadzanie wyłącznie
94
Część II Tabele Accessa
cyfr w polach numeru telefonu, NIP-u i identyfikatora pracownika. Maska wprowadzania dla NIP-u może mieć następującą postać: "000-000-00-00". Maska ta nakłada obowiązek wpisania wszystkich cyfr bez używania spacji i innych znaków. Maska wprowadzania zdefiniowana na poziomie właściwości pola jest wykorzystywana wszędzie tam, gdzie pole jest używane (kwerendy, formularze, raporty). Wartość właściwości Maska wprowadzania jest ciągiem znaków składającym się z trzech części, oddzielonych od siebie średnikami:
Pierwsza część — zawiera właściwą maskę składającą się z symboli zamieszczonych poniżej.
Druga część — informuje Accessa o tym, czy należy zapisywać literały zawarte w masce razem z pozostałymi danymi. Na przykład w masce wprowadzania mogą się znaleźć kreski oddzielające poszczególne części NIP-u, natomiast maska dla numeru telefonu może zawierać nawiasy i kreski. Wartość 0 (zero) powoduje zapisywanie literałów wewnątrz danych, natomiast wartość 1 powoduje zapisanie wyłącznie wprowadzonych danych.
Trzecia część — definiuje znak-wypełniacz, który informuje użytkownika o liczbie znaków w obszarze wprowadzania. W wielu maskach wprowadzania wykorzystuje się w tej roli znaki kratki (#) lub gwiazdki (*).
W definicji masek wprowadzania można używać następujących znaków: 0
— obowiązkowa cyfra, nie można użyć znaku plus (+) ani minus (-).
9
— opcjonalna cyfra, nie można użyć znaku plus (+) ani minus (-).
— opcjonalna cyfra lub spacja. Spacje są usuwane podczas zapisywania danych w tabeli. Znaki plus i minus są dozwolone.
# L
— obowiązkowa litera A – Z.
?
— opcjonalna litera A – Z.
A
— obowiązkowy znak lub cyfra.
a
— opcjonalny znak lub cyfra.
&
— obowiązkowy dowolny znak lub spacja.
C
— opcjonalny dowolny znak lub spacja.
.
(kropka) — kropka dziesiętna.
,
(przecinek) — separator tysięcy.
:
(dwukropek) — separator dat i godzin.
;
(średnik) — znak separatora.
-
(myślnik) — znak separatora.
/
(prawy ukośnik) — znak separatora.
<
(mniejszy niż) — zamienia wszystkie następne znaki na małe litery.
Rozdział 3. Tworzenie tabel >
95
(większy niż) — zamienia wszystkie następne znaki na wielkie litery.
(wykrzyknik) — powoduje wyświetlanie maski od prawej do lewej. Znaki wypełniają maskę od prawej do lewej.
! \
(lewy ukośnik) — wyświetla kolejny znak dosłownie.
Tych samych specyfikatorów można używać w arkuszu właściwości pola w kwerendzie lub formularzu. Maski wprowadzania są ignorowane podczas importowania lub dodawania danych do tabeli za pomocą kwerendy funkcjonalnej. Właściwość Format zdefiniowana dla pola przesłania właściwość Maska wprowadzania. W takim przypadku maska wprowadzania ma zastosowanie podczas wprowadzania danych. Po zakończeniu wprowadzania format zmienia się zgodnie ze specyfikatorem formatu. Kreator masek wprowadzania
Chociaż maski wprowadzania można definiować ręcznie, to można również w łatwy sposób określić je dla pól typu Tekst lub Data/Godzina za pomocą Kreatora masek wprowadzania. Kliknięcie pola właściwości Maska wprowadzania powoduje wyświetlenie przycisku Konstruuj (z trzema kropkami). Aby uruchomić kreator, należy kliknąć ten przycisk. Jego pierwszy ekran zamieszczono na rysunku 3.8. Rysunek 3.8. Kreator masek wprowadzania służący do definiowania masek dla pól tekstowych oraz przechowujących daty
Kreator masek wprowadzania wyświetla nie tylko nazwy wszystkich predefiniowanych masek, ale także przykłady każdej z nich. Można wybrać dowolną z oferowanych masek, a po kliknięciu w polu Próbuj można sprawdzić, jak będzie przebiegało wprowadzanie danych. Po wybraniu maski wprowadzania kolejny ekran kreatora umożliwia dostosowanie jej do indywidualnych potrzeb i określenie symbolu zastępczego, np. znaku kratki (#) lub znaku „małpy” (@). Kolejny ekran zawiera pytanie, czy przechowywać znaki specjalne razem z danymi (np. kreski dla NIP-ów). Po zakończeniu pracy z kreatorem Access umieści zdefiniowaną maskę w polu odpowiedniej właściwości.
96
Część II Tabele Accessa Można utworzyć własne maski wprowadzania dla pól tekstowych oraz typu Data/Godzina, klikając przycisk Edytuj listę na pierwszym ekranie kreatora, a następnie wpisując czytelną nazwę, maskę wprowadzania, znak symbolu zastępczego oraz dane przykładowe. Po utworzeniu nowa maska będzie dostępna przy każdym uruchomieniu kreatora.
Można zdefiniować dowolną liczbę masek wprowadzania. Można także określić ustawienia międzynarodowe, co umożliwia pracę z maskami charakterystycznymi dla różnych krajów. Niestandardowa maska wprowadzania utworzona w jednej bazie jest też dostępna w innych. Tytuł Właściwość Tytuł decyduje o ciągu znaków, jaki się pojawi na domyślnej etykiecie dołączonej do formantu po przeciągnięciu pola z listy pól do formularza lub raportu. Tytuły wyświetlają się również jako nagłówki kolumn w widoku arkusza danych tabeli lub kwerendy zawierającej pole. Podczas używania właściwości Tytuł należy zachować ostrożność. Ponieważ tekst tytułu wyświetla się jako nagłówek kolumny w widoku arkusza danych, nagłówek kolumny w widoku arkusza danych kwerendy może wprowadzać w błąd. Kiedy pole występuje w kwerendzie, użytkownik nie ma bezpośredniego dostępu do właściwości pola, zatem musi pamiętać, że o nagłówku kolumny decyduje właściwość Tytuł, która nie musi być związana z nazwą pola. Aby było jeszcze trudniej, tytuł przypisany w widoku projektu tabeli oraz tytuł definiowany w arkuszu właściwości pola w widoku projektu kwerendy to dwie różne właściwości, które mogą zawierać różne teksty.
Maksymalna długość tytułu wynosi 2048 znaków, co w zupełności wystarcza dla większości opisów. Reguła sprawdzania poprawności i Tekst reguły sprawdzania poprawności Właściwość Reguła poprawności definiuje wymagania wprowadzania danych do pola. Reguła sprawdzania poprawności, nad której przestrzeganiem czuwa silnik bazy danych ACE, zapewnia zgodność danych wprowadzanych do tabeli z wymaganiami aplikacji. Właściwości dotyczące sprawdzania poprawności pól to doskonały sposób na to, by wymusić przestrzeganie reguł biznesowych — używając ich można na przykład nie dopuścić do sprzedaży produktu za zero złotych albo nie pozwolić na to, by data oceny pracownika była wcześniejsza od daty jego zatrudnienia. Sprawdzanie poprawności danych wprowadzonych do pól i formantów następuje zawsze wtedy, kiedy pole jest wykorzystywane w aplikacji. Wartość właściwości Reguła poprawności to ciąg znaków zawierający wyrażenie używane do sprawdzania danych wprowadzanych przez użytkowników. Wyrażenie spełniające rolę właściwości Reguła poprawności nie może zawierać funkcji zdefiniowanych przez użytkownika ani żadnych funkcji domeny Accessa bądź funkcji agregacji (DCount, DSum itp.). Reguła sprawdzania poprawności dla pola nie może zawierać odwołań do formularzy, kwerend lub innych tabel w aplikacji (ograniczenia te nie dotyczą reguł sprawdzania poprawności stosowanych w odniesieniu do formantów formularzy). Reguły sprawdzania poprawności dla pól nie mogą zawierać odwołań do innych pól w tabeli,
Rozdział 3. Tworzenie tabel
97
ale reguła sprawdzania poprawności zastosowana do rekordu w tabeli może odwoływać się do pól w tej samej tabeli (regułę sprawdzania poprawności poziomu rekordu ustawia się w arkuszu właściwości tabeli, a nie dla indywidualnych pól). Właściwość Tekst reguły spr. poprawności zawiera ciąg, który wyświetla się w oknie komunikatu w przypadku, gdy dane wprowadzone przez użytkownika nie spełniają wymagań określonych za pomocą właściwości Reguła poprawności. Maksymalny rozmiar właściwości Tekst reguły spr. poprawności wynosi 255 znaków. W przypadku korzystania z właściwości Reguła poprawności zawsze należy pamiętać o zdefiniowaniu tekstu reguły, by uniknąć wyświetlania ogólnego komunikatu Accessa w przypadku naruszenia reguły sprawdzania poprawności danych. Właściwość Tekst reguły spr. poprawności należy wykorzystać w celu wyświetlenia użytkownikom komunikatu z informacjami o dozwolonych wartościach. Na rysunku 3.9 pokazano okno komunikatu wyświetlane w przypadku przekroczenia wartości określonej przez właściwość Reguła poprawności dla pola CreditLimit. Rysunek 3.9. Okno komunikatu reguły sprawdzania poprawności pojawia się, kiedy użytkownik wpisze w polu wartość, która nie spełnia reguły zdefiniowanej w projekcie tabeli
Właściwość Reguła poprawności nie ma zastosowania do pól wyboru, przycisków opcji bądź przełączników w obrębie grupy opcji w formularzu. Grupa opcji ma własną właściwość Reguła poprawności, która dotyczy wszystkich formantów w obrębie grupy. Reguły sprawdzania poprawności często wykorzystuje się po to, by zapewnić, że pewne daty przypadają po innych datach (np. data przejścia pracownika na emeryturę musi być późniejsza od daty przyjęcia go do pracy), a także po to, by uniemożliwić wprowadzanie liczb ujemnych w polach stanów magazynowych lub by zapewnić wprowadzanie wartości należących do zdefiniowanego zakresu liczbowego bądź tekstowego. Daty używane w wyrażeniach Accessa (np. we właściwości Reguła poprawności) mają po obu stronach ograniczniki w postaci znaków kratki (#). Aby wprowadzić ograniczenie dla danych wprowadzanych w polu LastSalesDate do dat między 1 stycznia 2013 a 31 grudnia 2014, należy wpisać regułę Between #1/1/13# and #12/31/14#. Aby górnym limitem wprowadzanych dat była data bieżąca, można wprowadzić regułę sprawdzania poprawności mającą postać Between #1/1/2013# and Date(), gdzie Date() to wbudowana funkcja języka VBA zwracająca bieżącą datę. Z powodzeniem można jej używać w regułach sprawdzania poprawności lub innych wyrażeniach.
Po przeciągnięciu pola zawierającego regułę sprawdzania poprawności do formularza właściwość Reguła poprawności nowego formantu wyświetlana w jego arkuszu właściwości nie jest ustawiana na regułę sprawdzania poprawności pola zdefiniowaną na poziomie tabeli. Jeśli nie wprowadzi się nowej reguły sprawdzania poprawności w arkuszu właściwości formantu, Access zastosuje regułę ustawioną na poziomie tabeli.
98
Część II Tabele Accessa
Sprawdzanie poprawności zawartości pól i formantów następuje w momencie, kiedy fokus opuszcza pole tabeli lub formant formularza. Reguły sprawdzania poprawności stosowane zarówno do pola tabeli, jak i do formantu formularza powiązanego z polem są wymuszane dla obu tych elementów. Reguła poziomu tabeli stosowana jest podczas edycji danych w powiązanym formancie w czasie, kiedy fokus opuszcza formant. Reguł sprawdzania poprawności z poziomu tabeli nie można stosować dla powiązanych tabel zewnętrznych, takich jak FoxPro, Paradox lub dBASE. W powiązanych zewnętrznych tabelach należy stosować reguły sprawdzania poprawności dla formantów powiązanych z polami. Wymagane Właściwość Wymagane wskazuje na to, czy Access ma wymagać wprowadzenia wartości w polu. Ustawienie jej na wartość Tak oznacza, że wprowadzenie wartości w polu tabeli lub formancie formularza związanym z polem jest obowiązkowe. Wymagane pole nie może mieć wartości null. Właściwość Wymagane jest nieprawidłowa dla pól typu Autonumerowanie. Domyślnie wszystkim polom tego typu jest przypisywana wartość podczas tworzenia nowego rekordu. Przestrzeganie właściwości Wymagane kontroluje silnik bazy danych Accessa. Jeśli użytkownik spróbuje opuścić formant pola tekstowego związanego z polem o właściwości Wymagane ustawionej na Tak, generowany jest komunikat o błędzie. Właściwości tej można używać w połączeniu z właściwością Zerowa dł. dozwolona w celu sprawdzenia, czy wartość w polu jest nieznana, czy nie istnieje. Zerowa dł. dozwolona Właściwość Zerowa dł. dozwolona decyduje o tym, czy w polu typu Krótki tekst lub Długi tekst dozwolone jest wprowadzanie ciągów zerowej długości (""). Właściwość ta przyjmuje następujące wartości: Tak
— wprowadzanie ciągów o zerowej długości jest dozwolone.
— wprowadzanie ciągów zerowej długości jest niedozwolone. W przypadku braku prawidłowych danych tekstowych do tabeli wstawiana jest wartość null.
Nie
Odpowiednia kombinacja właściwości Zerowa dł. dozwolona i Wymagane umożliwia rozróżnienie między brakiem danych (który najczęściej reprezentuje się za pomocą ciągu zerowej długości) a nieznaną wartością danych (którą zwykle zapisuje się za pomocą wartości null). W niektórych przypadkach trzeba zapisać właściwą wartość w polu typu Krótki tekst lub Długi tekst. Przykładem nieistniejących danych jest przypadek klienta, którego adres e-mail nie jest znany. Pole z adresem e-mail należy ustawić na pusty ciąg (zerowej długości), co oznacza, że wiemy, iż użytkownik ma adres e-mail, ale go nie znamy. Inny klient, całkowicie nowy dla firmy, powinien mieć wartość null w polu z adresem e-mail, co oznacza, że nie wiemy, czy posiada adres e-mail.
Rozdział 3. Tworzenie tabel
99
Maska wprowadzania ułatwia użytkownikom aplikacji rozpoznanie sytuacji, w której w polu jest wartość null. Na przykład można tak ustawić maskę wprowadzania, aby w przypadku, gdy w polu znajduje się ciąg zerowej długości, wyświetlał się ciąg „Zapytaj klienta”, a gdy pole zawiera wartość null, pojawiał się ciąg „Brak danych”. Właściwość Wymagane określa, czy w polu można wprowadzać wartość null, natomiast właściwość Zerowa dł. dozwolona umożliwia wprowadzanie w polu ciągów zerowej długości. Użyte razem te dwie niezależne właściwości tworzą mechanizm umożliwiający stwierdzenie, czy wartość jest nieznana, czy jej nie ma. Interakcje między właściwościami Wymagane i Zerowa dł. dozwolona są dość złożone. W tabeli 3.6 zestawiono możliwości kombinacji tych właściwości, które mają na celu stworzenie obowiązku wprowadzania wartości w polu lub umożliwienie wprowadzania w nim ciągów zerowej długości lub wartości null. Tabela 3.6. Interakcje między właściwościami Wymagane i Zerowa dł. dozwolona Zerowa dł. dozwolona
Wymagane
Dane wpisane przez użytkownika
Dane zapisane w bazie danych
Nie
Nie
Null
Null
Nie
Nie
Spacja
Null
Nie
Nie
Ciąg zerowej długości
Zabroniona
Tak
Nie
Null
Null
Tak
Nie
Spacja
Null
Tak
Nie
Ciąg zerowej długości
Ciąg zerowej długości
Nie
Tak
Null
Zabroniona
Nie
Tak
Spacja
Zabroniona
Nie
Tak
Ciąg zerowej długości
Zabroniona
Tak
Tak
Null
Zabroniona
Tak
Tak
Spacja
Ciąg zerowej długości
Tak
Tak
Ciąg zerowej długości
Ciąg zerowej długości
Indeksowane Właściwość Indeksowane informuje Accessa o tym, że pole będzie wykorzystywane jako indeks w tabeli. Pola indeksowane mają wewnętrzną strukturę, która zapewnia przyspieszenie kwerend oraz operacji sortowania i grupowania. Jeśli jakieś pole często występuje w kwerendach (np. identyfikator pracownika lub NIP) lub jeśli często się je wykorzystuje w operacjach sortowania bądź grupowania w raportach, należy ustawić jego właściwość Indeksowane na wartość Tak. Dozwolone są następujące ustawienia właściwości Indeksowane: Nie
— pole nie jest indeksowane (wartość domyślna).
100
Część II Tabele Accessa
— pole jest indeksowane i Access zezwala na występowanie w kolumnie duplikatów. Jest to odpowiednie ustawienie na przykład dla nazwisk, jeśli zachodzi prawdopodobieństwo wystąpienia w tabeli takich nazwisk jak Kowalski więcej niż raz.
Tak (Duplikaty OK)
— pole jest poindeksowane i duplikaty w kolumnie są niedozwolone. Wartość tę wykorzystuje się w odniesieniu do danych, które muszą być niepowtarzalne, np. NIP-ów, identyfikatorów pracowników lub numerów klientów.
Tak (Bez duplikatów)
Więcej informacji na temat indeksów można znaleźć w dalszej części tego rozdziału. Oprócz klucza głównego można poindeksować tyle pól, ile trzeba do zapewnienia optymalnej wydajności. Access zezwala na zdefiniowanie do 32 indeksów na tabelę. Należy pamiętać, że z zastosowaniem każdego z indeksów wiąże się pewna strata wydajności w miarę dodawania kolejnych rekordów do tabeli. Access dynamicznie aktualizuje informacje dotyczące indeksów po dodaniu każdego nowego rekordu. Jeśli w tabeli zdefiniuje się zbyt wiele indeksów, dodanie każdego nowego rekordu będzie się wiązało ze znacznymi opóźnieniami. Właściwość Indeksowane można ustawić w arkuszu właściwości pola lub tabeli. W celu ustawienia indeksów składających się z wielu pól trzeba koniecznie skorzystać z arkusza właściwości tabeli. Indeksy tego rodzaju omówiono w dalszej części rozdziału. Opcja automatycznego indeksowania
W oknie dialogowym Opcje programu Access (Plik/Opcje/Projektanci obiektu) jest opcja Autoindeksowanie przy importowaniu/tworzeniu, której włączenie powoduje automatyczne indeksowanie przez Access określonych pól po ich dodaniu do projektu tabeli. Domyślnie pola, które zaczynają się lub kończą na ID, klucz, kod, num (np. IDPracownika lub Kod zadania), są automatycznie indeksowane w momencie utworzenia pola. Przy każdym dodaniu nowego rekordu do tabeli dane z pola są uwzględniane w indeksie. Aby także inne pola były automatycznie indeksowane w momencie ich tworzenia, należy dodać nowe wartości obok pola wyboru Autoindeksowanie przy importowaniu/tworzeniu w zakładce Projektanci obiektu okna dialogowego Opcje programu Access (rysunek 3.10).
Rysunek 3.10. Obszar Projekt tabeli w oknie dialogowym Opcje programu Access zawiera opcje umożliwiające ustawienie specyfikatora Autoindeksowanie przy importowaniu/tworzeniu
Rozdział 3. Tworzenie tabel
101
Kiedy należy stosować indeksowanie?
Ogólnie rzecz biorąc, należy indeksować pola, które są często wykorzystywane przy wyszukiwaniu bądź sortowaniu. Trzeba pamiętać, że indeksy spowalniają niektóre operacje, na przykład wprowadzanie rekordów do tabeli czy wykonywanie niektórych kwerend funkcjonalnych. Pól typu Długi tekst i Obiekt OLE nie można indeksować. Access nie pozwala na utrzymywanie indeksów dla tych typów danych. Indeksu nie należy stosować, jeśli pole zawiera tylko kilka niepowtarzalnych wartości. Na przykład nie osiągnie się znaczących korzyści z poindeksowania pola zawierającego informacje o płci osoby czy województwie zamieszkania bądź pola typu Tak/Nie. Ponieważ tego typu pola mogą zawierać wartości z ograniczonego zbioru, Access z łatwością sortuje zapisane w nich dane. Z indeksów składających się z wielu pól należy korzystać w przypadkach, kiedy operacje sortowania są jednocześnie wykonywane według wielu pól (np. według imienia i nazwiska). W przypadku zdefiniowania takiego indeksu posortowanie tabeli będzie znacznie łatwiejsze.
Właściwości pól tabeli tblCustomers Po zdefiniowaniu nazw pól, typów danych i opisów pól można powrócić do definicji tabeli i dokładniej zdefiniować poszczególne pola. Każde pole zawiera właściwości, które mogą być różne dla różnych typów danych. W tabeli tblCustomers należy zdefiniować właściwości dla kilku typów danych. Na rysunku 3.11 pokazano obszar właściwości pola CreditLimit. Zauważmy, że w oknie właściwości są dwie zakładki — Ogólne i Odnośnik. Rysunek 3.11. Obszar właściwości pola CreditLimit typu Waluta
Wciskanie klawisza F6 powoduje przełączanie między obszarem definicji pola a obszarem właściwości (aby wyświetlić żądany obszar, czasami trzeba wcisnąć klawisz F6 kilka razy). Aby przejść do wybranego obszaru, można również kliknąć na nim myszą. Dla niektórych właściwości dostępna jest lista dopuszczalnych wartości wraz ze strzałką w dół, która wyświetla się w momencie umieszczenia wskaźnika w polu. Kliknięcie strzałki powoduje wyświetlenie dostępnych wartości na liście rozwijanej.
102
Część II Tabele Accessa Na rysunku 3.11 znajduje się 10 właściwości dostępnych dla pola CreditLimit typu Waluta. Dla pól innych typów (Liczba, Data/Godzina, Krótki tekst lub Tak/Nie) liczba opcji może być większa lub mniejsza.
W obszarze właściwości pól okna projektu tabeli jest druga zakładka, a mianowicie Odnośnik. Po jej kliknięciu wyświetla się tylko jedna właściwość — Typ formantu. Właściwość ta ma zastosowanie dla pól typu Krótki tekst, Liczba i Tak/Nie. Okno właściwości odnośnika dla pola Aktywny typu Tak/Nie, gdzie jedyną właściwością jest Typ formantu, przedstawiono na rysunku 3.12. Właściwość tę można zdefiniować jako jedną z trzech wartości: Pole wyboru, Pole tekstowe oraz Pole kombi. Wybierając jedną z nich, decydujemy, jakiego typu formant będzie użyty w chwili umieszczania pola w formularzu. Ogólnie wszystkie formanty są tworzone jako pola tekstowe, z wyjątkiem pól typu Tak/Nie, które domyślnie przyjmują postać pól wyboru. Jednak dla pól typu Tak/Nie także można określić typ formantu jako Pole tekstowe. Można w nim wyświetlać odpowiednie wartości zależne od właściwości Format, np. Tak/Nie, Prawda/Fałsz. Rysunek 3.12. Zakładka Odnośnik dla pola typu Tak/Nie
Więcej informacji na temat pól kombi można znaleźć w rozdziale 19.
W przypadku wykorzystywania pól tekstowych zamiast pól Tak/Nie i jeśli wiadomo, że w polu tekstowym może występować tylko kilka ściśle określonych wartości, jako typ formantu należy wybrać Pole kombi. Okno właściwości odnośnika dla przypadku, kiedy dla pola CreditStatus wybrano pole kombi jako Typ formantu, przedstawiono na rysunku 3.13. Istnieją tylko dwie dozwolone wartości pola CreditStatus: OK i Przekroczony. Te dwie wartości (rozdzielone średnikiem) zostały określone we właściwości Źródło wierszy pola kombi, z kolei właściwość Typ źródła wierszy ustawiono na Lista wartości. Rysunek 3.13. Ustawienie pola kombi jako typu formantu dla pola CreditStatus
Rozdział 3. Tworzenie tabel
103
Chociaż na rysunku 3.13 elementy pola kombi pochodzą z listy wartości, równie dobrze można by określić źródło wierszy pola kombi za pomocą kwerendy bądź instrukcji SQL-a. Rysunek 3.14 przedstawia wygląd pola CreditStatus podczas wyświetlania tabeli tbl Customers w widoku arkusza danych. Użytkownik ma do wyboru tylko dwie wartości statusu kredytu: OK lub Przekroczony. Takie same pole kombi wyświetla się w przypadku dodania pola w formularzu Accessa. Rysunek 3.14. Wykorzystanie pola kombi w roli odnośnika w celu wskazania dozwolonych wartości dla pola
Właściwości dla pól typu Odnośnik są różne dla różnych typów danych. Pola danych typu Tak/Nie różnią się od pól tekstowych czy pól liczbowych. Ponieważ pole typu Odnośnik jest w rzeczywistości polem kombi, to gdy dla pola wybierzemy typ Odnośnik, zostaną wyświetlone standardowe właściwości pól kombi.
Określanie klucza głównego Każda tabela powinna mieć klucz główny — jedno lub więcej pól z niepowtarzalnymi wartościami dla każdego rekordu (w terminologii baz danych zasada ta nazywa się integralnością jednostkową). W tabeli tblCustomers kluczem głównym jest pole CustomerID. Każdy klient ma unikatową wartość pola CustomerID. Dzięki temu silnik bazy danych potrafi rozróżniać rekordy od siebie. Wartość pola CustomerID równa 17 odnosi się do jednego i tylko jednego rekordu w tabeli tblCustomers. Jeżeli nie zdefiniuje się klucza głównego (pola z niepowtarzalnymi wartościami), Access może to zrobić automatycznie.
Wybór klucza głównego Jeżeli nie ma pola CustomerID, to aby uzyskać niepowtarzalność, należałoby utworzyć klucz główny w oparciu o inne pole. Nie można do tego celu wykorzystać pola Company, ponieważ może istnieć dwóch klientów o takiej samej nazwie firmy. Kombinacja pól Company i City (klucz złożony z wielu pól) także nie wchodzi w grę z tego samego powodu: istnieje możliwość, że w jednym mieście istnieją dwie firmy o identycznych nazwach. Trzeba znaleźć pole bądź kombinację pól, które sprawią, że każdy rekord będzie niepowtarzalny.
104
Część II Tabele Accessa
Najłatwiejszym sposobem uporania się z tym problemem jest dodanie pola typu Autonumerowanie w celu wykorzystania go w roli klucza głównego. Klucz główny tabeli tbl Customers to CustomerID — pole typu Autonumerowanie. Jeżeli nie wyznaczy się żadnego pola jako klucza głównego, Access może utworzyć pole typu Autonumerowanie i wyznaczyć je jako klucz główny tabeli. Pola typu Autonumerowanie są dobrymi kluczami głównymi, ponieważ to Access generuje dla nich wartości. Oprócz tego dba o to, by żadna z wartości nie powtórzyła się w obrębie tabeli, oraz nie pozwala na modyfikowanie wartości pól tego typu. Dobry klucz główny charakteryzuje się następującymi cechami:
Klucz główny musi w niepowtarzalny sposób identyfikować każdy rekord.
Klucz główny nie może mieć wartości null.
Klucz główny musi istnieć w momencie tworzenia rekordu.
Definicja klucza głównego musi być stabilna — po jej ustaleniu nie można jej zmieniać.
Klucz główny musi być zwięzły — powinien zawierać jak najmniej atrybutów.
Oprócz tego, że klucze główne w unikatowy sposób identyfikują wiersze w tabeli, charakteryzują się również innymi właściwościami:
Klucz główny zawsze jest indeksem.
Indeksy utrzymują predefiniowaną kolejność jednego lub więcej pól, co znacznie przyspiesza wykonywanie kwerend oraz żądań wyszukiwania i sortowania.
Przy dodawaniu nowych rekordów do tabeli Access sprawdza, czy w polach klucza głównego takie dane już istnieją, a jeśli tak, to nie pozwala na wpisanie powtarzających się danych.
Domyślnie Access wyświetla dane w kolejności określonej przez klucz główny.
Dzięki zdefiniowaniu jako klucza głównego takiego pola, jak CustomerID, dane wyświetlają się w określonej kolejności. Ponieważ w naszym przykładzie typ pola CustomerID to Autonumerowanie, Access przypisuje jego wartość automatycznie w kolejności wprowadzania rekordu do systemu. Idealnym kluczem głównym jest zatem pojedyncze pole, które jest niezmienne i dla którego istnieje gwarancja niepowtarzalności w obrębie tabeli. Z tych powodów w bazie danych MiniAuta dla Kolekcjonerów wykorzystano wyłącznie pola typu Autonumerowanie jako klucze główne dla wszystkich tabel.
Tworzenie klucza głównego Klucz główny można utworzyć na jeden z trzech sposobów. Jeśli tabela jest otwarta w widoku projektu:
Zaznacz pole, które ma wejść w skład klucza głównego, a następnie kliknij przycisk Klucz główny (ikona z kluczem) z grupy Narzędzia na zakładce PROJEKTOWANIE wstążki Accessa.
Rozdział 3. Tworzenie tabel
105
Kliknij pole prawym przyciskiem myszy, a po wyświetleniu menu podręcznego wybierz z niego opcję Klucz główny.
Zapisz tabelę bez wybierania klucza głównego — Access utworzy wtedy automatycznie pole typu Autonumerowanie.
Po wyznaczeniu klucza głównego po lewej stronie wybranych pól, w obszarze selektora, pojawi się symbol klucza, który oznacza, że utworzono klucz główny.
Tworzenie złożonych kluczy głównych Do pełnienia roli klucza głównego tabeli można wyznaczyć kombinację pól. Takie klucze często określa się jako złożone klucze główne. Jak widać na rysunku 3.15, należy zaznaczyć pola, które mają wejść w skład złożonego klucza głównego, a następnie kliknąć ikonę klucza w zakładce NARZĘDZIA na wstążce. Pewnym ułatwieniem jest sytuacja, w której pola wchodzące w skład złożonego klucza głównego leżą obok siebie w widoku projektu tabeli. Rysunek 3.15. Tworzenie złożonych kluczy głównych
Złożone klucze główne są wykorzystywane głównie wtedy, gdy projektant uważa, iż klucze główne powinny składać się z danych, które naturalnie występują w bazie danych. Dawniej uczono projektantów, że w każdej tabeli powinien się znaleźć naturalny klucz główny (dane naturalnie występujące w tabeli). Powodem, dla którego obecnie rzadko się używa złożonych kluczy głównych, jest fakt, że projektanci zdali sobie sprawę z nieprzewidywalności danych. Nawet jeśli użytkownicy zapewniają, że kombinacja określonych pól nigdy się nie powtórzy w tabeli, może się zdarzyć, że praktyka okaże się inna niż plany. Używanie zastępczych kluczy głównych (pól, które naturalnie nie należą do tabeli, np. NIP-u lub identyfikatora pracownika), takich jak pola typu Autonumerowanie, umożliwia oddzielenie projektu tabeli od jej danych. Problem w przypadku naturalnych kluczy głównych (tzn. danych, które naturalnie występują w tabeli) polega na tym, że w przypadku odpowiednio rozbudowanego zbioru danych istnieje prawdopodobieństwo wystąpienia duplikatów wartości pól wybranych jako klucze główne tabeli.
106
Część II Tabele Accessa
Co więcej, w przypadku używania kluczy złożonych utrzymanie relacji między tabelami staje się bardziej skomplikowane, ponieważ trzeba dublować pola we wszystkich tabelach zawierających powiązane ze sobą dane. Używanie złożonych kluczy głównych zwiększa stopień złożoności bazy danych bez jednoczesnej poprawy stabilności, integralności i innych pożądanych własności.
Indeksowanie tabel Rzadko się zdarza (jeśli w ogóle), aby dane były wprowadzane do tabel w sposób uporządkowany. Zazwyczaj rekordy wprowadza się do tabel w sposób całkowicie przypadkowy (z wyjątkiem danych uporządkowanych chronologicznie). Na przykład obciążony system wprowadzania zamówień jednego dnia zbiera informacje dotyczące zamówień wielu klientów. Najczęściej dane te będą wykorzystywane do tworzenia raportu zamówień dla pojedynczego klienta w celu wystawienia faktury lub odczytania zamówionych ilości potrzebnych do zarządzania stanami magazynowymi. Rekordy w tabeli Orders występują jednak w porządku chronologicznym, co nie zawsze pomaga przy tworzeniu raportów dotyczących zamówień klientów. W takim przypadku lepiej by było, gdyby dane były uporządkowane według identyfikatora klienta. Aby dokładniej zilustrować to pojęcie, weźmy za przykład kartoteki Rolodex używane do zapisywania nazwisk, adresów i numerów telefonów. Załóżmy przez moment, że pozycja kart w kartotece jest stała. Można dodać nowe karty, ale tylko na koniec kartoteki. Ograniczenie to oznacza, że wizytówka Jankowskiego może się znaleźć za wizytówką Kowalskiego, a jeszcze dalej znajdzie się wizytówka Brzozowskiego. Mówiąc inaczej, dane w kartotece są nieuporządkowane. Korzystanie z wizytownika Rolodex zawierającego nieposortowane wizytówki byłoby trudne. Trzeba by było przeszukać wszystkie wizytówki, by dotrzeć do tej osoby, która nas interesuje — byłby to bardzo pracochłonny i długotrwały proces. Oczywiście z wizytownika nie korzysta się w ten sposób. W momencie dodawania wizytówki wkładamy ją w miejsce, w którym logicznie powinna się znajdować. Najczęściej oznacza to wstawienie wizytówki do wizytownika w porządku alfabetycznym, według nazwiska. Rekordy do tabel Accessa dodaje się w sposób analogiczny do przykładu z kartoteką o stałej pozycji kart. Nowe rekordy zawsze są dodawane na końcu tabeli, a nie w jej środku, gdzie logicznie powinny się znaleźć. W systemie rejestracji zamówień dobrze by jednak było, gdyby nowe rekordy dotyczące tego samego klienta znajdowały się obok siebie. Niestety, tabele Accessa nie działają w ten sposób. Naturalny porządek tabeli to taki, w jakim dodawano do niej rekordy. Taki porządek czasami określa się jako porządek wprowadzania lub porządek fizyczny dla podkreślenia, że rekordy w tabeli występują w porządku, w jakim dodano je do tabeli. Używanie tabel uporządkowanych w naturalny sposób niekoniecznie jest złe. Naturalny porządek doskonale się sprawdza w przypadku, gdy operacje wyszukiwania są wykonywane rzadko lub gdy tabela jest bardzo mała. Zdarza się również, że dane wprowadzane do tabeli są w dużym stopniu uporządkowane. Jeśli tabela służy do pobierania danych sekwencyjnych (np. odczytów z miernika elektrycznego) i dane te będą wykorzystywane w tym samym porządku, to nie ma potrzeby indeksowania danych.
Rozdział 3. Tworzenie tabel
107
Jednak w przypadkach, kiedy porządek naturalny nie wystarcza, w systemie Microsoft Access występuje mechanizm indeksowania, który przyspiesza wyszukiwanie i sortowanie rekordów. Logiczny porządek rekordów w tabeli definiuje się poprzez utworzenie w niej indeksu. W Accessie indeksy wykorzystuje się w celu utrzymania jednego lub więcej wewnętrznych porządków sortowania danych w tabeli. Na przykład można poindeksować pole LastName często wykorzystywane w kwerendach i procedurach sortowania. Microsoft Access wykorzystuje indeksy w tabeli w sposób, w jaki korzysta się ze skorowidza w książce. Otóż aby znaleźć dane, Access poszukuje ich lokalizacji w indeksie. Najczęściej w tabelach wykorzystuje się jeden lub kilka prostych indeksów. Prosty indeks to taki, który obejmuje jedno pole w tabeli. Proste indeksy umożliwiają ułożenie rekordów tabeli w porządku rosnącym lub malejącym. Tworzy się je poprzez ustawienie właściwości Indeksowane pola na jedną z następujących wartości: Tak (Duplikaty OK); Tak (Bez duplikatów).
Domyślnie w tabelach Accessa nie ma indeksu. Trudno sobie jednak wyobrazić tabelę, która nie wymagałaby użycia żadnego indeksu. W następnym podrozdziale objaśniamy, dlaczego indeksowanie w tabelach Accessa jest tak ważne.
Ważność stosowania indeksów Z danych firmy Microsoft wynika, że w ponad połowie tabel baz danych Accessa nie używa się indeksów. W tej liczbie nie uwzględnia się tabel, które są nieprawidłowo poindeksowane — mowa tylko o tych tabelach, w których wcale nie ma indeksów. Wygląda na to, że wiele osób nie docenia ważności indeksowania tabel w bazach danych Accessa. Aby zademonstrować możliwości i wartość indeksów, w przykładach dołączonych do tej książki zamieszczona została baza danych IndexTest.accdb. Znajdują się w niej dwie identyczne tabele zawierające w przybliżeniu po 355 000 losowych słów. Jedną tabelę poindeksowano według pola Word, druga zaś nie jest poindeksowana. Prosty formularz (zobacz rysunek 3.16) umożliwia odpytywanie tabeli z indeksem lub bez indeksu i obserwowanie, ile milisekund trwało wyszukiwanie w każdym przypadku. Rysunek 3.16. Formularz frmIndexTest zapewnia szybki i łatwy sposób przekonania się o ważności indeksów
Seria testów wykazała, że w spójnie poindeksowanej tabeli wyszukiwanie słowa zajmuje mniej niż 20 milisekund, podczas gdy wyszukiwanie w tabeli niepoindeksowanej zajmuje od 200 do 350 milisekund. Uzyskanie wyniku pokazanego na rysunku 3.16 prawie
108
Część II Tabele Accessa
w ogóle nie zajmuje czasu i nie zwiększa całkowitego czasu wymaganego do uruchomienia zapytania. Nie trzeba dodawać, że czas potrzebny do wykonania kwerendy zależy w dużej mierze od sprzętu komputerowego, jednak dodanie do tabeli indeksu pozwala na osiągnięcie zysku wydajności sięgającego nawet ponad 500 procent. Ponieważ zdefiniowanie indeksu powoduje, że Access wewnętrznie utrzymuje porządek sortowania według danych zapisanych w poindeksowanym polu, oczywisty staje się powód, dla którego wprowadzenie indeksu powoduje poprawę wydajności. Indeksować powinno się praktycznie wszystkie pola, które często wykorzystuje się w kwerendach lub według których często wykonuje się sortowanie w formularzach lub raportach. Bez zdefiniowania indeksu Access musi przeszukiwać wszystkie rekordy w bazie danych w poszukiwaniu danych spełniających kryteria. Proces ten nazywa się skanowaniem tabeli i jest analogiczny do przeszukiwania każdej wizytówki w kartotece Rolodex w celu znalezienia wizytówek wszystkich osób pracujących dla określonej firmy. Jeśli nie przejrzy się wszystkich wizytówek, nie będzie się miało pewności, że udało się znaleźć wszystkie wizytówki spełniające nasze kryteria. Jak wspomniano we wcześniejszej części tego rozdziału, pola, które są kluczami głównymi tabeli, zawsze są poindeksowane. Jest tak dlatego, że klucze główne służą do wyszukiwania rekordów w tabeli. Dzięki poindeksowaniu ich Access znacznie łatwiej znajdzie żądane rekordy zarówno w bieżącej tabeli, jak i w zewnętrznej tabeli powiązanej z bieżącą. Gdyby indeks nie został zdefiniowany, Access musiałby przeszukać wszystkie rekordy w obcej tabeli, aby mieć pewność, że odnalazł wszystkie powiązane rekordy. Obniżenie wydajności związane z niepoindeksowanymi tabelami może mieć katastrofalny wpływ na ogólną wydajność aplikacji Accessa. Jednym z możliwych rozwiązań problemów z wydajnością aplikacji jest zastosowanie indeksowania.
Indeksy złożone z wielu pól Indeksy złożone z wielu pól, nazywane po prostu indeksami złożonymi, tworzy się bardzo prosto. Wystarczy w widoku projektu kliknąć przycisk Indeksy lub wybrać polecenie Indeksy z menu Widok. Otworzy się okno dialogowe Indeksy (zobacz rysunek 3.17), w którym można określić pola tworzące indeks. Rysunek 3.17. Zastosowanie indeksów złożonych może przyczynić się do poprawy wydajności
Rozdział 3. Tworzenie tabel
109
Wystarczy wprowadzić nazwę indeksu (na rysunku 3.17 jest to CityState) i za pomocą klawisza Tab przełączyć się do kolumny Nazwa pola. Z listy rozwijanej należy wybrać pola tworzące indeks. W tym przypadku jeden indeks tworzą pola City i State. W skład indeksu złożonego wchodzą wszystkie pola bezpośrednio poniżej tego wiersza, dla których nie określono nazwy indeksu. Podczas tworzenia porządku sortowania w tej tabeli Access uwzględnia oba wymienione pola, co przyspiesza wykonywanie kwerend oraz operacje sortowania obejmujące zarówno pole City, jak i pole State. Kolejność pól w indeksie złożonym ma znaczenie. Opisany w tym rozdziale indeks CityState zostanie wykorzystany w Accessie tylko wtedy, gdy w kwerendzie pojawi się pole City (jeśli używane jest tylko pole State, indeks ten nie zapewnia żadnych korzyści).
Indeks złożony może zawierać do dziesięciu pól. Jeśli indeks złożony nie jest używany jako klucz główny tabeli, dowolne z tworzących go pól może być puste. Sposób ustawiania właściwości dla indeksu złożonego zaprezentowano na rysunku 3.18. Należy umieścić kursor w wierszu okna dialogowego Indeksy zawierającego nazwę indeksu. Zwróćmy uwagę na trzy właściwości wyświetlające się w dolnej części okna dialogowego Indeksy. Rysunek 3.18. Ustawianie właściwości indeksów nie jest trudne
Znaczenie właściwości indeksu jest dość oczywiste (właściwości indeksów mają zastosowanie do indeksów złożonych zarówno z jednego, jak i z wielu pól):
Podstawowy — ustawienie tej właściwości na Tak powoduje, że Access wykorzystuje indeks w roli klucza głównego tabeli. Jako klucz główny można wyznaczyć więcej niż jedno pole. Należy jednak pamiętać o regułach dotyczących kluczy głównych, w szczególności wymogu niepowtarzalności kluczy głównych oraz tego, że żadne pole wchodzące w skład klucza głównego nie może być puste. Domyślna wartość właściwości Podstawowy to Nie.
Unikatowy — ustawienie tej właściwości na Tak powoduje, że indeks musi być niepowtarzalny w obrębie tabeli. Pole zawierające NIP to dobry kandydat na unikatowy indeks, ponieważ aplikacja może oczekiwać występowania dokładnie jednej wartości wybranego NIP-u w tabeli. Dla porównania pole nazwiska nie jest dobrym kandydatem na unikatowy indeks, gdyż często się zdarza występowanie wielu osób o takich samych nazwiskach, zwłaszcza popularnych, jak Kowalski czy Nowak. W związku z tym próba utworzenia unikatowego indeksu z pola zawierającego nazwisko spowodowałaby tylko kłopoty.
110
Część II Tabele Accessa
W przypadku kluczy złożonych niepowtarzalna musi być kombinacja wartości pól — dla poszczególnych pól wchodzących w skład klucza złożonego mogą występować duplikaty.
Ignoruj zerowe — jeśli poindeksowane pole rekordu zawiera wartość null (co w przypadku kluczy złożonych zdarza się tylko wtedy, gdy wszystkie pola składające się na klucz złożony mają wartość null), indeks rekordu nie wnosi niczego do ogólnego indeksowania. Mówiąc inaczej, jeśli indeks rekordu nie zawiera jakiejś wartości, Access nie potrafi stwierdzić, gdzie należy wstawić rekord na wewnętrznej liście sortowania. Z tego powodu można poinstruować Accessa, aby rekordy z wartością null indeksu były ignorowane. Domyślnie właściwość Ignoruj zerowe jest ustawiona na Nie, co oznacza, że Access wstawia rekordy z wartością indeksu null do list indeksowania razem z innymi rekordami o wartościach indeksu różnych od null.
Należy przetestować wpływ właściwości indeksu na tabele Accessa i wykorzystać te właściwości, które najbardziej odpowiadają potrzebom bazy danych. Określone pole może jednocześnie być zarówno kluczem głównym tabeli, jak częścią indeksu złożonego. Indeksowanie należy stosować w tabelach w miarę potrzeb, tak by uzyskać najlepszą możliwą wydajność i jednocześnie nie nadużyć indeksów oraz nie naruszyć podstawowych reguł indeksowania. Na przykład w takiej bazie danych jak MiniAuta dla Kolekcjonerów numer faktury z tabeli tblSales jest często wykorzystywany w formularzach i raportach, dlatego powinien zostać poindeksowany. Ponadto jest wiele sytuacji, w których numer faktury występuje w kombinacji z innymi polami, np. datą transakcji i identyfikatorem przedstawiciela handlowego. Warto rozważyć dodanie do tabeli transakcji złożonego indeksu składającego się z kombinacji numeru faktury z datą sprzedaży i identyfikatorem przedstawiciela handlowego.
Kiedy należy indeksować tabele? Jeśli w tabeli jest stosunkowo mało rekordów, ponoszenie dodatkowych kosztów związanych z utrzymaniem dodatkowych indeksów (oprócz głównego) może być nieopłacalne. Chociaż wykorzystanie indeksu nieco przyspiesza pobieranie danych, Access musi uaktualniać informacje dotyczące indeksu przy każdej operacji wprowadzania bądź modyfikacji rekordów w tabeli. Z kolei wprowadzanie zmian w niepoindeksowanych polach nie wymaga wykonywania dodatkowych operacji plikowych. Dane z niepoindeksowanych pól można odczytać równie łatwo (choć nie tak szybko) jak z pól poindeksowanych. Ogólnie rzecz biorąc, pomocnicze indeksy warto zdefiniować w przypadku rozbudowanych tabel. W takim przypadku indeksowanie pól innych niż klucz główny przyspiesza operacje wyszukiwania. Jednak nawet w przypadku rozbudowanych tabel indeksowanie może się przyczynić do pogorszenia wydajności, jeśli rekordy w tabeli będą się często zmieniały lub jeśli często będą dodawane nowe rekordy. Każda operacja modyfikacji rekordu lub wprowadzenia nowego rekordu powoduje konieczność aktualizacji wszystkich indeksów w tabeli. Dlaczego mimo wszystkich zalet indeksów nie indeksuje się wszystkich pól w tabeli? Jakie są wady poindeksowania zbyt wielu pól? Czy można nadużyć indeksów w tabeli?
Rozdział 3. Tworzenie tabel
111
Przede wszystkim indeksy nieco zwiększają rozmiar bazy danych Accessa. Niepotrzebne poindeksowanie tabeli zajmuje pewną ilość miejsca na dysku dla każdego rekordu. Co ważniejsze, indeksy powodują obniżenie wydajności operacji dodawania rekordu do tabeli. Ponieważ Access automatycznie aktualizuje indeksy za każdym razem, kiedy rekord jest dodawany (lub usuwany), wprowadzenie każdego nowego rekordu wymaga uaktualnienia wewnętrznego indeksowania. Jeśli w tabeli istnieje dziesięć indeksów, Access dziesięć razy aktualizuje indeksy przy każdej operacji dodawania lub usuwania rekordu. W przypadku rozbudowanych tabel powoduje to zauważalne opóźnienia (szczególnie w przypadku wolnych komputerów). Czasami modyfikacja danych w rekordach powoduje konieczność aktualizacji mechanizmu indeksowania. Jest tak w przypadku, gdy modyfikacja powoduje zmianę pozycji rekordu na liście sortowania lub wyniku kwerendy. Z tego powodu w przypadku pracy z dużymi, ciągle zmieniającymi się zbiorami danych, w których rzadko wykonuje się operacje wyszukiwania, można zrezygnować z indeksowania pól w tabeli lub poindeksować tylko te pola, według których będzie wykonywane wyszukiwanie. Projektanci baz danych Accessa zwykle zaczynają od stosowania najprostszych indeksów, składających się z jednego pola, a następnie, w miarę coraz lepszego poznawania procesu, zaczynają podążać w kierunku indeksów bardziej skomplikowanych. Należy jednak pamiętać o kompromisie między zwiększeniem wydajności wyszukiwania a kosztem obliczeniowym związanym z utrzymywaniem wielu indeksów w tabelach. Należy również pamiętać o tym, że indeksowanie nie modyfikuje fizycznego rozmieszczenia rekordów w tabeli. Naturalny porządek rekordów (porządek, w jakim rekordy dodawano do tabeli) jest utrzymywany także po ustanowieniu indeksu. Proces kompaktowania i naprawy bazy danych Accessa wymusza odtwarzanie indeksów we wszystkich tabelach. Dodatkowo fizycznie przeorganizowuje tabele w plikach .accdb zgodnie z porządkiem klucza głównego. Przeprowadzanie zabiegów konserwacyjnych daje pewność działania baz danych Accessa z maksymalną wydajnością.
Drukowanie struktury tabeli Strukturę tabeli można wydrukować poprzez kliknięcie przycisku Dokumentator bazy danych z grupy Analiza zakładki NARZĘDZIA BAZY DANYCH wstążki Accessa. Grupa Analiza zawiera szereg narzędzi ułatwiających tworzenie dokumentacji obiektów bazy danych. Kliknięcie przycisku Dokumentator bazy danych powoduje wyświetlenie okna dialogowego, w którym można wybrać obiekty przeznaczone do wydrukowania. Na rysunku 3.19 w zakładce Tabele dokumentatora bazy danych wybrano tabelę tblCustomers. Można też ustawić wiele opcji drukowania. Po kliknięciu przycisku Opcje wyświetla się okno dialogowe Drukowanie definicji tabel, w którym można wybrać, jakie informacje na temat struktury tabeli wydrukować (zobacz rysunek 3.20). Mogą to być na przykład nazwy pól, wszystkie ich właściwości, indeksy, a nawet uprawnienia sieciowe. Nie należy wybierać zbyt wielu opcji w oknie dialogowym Drukowanie definicji tabel. Drukowanie wszystkich detali projektu tabeli wiąże się ze zużyciem mnóstwa papieru. Najlepiej wydrukować kilka niezbędnych informacji, a szczegóły dodawać tylko wtedy, gdy jest to konieczne.
112
Część II Tabele Accessa
Rysunek 3.19. Okno dialogowe Dokumentator bazy danych
Rysunek 3.20. Opcje drukowania w oknie dialogowym Drukowanie definicji tabel
Po wybraniu danych do wydrukowania Access generuje raport. Można go przeglądać w widoku podglądu bądź w widoku wydruku albo wysłać do drukarki. Można również zapisać raport w bazie danych jako część dokumentacji aplikacji. Dokumentator bazy danych tworzy tabelę zawierającą wszystkie wybrane obiekty i ich właściwości. Za jego pomocą można tworzyć dokumentację obiektów bazy danych, takich jak formularze, kwerendy, raporty, makra i moduły.
Zapisywanie ukończonej tabeli Ukończoną strukturę tabeli możesz zapisać, wybierając z menu Plik opcję Zapisz lub klikając przycisk Zapisz znajdujący się na pasku narzędzi Szybki dostęp w lewym górnym rogu środowiska Accessa. Jeżeli zapisujemy tabelę po raz pierwszy, Access zapyta o nazwę dla niej. Nazwy tabel mogą mieć do 64 znaków długości i muszą spełniać standardowe kryteria Accessa dotyczące nazw obiektów (nazwy mogą obejmować litery i cyfry, nie mogą rozpoczynać się od cyfry i nie mogą zawierać znaków przestankowych). Tabelę można także zapisać w trakcie jej zamykania. Jeśli tabelę zapisaliśmy wcześniej, a teraz chcemy ją zapisać pod inną nazwą, wystarczy wybrać z menu Plik opcję Zapisz jako, a następnie wpisać wybraną nazwę. Spowoduje
Rozdział 3. Tworzenie tabel
113
to utworzenie nowej struktury tabeli, przy czym istniejąca tabela o pierwotnej nazwie pozostanie nienaruszona. Aby usunąć starą tabelę, należy zaznaczyć ją w okienku nawigacji, a następnie nacisnąć klawisz Delete.
Operacje na tabelach Po utworzeniu wielu tabel można wykorzystać je w innych bazach danych lub skopiować je i używać jako kopii zapasowych. W wielu przypadkach interesuje nas skopiowanie samego projektu tabeli, bez danych. W okienku nawigacji można wykonywać wiele operacji na tabelach. Są to między innymi:
zmiana nazwy tabel,
usuwanie tabel,
kopiowanie tabel w obrębie bazy danych,
kopiowanie tabel do innej bazy danych.
Operacje te można wykonać bezpośrednio lub korzystając z opcji menu.
Zmiana nazwy tabel Nazwę tabeli można zmienić, klikając wybraną tabelę prawym przyciskiem myszy i wybierając opcję Zmień nazwę z menu podręcznego. Po zmianie nazwy tabeli wyświetli się ona na odpowiedniej pozycji na liście tabel posortowanych alfabetycznie. Po zmianie nazwy tabeli trzeba także zmienić tę nazwę we wszystkich obiektach, które się do niej odwołują (kwerendach, formularzach, raportach).
Usuwanie tabel Tabelę można usunąć, zaznaczając ją w okienku nawigacji i naciskając klawisz Delete. Innym sposobem jest kliknięcie tabeli prawym przyciskiem myszy i wybranie polecenia Usuń z menu podręcznego. Tak jak w większości operacji usuwania trzeba potwierdzić zamiar usunięcia poprzez kliknięcie w wyświetlonym oknie dialogowym przycisku Tak. Należy pamiętać, że przytrzymanie klawisza Shift przed wciśnięciem klawisza Delete spowoduje usunięcie tabeli (lub dowolnego innego obiektu bazy danych) bez wyświetlania potwierdzenia, Kombinacja klawiszy Shift+Delete jest przydatna do usuwania obiektów bazy danych. Może ona być jednak niebezpieczna w przypadku niezbyt ostrożnego korzystania z niej.
Kopiowanie tabel w obrębie bazy danych Dowolną tabelę w bazie danych można skopiować za pomocą opcji wycinania i wklejania z grupy Schowek na zakładce NARZĘDZIA GŁÓWNE. Podczas wklejania tabeli do bazy danych wyświetla się okno dialogowe Wklejanie tabeli jako. W tym oknie należy wybrać jedną z trzech opcji:
114
Część II Tabele Accessa
Tylko struktura — wybranie pierwszej opcji spowoduje utworzenie nowej pustej tabeli o tej samej strukturze co kopiowana tabela. Za pomocą tej opcji zwykle tworzy się tabele tymczasowe lub archiwalne, do których można kopiować stare rekordy.
Struktura i dane — powoduje utworzenie kompletnej kopii struktury wybranej tabeli razem ze wszystkimi danymi.
Dołącz dane do istniejącej tabeli — powoduje dodanie danych z wybranej tabeli na końcu innej tabeli. Jest to przydatne w sytuacjach łączenia ze sobą tabel, na przykład w przypadku dodawania danych dotyczących transakcji miesięcznych do tabeli zawierającej dane z całego roku.
Aby skopiować tabelę, wykonaj następujące czynności: 1. Kliknij prawym przyciskiem myszy nazwę tabeli w okienku nawigacji i wybierz polecenie Kopiuj z menu podręcznego lub kliknij przycisk Kopiuj w grupie Schowek na zakładce NARZĘDZIA GŁÓWNE. 2. Wybierz polecenie Wklej z menu podręcznego lub kliknij przycisk Wklej w grupie Schowek na zakładce NARZĘDZIA GŁÓWNE. Pojawi się okno dialogowe Wklejanie tabeli jako (zobacz rysunek 3.21). Rysunek 3.21. Próba wklejenia tabeli powoduje wyświetlenie okna dialogowego Wklejanie tabeli jako
3. Wpisz nazwę nowej tabeli. Aby dołączyć dane do istniejącej tabeli, należy w polu Nazwa tabeli wpisać nazwę istniejącej tabeli (zobacz następny krok). 4. W oknie dialogowym Wklejanie tabeli jako wybierz jedną z opcji wklejania (Tylko struktura, Struktura i dane, Dołącz dane do istniejącej tabeli). 5. Kliknij OK, aby zakończyć operację.
Kopiowanie tabel do innej bazy danych Tak jak można kopiować tabele w obrębie jednej bazy danych, można również kopiować je do innych baz. Jest wiele powodów, dla których się to robi. Na przykład możliwe jest, że jedna tabela występuje w wielu systemach lub trzeba utworzyć kopię bezpieczeństwa ważnych tabel. W trakcie kopiowania tabel do innej bazy danych nie są kopiowane relacje między tabelami — Access kopiuje jedynie struktury i dane. Metoda kopiowania tabeli do innej bazy danych jest w zasadzie taka sama jak w przypadku kopiowania dokonywanego w obrębie jednej bazy:
Rozdział 3. Tworzenie tabel
115
1. Kliknij prawym przyciskiem myszy nazwę tabeli w okienku nawigacji i wybierz polecenie Kopiuj z menu podręcznego lub kliknij przycisk Kopiuj w grupie Schowek na zakładce NARZĘDZIA GŁÓWNE. 2. Otwórz inną bazę danych Accessa i wybierz polecenie Wklej z menu podręcznego albo kliknij przycisk Kopiuj w grupie Schowek na zakładce NARZĘDZIA GŁÓWNE. Pojawi się okno dialogowe Wklejanie tabeli jako. 3. Wpisz nazwę nowej tabeli. 4. Wybierz jedną z opcji wklejania (Tylko struktura, Struktura i dane, Dołącz dane do istniejącej tabeli). 5. Kliknij OK, aby zakończyć operację.
Dodawanie rekordów do tabeli bazy danych Dodawanie rekordów do tabeli jest bardzo proste: wystarczy zaznaczyć i kliknąć wybraną nazwę tabeli w okienku nawigacji, aby wyświetlić ją w widoku arkusza danych, a po jej otwarciu można wpisywać dane w każdym polu. Dodawanie rekordów do tabeli w widoku arkusza danych przedstawia rysunek 3.22. Rysunek 3.22. Dodawanie rekordów do tabeli w widoku arkusza danych
Informacje można wpisywać we wszystkich polach z wyjątkiem pola CustomerID. Wartości w polach typu Autonumerowanie są uzupełniane automatycznie. Chociaż rekordy można wpisywać za pomocą arkusza danych bezpośrednio do tabeli, to nie jest to najbardziej efektywna metoda. Lepiej dodawać rekordy za pomocą formularzy, ponieważ kod dołączony do formularzy umożliwia dynamiczne wstawianie wartości domyślnych (np. na podstawie danych wcześniej wprowadzonych w formularzu). Formularze pozwalają również komunikować się z użytkownikami podczas procesu wprowadzania danych.
116
Część II Tabele Accessa
Posługiwanie się polami typu Załącznik Microsoft zauważył, że projektanci baz danych muszą pracować z wieloma różnymi typami danych. Chociaż tradycyjne typy danych Accessa (Krótki tekst, Waluta, Obiekt OLE itp.) umożliwiają obsługę wielu różnych typów danych, do niedawna nie było możliwości wykorzystania kompletnych plików jako danych Accessa bez przeprowadzania pewnych transformacji (np. konwersji do postaci danych OLE). Od Accessa 2010 istnieje typ Załącznik, który pozwala dołączać do baz danych Accessa całe pliki jako załączniki pól tabeli. Kliknięcie pola typu Załącznik powoduje wyświetlenie niewielkiego okna dialogowego (zobacz rysunek 3.23), które umożliwia wskazanie plików dołączanych do tabeli. Rysunek 3.23. Zarządzanie załącznikami dla pól typu Załącznik
Kliknięcie przycisku Dodaj w oknie dialogowym na rysunku 3.23 powoduje wyświetlenie znajomego windowsowego okna Wybierz pliki, pozwalającego wyszukać pliki, które mają zostać dołączone do pola. Wybrane pliki są dodawane do listy widocznej na rysunku 3.23. Zwróćmy również uwagę na to, że w oknie dialogowym Załączniki znajdują się przyciski służące do usuwania załączników pola i zapisywania załączników na dysku komputera. Ważną informacją do zapamiętania dotyczącą typu danych Załącznik jest fakt, iż pojedyncze pole załącznika w tabeli umożliwia załączenie wielu plików różnych typów. W obrębie jednego pola typu Załącznik można zapisać dokument Worda, kilka klipów wideo lub audio, a także zdjęcia. W związku z tym, że dane załączników stają się częścią bazy danych, dodanie wielu załączników do tabeli spowoduje szybki wzrost rozmiaru pliku .accdb. Z typu danych Załącznik należy korzystać tylko wtedy, gdy korzyści z jego zastosowania są większe niż problemy.
Rozdział 4.
Relacje między tabelami W tym rozdziale:
Projektowanie baz danych odpornych na błędy
Normalizacja danych w bazie danych
Omówienie typowych relacji między tabelami
Reguły integralności specyficzne dla aplikacji
Dodawanie pól kluczowych do tabel
We wcześniejszej części tej książki omówiliśmy jedno z najbardziej podstawowych założeń dotyczących relacyjnych systemów baz danych — dane są rozdzielone na pewną liczbę tabel, które są ze sobą powiązane za pomocą kluczy głównych i obcych. Chociaż tę prostą zasadę łatwo zrozumieć, znacznie trudniej nauczyć się tego, w jaki sposób i w jakich sytuacjach dane należy umieszczać w osobnych tabelach. Ponieważ dane zarządzane przez relacyjną bazę danych (taką jak Access) występują w wielu różnych tabelach, musi istnieć sposób na ich powiązanie. Im wydajniej baza danych obsługuje te powiązania, tym lepiej i w bardziej elastyczny sposób działa aplikacja jako całość. Chociaż bazy danych powinny odzwierciedlać sytuacje ze świata rzeczywistego lub co najmniej zarządzać danymi występującymi w rzeczywistych sytuacjach, nawet najbardziej skomplikowaną sytuację można sprowadzić do kilku relacji między tabelami. W miarę wzrostu złożoności danych zarządzanych przez bazę może wystąpić potrzeba dodania większej liczby tabel do projektu. Na przykład, baza danych zarządzająca sprawami dotyczącymi pracowników firmy będzie zawierać tabele zawierające informacje o pracownikach (nazwisko, numer NIP, adres, data zatrudnienia, itp.), informacje płacowe, programy udziału w zyskach dotyczące danego pracownika itp. W tym rozdziale wykorzystano dane pochodzące z różnych aplikacji, m.in. z Northwind Traders (tradycyjnej przykładowej bazy danych Accessa), przykładu małej księgarni oraz aplikacji MiniAuta dla Kolekcjonerów — aplikacji używanej w pozostałych rozdziałach tej książki. Każdy zbiór danych ma nieco odmienne przeznaczenie od pozostałych i służy do podkreślenia różnych aspektów teorii relacji. Wszystkie tabele opisywane w tym rozdziale można znaleźć w bazie danych Rozdział04.accdb.
118
Część II Tabele Accessa
Jednak podczas pracy z rzeczywistymi danymi w określonym momencie koncentrujemy się na związkach pomiędzy dwiema tabelami. Można najpierw stworzyć tabele z informacjami o pracownikach oraz płacach i połączyć te tabele za pomocą relacji tak, by można było łatwo znaleźć informacje płacowe dotyczące pracownika. W tym rozdziale wykorzystano różne dane z bazy Rozdział04.accdb. Jeżeli ktoś jeszcze nie skopiował jej do swojego komputera, powinien zrobić to teraz. Aby prześledzić przykłady, można skorzystać z tabel tej bazy danych albo utworzyć tabele samodzielnie w innej bazie danych.
Tworzenie kuloodpornych baz danych W rozdziałach 1., 2. i 3. zaprezentowaliśmy przykłady znanych relacji występujących w wielu bazach danych Accessa. Zdecydowanie najbardziej powszechnym typem relacji jest relacja jeden do wielu. W aplikacji MiniAuta dla Kolekcjonerów występuje bardzo dużo takich relacji. Każdy rekord w tabeli klientów jest powiązany z jednym lub wieloma rekordami w tabeli transakcji (każdy klient może zakupić w systemie MiniAuta dla Kolekcjonerów wiele towarów). Relacje jeden do wielu opisano bardziej szczegółowo w dalszej części tego rozdziału, w podrozdziale „Relacje między tabelami”. Z łatwością można sobie wyobrazić projekt, w którym dane z tabel klientów i transakcji znalazłyby się w jednej tabeli. Wystarczyłoby utworzyć osobny wiersz dla każdego zamówienia złożonego przez każdego z klientów. W miarę składania nowych zamówień następowałoby dodawanie nowych wierszy zawierających informacje dotyczące klientów i składanych przez nich zamówień. Przykładem takiego układu jest tabela Accessa pokazana na rysunku 4.1. Na tym rysunku kolumna OrderID zawiera numer zamówienia złożonego przez klient (dane w tej tabeli posortowano według kolumny CustomerID, aby pokazać ile zamówień złożył każdy z klientów). Tabelę przedstawioną na rysunku 4.1 utworzono poprzez połączenie tabel Customers i Orders z przykładowej bazy danych Northwind Traders. Tabela ta znajduje się w pliku bazy danych Rozdział04.accdb w przykładach dołączonych do tej książki. Zwróćmy uwagę na kolumnę OrderID z prawej strony kolumny CompanyName. Każdy klient (np. firma Alfreds Futterkiste) złożył pewną liczbę zamówień. Kolumny z prawej strony tabeli (poza prawą krawędzią widoczną na rysunku) zawierają dodatkowe informacje dotyczące każdego klienta włącznie z adresem i numerem telefonu, natomiast dalsze kolumny zawierają szczegóły dotyczące zamówień. Ogółem tabela ta zawiera 24 różne pola. Układ pokazany na rysunku 4.1 występuje w sytuacji, kiedy w roli bazy danych wykorzystuje się aplikację arkusza kalkulacyjnego, na przykład Excel. Ponieważ Excel jest arkuszem kalkulacyjnym, nie obsługuje podziału danych na oddzielne tabele i zachęca użytkowników do przechowywania wszystkich danych w jednym, rozbudowanym arkuszu. Z takim układem wiąże się kilka problemów:
Tabela szybko rozrasta się do rozmiarów, które utrudniają jej zarządzanie. W tabeli Contacts bazy Northwind Traders jest 11 różnych pól, natomiast w tabeli Orders jest ich 14. W obu tabelach jest tylko jedno pole wspólne — OrderID.
Rozdział 4. Relacje między tabelami
119
Rysunek 4.1. Tabela Accessa zawierająca dane dotyczące zarówno klientów, jak i zamówień
Za każdym razem, kiedy składane jest zamówienie, wszystkie 24 pola danych są dodawane do każdego rekordu w połączonej tabeli. Dodawanych jest także bardzo dużo danych niezwiązanych bezpośrednio z zamówieniem (np. nazwisko kontaktu czy stanowisko kontaktu).
Dane są trudne do utrzymania i aktualizacji. Wprowadzenie niewielkiej modyfikacji danych w rozbudowanej tabeli (np. zmiana numeru telefonu klienta lub numeru faksu) wymaga wyszukania wszystkich rekordów w tabeli dotyczących klienta i zmiany wszystkich wystąpień numeru telefonu. Z łatwością można popełnić błąd lub pominąć jedno lub kilka wystąpień. Im mniej rekordów wymaga zmian, tym lepiej dla użytkownika.
Monolityczny projekt tabeli to marnotrawstwo miejsca na dysku i innych zasobów. Ponieważ w połączonej tabeli jest zapisanych mnóstwo redundantnych danych (np. adres klienta powtarza się dla każdej transakcji), znaczącą ilość miejsca na dysku zajmują nadmiarowe dane. Oprócz zmarnotrawionego miejsca na dysku w nieekonomiczny sposób wykorzystuje się przepustowość sieci, pamięć i inne zasoby.
Znacznie lepszy jest projekt relacyjny, w którym powtarzające się dane są zapisane w osobnej tabeli. W takim przypadku dane z jednej tabeli służą jako odwołanie do informacji z drugiej tabeli. Dodatkowe pole, jakie trzeba zdefiniować w przypadku relacyjnego modelu danych, to niewielka cena w porównaniu z wydajnością uzyskaną dzięki przeniesieniu redundantnych danych poza tabelę. Druga olbrzymia korzyść z normalizacji danych i zastosowania ścisłych zasad projektowania baz danych w aplikacjach Accessa polega na tym, że dane stają się praktycznie kuloodporne. W prawidłowo zaprojektowanej i zarządzanej bazie danych użytkownicy
120
Część II Tabele Accessa
mają pewność, że informacje wyświetlane na formularzach i w raportach odzwierciedlają dane przechowywane w tabelach. Źle zaprojektowane bazy danych są podatne na uszkodzenia. Z tego powodu czasami dochodzi do „zagubienia” danych, które nigdy nie pojawią się na formularzach i w raportach, pomimo tego, że użytkownicy dodawali dane do aplikacji. Czasami może dojść również do zwracania przez kwerendy aplikacji błędnych danych. W każdym z takich przypadków bazom danych nie można ufać. Użytkownicy nigdy nie mają pewności, że dane, które widzą na formularzach i w raportach, są prawidłowe. Użytkownicy zwykle ufają temu, co się wyświetla na ekranie lub jest wydrukowane na papierze. Wyobraźmy sobie problemy, jakie mogłyby wyniknąć, gdyby klientowi nie została wystawiona faktura za transakcję lub gdyby doszło do nieprawidłowego zaktualizowania stanów magazynowych. Zły projekt bazy danych nie wróży niczego dobrego. Projektanci baz danych są odpowiedzialni za to, aby projektowane przez nich aplikacje były jak najdokładniejsze i jak najbardziej odporne na różnorodne sytuacje. Stosowanie się do reguł normalizowania danych pomaga osiągnąć te cele.
Normalizacja i denormalizacja danych Proces podziału danych na wiele tabel określa się terminem normalizacja. Jest kilka faz normalizacji. Pierwsza do trzeciej postaci normalnych są najłatwiejsze do zrozumienia oraz zaimplementowania i wystarczają w większości zastosowań. Choć istnieją wyższe poziomy normalizacji, zazwyczaj ignorują je wszyscy projektanci z wyjątkiem najbardziej doświadczonych i najbardziej drobiazgowych. Aby zilustrować proces normalizacji, posłużymy się niewielką bazą danych, z której mógłby korzystać hurtownik książek do rejestrowania zamówień składanych przez niewielkie księgarnie rozmieszczone w terenie. Baza danych powinna zawierać następujące informacje:
daty złożenia zamówień książek;
dane klientów, którzy złożyli zamówienie;
liczba zamówionych książek;
tytuły zamówionych książek.
Chociaż ten zbiór danych jest bardzo prosty, zawiera typowe dane zarządzane w aplikacjach Accessa i pozwala zademonstrować sposób normalizacji zbioru danych.
Pierwsza postać normalna Pierwsza faza normalizacji, nazywana pierwszą postacią normalną (w skrócie 1NF — od ang. first normal form), wymaga, aby tabela spełniała następującą regułę: Każda komórka tabeli musi zawierać pojedynczą wartość. W tabeli nie mogą występować powtarzające się grupy danych. Za tabelę uważa się dwuwymiarową strukturę danych, a zapisywanie wielu wartości w polu lub zezwolenie na powtarzające się grupy wewnątrz tabeli sugeruje występowanie trzeciego wymiaru danych. Pierwszą próbę stworzenia tabeli do zarządzania zamówieniami księgarni (tblBookOrders1) pokazano na rysunku 4.2. Zwróćmy uwagę, że niektóre
księgarnie zamówiły więcej niż jedną książkę. Wartość 7 Magia ciastek w polu BookTitles oznacza, że klient zamówił 7 egzemplarzy książki pod tytułem Magia ciastek. Przechowywanie w tej samej komórce zarówno liczby, jak i nazwy to jedno z kilku naruszeń pierwszej postaci normalnej przez projekt tej tabeli. Tabela na rysunku 4.2 prezentuje zastosowanie płaskiej struktury baz danych (ang. flat-file). Dane w bazach danych o płaskiej strukturze są zapisane w dwóch wymiarach (wierszach i kolumnach). Pominięto w nich trzeci wymiar (powiązane tabele) możliwy do zaimplementowania w relacyjnych systemach baz danych takich jak Microsoft Access. Zwróćmy uwagę, że tabela na rysunku 4.2 narusza regułę pierwszej postaci normalnej. Wartość w polu BookTitle w wielu rekordach w tej tabeli zawiera więcej niż jedną wartość. Na przykład książka zatytułowana Domowe wędzonki występuje w rekordach 7. i 8. Obsługa takich danych jest bardzo trudna — aby odwołać się do książek zamówionych przez księgarnie, trzeba parsować dane zapisane w polu BookTitle i na tej podstawie stwierdzić, jakie książki zostały zamówione przez poszczególne księgarnie. Nieco lepszy projekt pokazano na rysunku 4.3 (tblBookOrders2). Liczby egzemplarzy poszczególnych książek przeniesiono do osobnych kolumn. W dalszym ciągu jednak każdy wiersz zawiera wszystkie dane pojedynczego zamówienia. Dzięki takiemu projektowi odczytanie informacji o liczbie egzemplarzy określonych tytułów jest nieco łatwiejsze. Wciąż jednak występują powtarzające się grupy dla liczb i tytułów (kolumny Quant1, Title1, Quant2, Title2 itd.), które naruszają regułę pierwszej postaci normalnej. Wysokość wiersza w tabeli na rysunku 4.3 zwiększono po to, by można było łatwiej zaprezentować układ tabeli. Projekt tabeli zamieszczonej na rysunku 4.3 ciągle jest nieelegancki, a praca z taką tabelą jest trudna. Kolumny służące do zapisywania liczby egzemplarzy i tytułów są stałą cechą tabeli. Projektant musi dodać wystarczającą liczbę kolumn, pozwalającą na zapisanie informacji o maksymalnej liczbie książek, jakie można zakupić w księgarni. Oto przykład. Załóżmy, że projektant prognozuje, iż wybrana księgarnia nigdy jednorazowo nie zamówi więcej niż 50 tytułów. Oznacza to konieczność dodania 100 kolumn do tabeli (dla każdego zamawianego tytułu potrzebne są dwie kolumny — z liczbą egzemplarzy i tytułem). Jeśli księgarnia zamówi jeden tytuł, 98 kolumn w tabeli będzie pustych — jest to czyste marnotrawstwo i przykład nieekonomicznego wykorzystania miejsca na dysku.
122
Część II Tabele Accessa
Rysunek 4.3. Projekt tabeli nieznacznie poprawiony w stosunku do poprzedniego
W przypadku projektu pokazanego na rysunku 4.3 odpytanie tabeli tblBookOrders2 w celu uzyskania informacji o sprzedaży określonej książki jest bardzo trudne. Liczby sprzedanych egzemplarzy dla poszczególnych książek są rozproszone po całej tabeli. Występują w różnych wierszach i różnych kolumnach. W związku z tym nie wiadomo, gdzie szukać informacji dotyczących transakcji. Co więcej, jeśli jakieś zamówienie przekroczy liczbę 50 tytułów, konieczna będzie aktualizacja projektu — dodanie kolumn potrzebnych dla kolejnego tytułu. Oczywiście można by tego uniknąć poprzez dodanie kolejnego wiersza dla wybranego zamówienia, ale w ten sposób praca z danymi stanie się jeszcze trudniejsza. Na rysunku 4.4 pokazano projekt tabeli tblBookOrders3 — tabelę w pierwszej postaci normalnej stworzoną na podstawie danych z rysunku 4.3. W tabeli tblBookOrders3 zamiast umieszczać zamówienia wielu książek w jednym rekordzie, każdy rekord zawiera informację o jednym tytule zamówionym przez klienta. Potrzebnych jest więcej rekordów, ale obsługa danych jest znacznie łatwiejsza. Pierwsza postać normalna jest bardziej wydajna, ponieważ w tabeli nie ma nieużywanych pól. Każde pole spełnia rolę zgodną z przeznaczeniem tabeli. Tabela z rysunku 4.4 zawiera te same dane co tabele z rysunków 4.2 i 4.3. Nowy projekt zapewnia jednak znacznie łatwiejszą pracę z danymi. Na przykład można łatwiej utworzyć kwerendę, która zwraca całkowitą liczbę książek zamówionych przez określonego klienta, lub sprawdzającą, jakie książki zamówiła wskazana księgarnia. Tabele zawsze powinny znajdować się w pierwszej postaci normalnej. Należy zadbać o to, aby każda komórka w tabeli zawierała pojedynczą wartość, a nie kombinację kilku wartości. Nie może być także powtarzających się grup (jak pokazano na rysunku 4.3).
Rozdział 4. Relacje między tabelami
123
Rysunek 4.4. Pierwsza postać normalna
Optymalizacja projektu tabeli nie kończy się jednak w tym momencie. Tabela BookOrders, a także inne tabele z tej aplikacji wymagają jeszcze wiele pracy. Tabela pokazana na rysunku 4.4 zawiera wiele redundantnych informacji. Tytuły książek powtarzają się za każdym razem, kiedy klienci zamówią tę samą książkę, a numer zamówienia i data zamówienia powtarzają się dla każdego wiersza zawierającego informacje o zamówieniu. Bardziej subtelny błąd polega na tym, że pola OrderID nie można używać jako klucza głównego tabeli. Ponieważ identyfikator zamówienia powtarza się dla każdego tytułu książki w zamówienia, nie można go używać do identyfikacji każdego rekordu w tabeli. Zamiast tego OrderID jest polem kluczowym tabeli. Można z niego korzystać w celu wyszukiwania wszystkich rekordów odpowiadających określonemu zamówieniu. Sytuację tę naprawimy w drugiej fazie optymalizacji.
Druga postać normalna Bardziej wydajny projekt można uzyskać w wyniku rozdzielenia danych z tabeli tblBook. Orders na dwie osobne tabele w celu uzyskania drugiej postaci normalnej (2NF). Oto druga reguła normalizacji: Dane, które nie zależą bezpośrednio od klucza głównego tabeli, należy przenieść do osobnej tabeli. Reguła ta oznacza, że tabela powinna zawierać dane reprezentujące jeden podmiot. Ponieważ stopniowo przekształcaliśmy jedną nieznormalizowaną tabelę na znormalizowaną postać, w tabeli tblBookOrders3 nie ma klucza głównego. Na razie można zignorować ten fakt i potraktować każdy wiersz tabeli jak encję. Wszystkie dane z tego wiersza, które nie są integralną częścią danej encji, należy przenieść do innej tabeli. W tabeli tbl BookOrders3 ani pole klienta, ani pole tytułu nie są integralną częścią zamówienia, dlatego trzeba je umieścić w innej tabeli.
124
Część II Tabele Accessa
Identyfikowanie encji Czy jednak klienci nie są integralnym aspektem zamówienia? To prawda, są. Jednak dane zapisane w polu klienta w tabeli tblBookOrders3 to nazwa klienta. Jeśli firma zmieni nazwę, nie wpłynie to na zamówienie. Także książka jest integralnym aspektem zamówienia, ale jej tytuł już nim nie jest. Aby rozwiązać ten problem, trzeba utworzyć odrębne tabele klientów i książek. Najpierw utwórzmy nową tabelę tblBookStores (zobacz rysunek 4.5). Rysunek 4.5. Przenoszenie danych o klientach do odrębnej tabeli
Aby utworzyć tabelę tblBookStores, wykonaj następujące czynności: 1. Kliknij przycisk Projekt tabeli na zakładce TWORZENIE na wstążce. 2. Dodaj pole BookStoreID typu Autonumerowanie. 3. Kliknij przycisk Klucz podstawowy na zakładce NARZĘDZIA TABEL PROJEKTOWANIE na wstążce. 4. Dodaj pole StoreName typu Krótki tekst. 5. Ustaw długość pola StoreName na 50. 6. Zapisz tabelę pod nazwą tblBookStores. Możliwe, że przydatne będą dodatkowe informacje na temat klientów, np. adres e-mail lub numer telefonu. Jednak na razie celem jest uzyskanie drugiej postaci normalnej przez przeniesienie danych, które nie są integralną częścią zamówienia, do odrębnej tabeli. Teraz utwórzmy tabelę na książki. W tym celu wykonaj następujące kroki: 1. Kliknij przycisk Projekt tabeli na zakładce TWORZENIE na wstążce. 2. Dodaj pole BookID typu Autonumerowanie. 3. Kliknij przycisk Klucz podstawowy na zakładce NARZĘDZIA TABEL PROJEKTOWANIE na wstążce.
Rozdział 4. Relacje między tabelami
125
4. Dodaj pole BookTitle typu Krótki tekst. 5. Zapisz tabelę pod nazwą tblBooks. Klient i książka są integralną częścią zamówienia (natomiast nie są nią nazwa firmy ani tytuł książki), dlatego potrzebny jest sposób na powiązanie tabel ze sobą. Choć klient może zmienić nazwę firmy, nie może zmodyfikować identyfikatora BookStoreID, ponieważ sami go utworzyliśmy i kontrolujemy tę wartość. Podobnie wydawnictwo może zmienić tytuł książki, ale nie zmodyfikuje identyfikatora BookID. Klucze główne tabel tblBookStores i tblBooks dobrze nadają się do wskazywania powiązanych obiektów. Zmiany innych danych nie stanowią tu problemu. Na rysunku 4.6 widoczne są trzy tabele. Tabela tblBookOrders3 zamiast nazwy klienta i tytułu książki zawiera klucze główne powiązanych rekordów z tabel tblBookStores i tbl Books. Gdy klucz główny jednej tabeli jest używany w polu innej tabeli, jest nazywany kluczem obcym.
Rysunek 4.6. Pierwszy krok doprowadzania tabeli do drugiej postaci normalnej
Gdyby przed przeniesieniem danych klientów do odrębnej tabeli nastąpiła zmiana nazwy Księgarnia Centrum na Księgarnia Centralna, konieczne byłoby znalezienie w tabeli tblBookOrders3 wszystkich wierszy dotyczących klienta Księgarnia Centrum i zmiana wartości pola w każdym z tych wierszy. Przeoczenie nazwy klienta podczas takiego procesu określa się mianem anomalii aktualizacji. Jej efektem są rekordy niespójne z innymi rekordami zapisanymi w bazie danych. Z punktu widzenia bazy danych Księgarnia Centrum oraz Księgarnia Centralna to dwie zupełnie różne firmy, chociaż my wiemy, że chodzi o ten sam sklep. Z powodu anomalii aktualizacji w wynikach kwerendy wybierającej wszystkie zamówienia złożone
126
Część II Tabele Accessa
przez Księgarnię Centralną nie będzie tych, dla których w polu z nazwą klienta jest wartość Księgarnia Centrum. Inną zaletą usunięcia nazwy klienta z tabeli zamówień jest fakt, iż po tej operacji nazwa będzie występowała tylko w jednym miejscu w bazie danych. Jeśli Księgarnia Centrum zmieni nazwę na Księgarnia Centralna, zmianę tę trzeba będzie uwzględnić tylko w tabeli tblBookStores. Ta jedna zmiana będzie obowiązywała w całej bazie danych, włącznie z wszystkimi formularzami i raportami, w których użyto informacji o nazwie klienta. Identyfikowanie odrębnych encji i umieszczanie dotyczących ich danych w niezależnych tabelach to duży pierwszy krok w kierunku uzyskania drugiej postaci normalnej. Jednak to jeszcze nie koniec. W tabeli zamówień nadal nie ma pola z niepowtarzalnymi wartościami, które można wykorzystać jako klucz główny. W polu OrderID występują powtarzające się wartości, co wskazuje na to, że uzyskanie drugiej postaci normalnej wymaga jeszcze trochę pracy. Mniej oczywiste encje Klienci i książki to obiekty fizyczne, które łatwo jest zidentyfikować jako odrębne encje. Następny krok jest bardziej abstrakcyjny. W tabeli zamówień tblBookOrders4 nadal znajdują się informacje na temat dwóch odrębnych (choć powiązanych) encji. Jedną z nich jest samo zamówienie, a druga to szczegóły dotyczące zamówienia (jego poszczególne pozycje). Trzy pierwsze rekordy tabeli tblBookOrders4 (zobacz rysunek 4.6) mają te same wartości pól OrderID, OrderDate i BookStoreID. Te trzy pola to cechy całego zamówienia, a nie jego poszczególnych pozycji. W polach Quantity i BookID trzech pierwszych rekordów znajdują się różne wartości. Te pola to cechy konkretnej pozycji z zamówienia. Wartości powtarzające się w kilku rekordach (np. wartość pola OrderID w tabeli tblBookOrders2 na rysunku 4.6) wskazują na to, że dane nie są jeszcze w drugiej postaci normalnej. Niektóre dane, np. klucze obce, celowo się powtarzają. Inne, np. daty i liczby sztuk, powtarzają się z naturalnych powodów i nie są oznaką problemów.
Ostatni etap tworzenia drugiej postaci normalnej to umieszczenie informacji integralnych dla całego zamówienia w tabeli odrębnej od informacji dotyczących poszczególnych pozycji zamówienia. Utwórz nową tabelę tblBookOrderDetails. Umieść w niej pola Book. OrderDetailID, Quantity i BookID. Pole BookOrderDetailID jest typu Autonumerowanie i pełni funkcję klucza głównego. Pole BookID to klucz zewnętrzny, używany do powiązania dwóch tabel. Na rysunku 4.7 widoczna jest nowa tabela zamówień (tblBookOrders5) i nowa tabela ze szczegółowymi informacjami o zamówieniach (tblBookOrderDetails). Z tabeli tblBookOrders5 usunięto dawne pole OrderID, a w zamian utworzono pole o tej samej nazwie typu Autonumerowanie. Skoro w tabeli zamówień znajduje się już pole z niepowtarzalnymi wartościami, można ustawić je jako klucz główny. Wszystkie dane w każdym rekordzie tabeli tblBookOrders5 dotyczą bezpośrednio zamówienia. W kontekście drugiej postaci normalnej można stwierdzić, że wszystkie dane bezpośrednio zależą od klucza głównego.
Rozdział 4. Relacje między tabelami
127
Rysunek 4.7. Po uzyskaniu drugiej postaci normalnej
Pole OrderID w tabeli tblBookOrderDetails to klucz obcy służący do powiązania dwóch tabel ze sobą. Na rysunku 4.7 widać, że trzy pierwsze rekordy tabeli tblBookOrderDetails mają pole OrderID o wartości 1, są więc powiązane z pierwszym rekordem tabeli tblBook. Orders5. Wszystkie pola tabeli tblBookOrderDetails bezpośrednio zależą od klucza głównego BookOrderDetailID. Wartość z pierwszego rekordu, 10, dotyczy bezpośrednio danej pozycji zamówienia. Z całym zamówieniem powiązana jest tylko pośrednio, podobnie jak wartości z dwóch następnych rekordów (5 i 7). Ta pośrednia zależność powstaje w wyniku umieszczenia w rekordzie klucza obcego OrderID. Pierwotna tabela, tblBookOrders1, zawierała w każdym rekordzie dane dotyczące kilku różnych encji. W wyniku serii kroków podzieliliśmy dane na cztery tabele: tblBook Orders5, tblBookOrderDetails, tblCustomers i tblBooks. Każda z nich zawiera dane na temat jednej encji. Dane wreszcie udało się zapisać w drugiej postaci normalnej. Podział tabeli na kilka tabel, z których każda opisuje oddzielny aspekt danych, nazywa się dekompozycją. Jest to ważna część procesu normalizacji. Mimo że tabele wydają się mniejsze niż w pierwotnej tabeli (zobacz rysunek 4.2), dane zawarte w tabelach są takie same jak poprzednio. Programista korzystający z tabel bazy danych księgarni może używać kwerend do przetwarzania danych z czterech utworzonych tabel w nowy, interesujący sposób. Łatwo można sprawdzić, ile książek z każdego tytułu zamówili poszczególni klienci oraz ile razy zamawiano określoną książkę. W połączeniu z tabelą zawierającą takie informacje, jak cena jednostkowa książki, cena sprzedaży książki itp., można z łatwością określić istotne statystyki finansowe ważne dla hurtownika zajmującego się sprzedażą książek.
128
Część II Tabele Accessa
Zwróćmy także uwagę na to, że zmniejszyła się liczba rekordów w tabeli tblBookOrder5. Jest to jedna z kilku zalet korzystania z relacyjnych baz danych. W każdej tabeli znajduje się tylko tyle danych, ile potrzeba do reprezentowania encji (w tym przypadku zamówienia książek) opisywanej przez tabelę. Jest to dużo wydajniejszy sposób korzystania z danych niż dodanie zdublowanych wartości pól (zobacz rysunek 4.2) dla każdego nowego rekordu umieszczanego w tabeli. Łamanie reguł Od czasu do czasu może okazać się konieczne złamanie tych reguł. Na przykład załóżmy, że księgarnie są uprawnione do otrzymywania rabatów na podstawie rozmiaru zamówień w ciągu ostatniego roku. W przypadku ścisłego przestrzegania reguł normalizacji procent rabatu należałoby umieścić w tabeli tblBookStores. W końcu rabat zależy od klienta, a nie od zamówienia. Może się jednak zdarzyć, że rabat będzie stosowany do każdego zamówienia indywidualnie. Na przykład przedstawiciel handlowy uzyskał zgodę od właściciela hurtowni na specjalną obniżkę cen dla szczególnie cennych klientów. W takiej sytuacji można umieścić kolumnę z rabatem w tabeli zamówień, pomimo tego, że powoduje ona zapisywanie powtarzających się informacji w wielu rekordach. Można by zapisać tradycyjny rabat w rekordzie klienta w tabeli tblBookStores i wykorzystać go jako wartość domyślną dla kolumny z rabatem, a jednocześnie zezwolić handlowcom na modyfikację tej wartości w przypadku poczynienia z klientem specjalnych uzgodnień. Tylko na pozór rozwiązanie to narusza drugą postać normalną. Domyślny rabat jest bezpośrednio zależny od klienta. Konkretna wysokość rabatu zależy od zamówienia. Podobna sytuacja dotyczy adresu dostawy. Klient może chcieć, aby większość zamówień trafiała do niego. Czasem jednak może chcieć wysłać towar bezpośrednio do jego odbiorcy. Adres wysyłki jest bezpośrednio powiązany z klientem, natomiast adres, pod który należy wysłać konkretne zamówienie, zależy od danego zamówienia. W dużych bazach w tabelach obiektów często występują dane używane jako wartości domyślne w tabelach transakcji. Omówienie tabel obiektów i tabel transakcji znajdziesz w rozdziale 3.
Trzecia postać normalna Ostatnia faza normalizacji, zwana trzecią postacią normalną (3NF), wymaga usunięcia wszystkich pól, które można uzyskać na podstawie danych zawartych w innych polach tabeli bądź innych tabel bazy danych. Załóżmy na przykład, że menedżer handlowy upiera się, aby w tabeli z zamówieniami dodać pole zawierające całkowitą liczbę zamówionych książek. Informacje te można oczywiście obliczyć na podstawie pola Quantity z tabeli tblBookOrderDetails. Nie ma powodu, dla którego należałoby dodawać nowe pole OrderTotal do tabeli Orders. Access z łatwością może obliczyć tę wartość na podstawie danych dostępnych w bazie danych. Jedyną zaletą zapisywania całkowitej liczby książek w bazie danych jest zaoszczędzenie kilku milisekund, jakie Access potrzebuje do odczytania z bazy danych i obliczenia wartości potrzebnych w formularzu lub raporcie.
Rozdział 4. Relacje między tabelami
129
Usuwanie obliczanych danych z bazy pomaga zachować integralność danych w bazie. Na rysunku 4.7 widoczne są trzy rekordy tabeli tblBookOrderDetails związane z zamówieniem o identyfikatorze 1. Po podsumowaniu wartości z pola Quantity wiadomo, że zamówiono 22 książki. Gdyby dodano pole OrderTotal i błędnie zapisano w nim wartość 33 zamiast 22, dane byłyby niespójne. Raport wyświetlający łączną liczbę zamówionych książek na podstawie pola OrderTotal zawierałby inną wartość niż raport uzyskany dzięki obliczeniom. W zależności od tworzonej aplikacji można znaleźć istotne powody, dla których warto zapisywać obliczane dane w tabelach, zwłaszcza w przypadku, gdy wykonywanie obliczeń trwa długo lub jeśli zapisane wartości są potrzebne do sprawdzenia obliczonych wartości drukowanych na raportach. Może się okazać, że wykonywanie obliczeń podczas wprowadzania danych (kiedy dane są przetwarzane rekord po rekordzie) jest bardziej wydajne niż podczas drukowania raportów (kiedy wygenerowanie pojedynczego raportu wymaga przetworzenia wielu tysięcy rekordów). Więcej informacji na temat anomalii Warto zapamiętać kwestie dotyczące anomalii aktualizacji. Celem normalizacji tabel w bazie danych jest uzyskanie maksymalnej wydajności przy minimalnym nakładzie wysiłków związanych z utrzymaniem bazy danych. Projekt bazy danych, w którym nie przeprowadzi się normalizacji, jest narażony na wystąpienie trzech rodzajów błędów. Stosowanie się do reguł opisanych w tym rozdziale umożliwia uniknięcie następujących problemów:
Anomalie wprowadzania danych. W powiązanej tabeli występuje błąd w momencie dodania rekordu do innej tabeli. Załóżmy na przykład, że dodaliśmy pole OrderTotal opisane w poprzednim punkcie. Po przetworzeniu zamówienia klient modyfikuje liczbę zamówionych książek lub dodaje nowy tytuł do tego samego zamówienia. Jeśli projektant nie zadbał o to, by aplikacja bazy danych automatycznie uaktualniła obliczane pole OrderTotal, po dodaniu nowych danych do tabeli informacje w tym polu będą błędne.
Jeśli anomalie wprowadzania danych stanowią problem w aplikacji, można skorzystać z osadzanych makr (zobacz rozdział 22.), które pomogą w zsynchronizowaniu danych w tabelach po wprowadzeniu zmian.
Anomalie usuwania danych. Anomalie usuwania danych powodują przypadkową utratę danych po usunięciu rekordu z tabeli. Załóżmy, że w tabeli tblBookOrders3 jest nazwisko, adres oraz inne informacje kontaktowe dotyczące każdej z księgarń. Usunięcie ostatniego rekordu zawierającego informacje o zamówieniach określonego klienta powoduje nieumyślne usunięcie informacji o tym kliencie. Zapisanie informacji o kliencie w osobnej tabeli zabezpiecza przed możliwością przypadkowej utraty danych. Unikanie anomalii związanych z usuwaniem danych to jeden z powodów, dla których nie warto stosować kaskadowego usuwania rekordów w tabelach (więcej informacji na temat kaskadowego usuwania rekordów można uzyskać w dalszej części tego rozdziału, w podrozdziale „Relacje między tabelami”).
Anomalie aktualizacji danych. Zapisywanie w tabelach danych, które nie zależą od klucza głównego tabeli, powoduje konieczność aktualizacji wielu wierszy za każdym razem, kiedy zmienią się te informacje. Utrzymywanie niezależnych danych (np. informacji o księgarniach) w osobnej tabeli powoduje, że w przypadku zmiany danych trzeba je zaktualizować tylko w jednym miejscu (więcej informacji na temat anomalii związanych z aktualizacją danych można znaleźć we wcześniejszej części tego rozdziału, w podpunkcie „Identyfikowanie encji”).
130
Część II Tabele Accessa
W dalszej części tego rozdziału, w punkcie „Denormalizacja”, podano kilka dobrych powodów, dla których umieszczenie w bazie danych obliczonych pól może być korzystne. Najczęściej decyzja o denormalizacji wynika z potrzeby uzyskania pewności, że obliczona wartość zapisana w bazie danych jest identyczna z wydrukowaną w raporcie. Chociaż możliwe są także wyższe poziomy normalizacji, w większości aplikacji baz danych trzecia postać normalna w zupełności wystarcza. Minimalnym wymaganiem jest dążenie do pierwszej postaci normalnej polegające na przeniesieniu redundantnych, powtarzających się danych do innej tabeli.
Denormalizacja Po zaprezentowaniu wszystkich powodów, dla których normalizacja baz danych to dobry pomysł, pokażemy sytuacje, w których warto rozmyślnie zdenormalizować tabele lub zrezygnować z procesu ich normalizacji. Ogólnie rzecz biorąc, dane normalizuje się po to, by poprawić wydajność bazy danych. Na przykład, pomimo wszystkich podjętych wysiłków, posługiwanie się tabelami odnośników w niektórych przypadkach może być czasochłonne. Nawet w przypadku użycia prawidłowo poindeksowanych i znormalizowanych tabel, niektóre operacje odwołań do tabel odnośników będą wymagały sporo czasu, zwłaszcza gdy tabele te zawierają złożone dane lub są rozbudowane. Podobnie dużo czasu może zająć obliczenie niektórych wartości. Czasami się okazuje, że zapisanie obliczonej wartości jest bardziej ekonomiczne niż obliczanie jej w locie. Jest to prawdą zwłaszcza wtedy, gdy użytkownicy pracują na starszych, wolnych komputerach z niewielką ilością pamięci. Innym częstym powodem denormalizacji danych jest umożliwianie dokładnego odtworzenia pierwotnego dokumentu. Jeśli chcesz ponownie wydrukować fakturę zapisaną rok temu, a klient w tym czasie zmienił nazwę firmy, w znormalizowanej bazie na fakturze pojawi się nowa nazwa. Jeśli z przyczyn biznesowych faktura powinna mieć pierwotną postać, nazwę klienta należy zapisać w rekordzie faktury w momencie jego tworzenia. Należy pamiętać, że większość przypadków denormalizacji schematu bazy danych stwarza wymaganie poświęcenia dodatkowego czasu na programowanie w celu ochrony danych i użytkownika przed problemami związanymi z nieznormalizowanym projektem. Na przykład w przypadku obliczonego pola OrderTotal trzeba wprowadzić kod, który oblicza i aktualizuje to pole za każdym razem, kiedy zmienią się dane, na podstawie których się je oblicza. To dodatkowe programowanie wymaga oczywiście czasu, a powstały kod zajmuje czas procesora w fazie działania aplikacji. Trzeba również uważać, aby denormalizacja projektu nie spowodowała także innych problemów. Jeśli ktoś zdecydował się na rozmyślną denormalizację projektu bazy danych i ma problem z doprowadzeniem aplikacji do poprawnego działania (w szczególności jeśli występują anomalie omawiane w poprzednim punkcie), powinien poszukać obejść umożliwiających posługiwanie się w pełni znormalizowanym projektem.
I ostatnia uwaga. Pamiętajmy, aby zawsze dokumentować operacje wykonywane w celu denormalizacji projektu. Może się zdarzyć, że ktoś poprosi nas o wprowadzenie poprawek
Rozdział 4. Relacje między tabelami
131
lub dodanie nowych własności do aplikacji. Jeśli nie opiszemy elementów projektu, które naruszają zasady normalizacji, narażamy się na możliwość, że ktoś inny cofnie te zmiany w celu „zoptymalizowania” projektu. Projektant, który to zrobi, będzie miał oczywiście jak najlepsze intencje, ale może również przywrócić problem z wydajnością rozwiązany dzięki subtelnej denormalizacji. Warto pamiętać, że denormalizację niemal zawsze wykonuje się w celu generowania raportów, a nie w celu utrzymywania danych w tabelach. Rozważmy sytuację, w której klient otrzymał specjalny rabat, różny od standardowego. W takiej sytuacji przydałaby się możliwość zapamiętania faktycznej kwoty, która znalazła się na fakturze. Obliczanie rabatu przy każdej okazji drukowania raportu jest niewłaściwe. Zapisanie faktycznej kwoty daje pewność, że w raporcie zawsze znajdzie się kwota, która widnieje na fakturze klienta, a nie wartość zależna od innych pól w bazie danych, które z czasem mogły się zmienić.
Relacje między tabelami Wiele osób decyduje się na używanie arkuszy kalkulacyjnych, na przykład Excela lub Lotusa 1-2-3, do tworzenia baz danych. Niestety w arkuszach kalkulacyjnych dane są zapisywane w dwóch wymiarach (wierszach i kolumnach) i nie pozwalają na łatwe powiązanie ze sobą poszczególnych arkuszy. Trzeba ręcznie powiązać każdą z komórek w arkuszu z komórkami w innym arkuszu, co jest bardzo żmudnym procesem. Dwuwymiarowe obiekty do przechowywania danych takie jak arkusze kalkulacyjne określa się jako kartotekowe bazy danych lub tzw. płaskie pliki bazy danych (ang. flatfile), ponieważ brakuje im trójwymiarowości właściwej dla relacyjnych baz danych. Na rysunku 4.8 pokazano arkusz Excela wykorzystany w roli kartotekowej bazy danych. Rysunek 4.8. Arkusz Excela wykorzystany w roli kartotekowej bazy danych
Wystarczy rzut oka na rysunek 4.8, aby uświadomić sobie problemy wynikające z zastosowania kartotekowych baz danych. Zwróćmy uwagę, że informacje o pracowniku występują w wielu wierszach arkusza. Za każdym razem, kiedy pracownikowi jest wystawiany czek z wypłatą, następuje dodanie nowego wiersza do arkusza. Z oczywistych względów taki arkusz bardzo szybko osiągnąłby duże rozmiary i stałby się trudny do zarządzania. Zwróćmy uwagę, jak wiele pracy trzeba włożyć we wprowadzenie stosunkowo niewielkich zmian w danych z rysunku 4.8. Na przykład zmiana pola Title wymaga przeszukiwania wielu rekordów i edycji danych zawartych w pojedynczych komórkach. Takie działania stwarzają wiele okazji do popełnienia błędów.
132
Część II Tabele Accessa
Dzięki odpowiedniemu kodowi w języku VBA w Excelu można powiązać dane z arkusza na rysunku 4.8 z innym arkuszem zawierającym szczegółowe informacje o wynagrodzeniu. Można by również programowo modyfikować dane w indywidualnych wierszach. Jednak ten olbrzymi wysiłek na nic się nie zda. Nie uda się osiągnąć możliwości relacyjnego systemu baz danych, takiego jak Microsoft Access.
Wiązanie danych Klucz główny w unikatowy sposób identyfikuje rekordy, które są zapisane w tabeli. Przykładem kluczy głównych tabeli danych o pracownikach może być NIP, kombinacja imienia i nazwiska lub identyfikator pracownika. Załóżmy, że dla tabeli z danymi o pracownikach wybrano identyfikator pracownika. Podczas tworzenia powiązania z tabelą zawierającą dane płacowe wykorzystano do połączenia tabel pole EmployeeID. Taki układ pokazano na rysunku 4.9 (więcej informacji na ten temat można znaleźć w dalszej części tego rozdziału, w punkcie „Jeden do wielu”).
Rysunek 4.9. Powiązanie między tabelami pracowników i płac to przykład typowej relacji jeden do wielu
Niektóre problemy związane z wykorzystywaniem naturalnych kluczy (np. NIP-ów) omówiono w dalszej części tego rozdziału, w punkcie „Naturalne a sztuczne klucze główne”. Chociaż na rysunku 4.9 nie widać relacji, Access wie o niej, ponieważ utworzono formalną relację między tabelami tblPayroll i tblEmployees (proces ten opisano w dalszej części tego rozdziału, w podrozdziale „Tworzenie relacji i wymuszanie przestrzegania integralności odwołań”). Dzięki relacji między tymi tabelami Access potrafi odczytać wszystkie rekordy z tabeli tblPayroll odpowiadające dowolnemu pracownikowi z tabeli tblEmployees.
Rozdział 4. Relacje między tabelami
133
Przykład relacji pokazano na rysunku 4.9. Każdy rekord z tabeli tblEmployees jest powiązany z kilkoma rekordami z tabeli tblPayroll. Jest to najczęściej spotykany typ relacji w systemach baz danych, ale w żadnym razie nie jest to jedyny sposób, w jaki mogą być ze sobą powiązane dane w tabelach. W tej książce a także w większości książek dotyczących relacyjnych baz danych takich jak Access, omówiono trzy podstawowe typy relacji między tabelami:
jeden do jednego,
jeden do wielu,
wiele do wielu.
Większość relacji w bazie danych MiniAuta dla Kolekcjonerów pokazaliśmy na rysunku 4.10.
Rysunek 4.10. Większość relacji w bazie danych MiniAuta dla Kolekcjonerów
Zwróćmy uwagę, że pomiędzy tabelami bazy danych istnieje kilka relacji jeden do wielu (np. tblSales z tblSalesPayments, tblSales z tblSalesLineItems oraz tblCustomers z tblSales). Relacja ustanowiona między tabelami jest bardzo ważna. Mówi ona Accessowi, jak znaleźć i wyświetlić informacje z pól występujących w dwóch lub więcej tabelach. Program musi wiedzieć, czy szukać tylko jednego rekordu w jednej tabeli, czy wielu rekordów na podstawie relacji. Na przykład tabela tblSales jest powiązana z tabelą tblCustomers za pomocą relacji wiele do jednego. Powód tego jest taki, że główny nacisk w systemie MiniAuta dla Kolekcjonerów położono na transakcje. Oznacza to, że z każdym rekordem transakcji zawsze będzie powiązany tylko jeden klient. Inaczej mówiąc, z jednym klientem można powiązać wiele transakcji. W takiej sytuacji system MiniAuta dla Kolekcjonerów wykorzystuje tabelę tblCustomers jako tabelę przeglądową.
134
Część II Tabele Accessa Relacje mogą być bardzo zagmatwane — wszystko zależy od tego, na co położono nacisk w systemie. Na przykład pracując z tabelami tblCustomers i tblSales, można zawsze utworzyć kwerendę zawierającą relację typu jeden do wielu między tymi tabelami. Chociaż system skoncentrowany jest na transakcjach (fakturach), to jednak czasem trzeba utworzyć raport dotyczący klientów, a nie faktur. Ponieważ jeden klient może dokonać więcej niż jednej transakcji, w tabeli tblCustomers będzie zawsze tylko jeden rekord, któremu będzie odpowiadać co najmniej jeden rekord w tabeli tblSales (może ich być więcej). Właśnie stąd Access będzie wiedział, że ma szukać tylko jednego rekordu w tabeli klientów oraz wszystkich w tabeli transakcji zawierających ten sam numer klienta.
Jeden do jednego Relacja jeden do jednego między tabelami oznacza, że każdemu rekordowi w pierwszej tabeli odpowiada jeden i tylko jeden rekord w drugiej tabeli. Pojęcie relacji jeden do jednego zilustrowano na rysunku 4.11. Rysunek 4.11. Relacja typu jeden do jednego
Klasycznych relacji jeden do jednego nie stosuje się zbyt często w relacyjnych bazach danych. W większości przypadków dane zawarte w drugiej tabeli są umieszczone w pierwszej tabeli. Relacji jeden do jednego raczej się unika, gdyż naruszają one reguły normalizacji. Zgodnie z regułami normalizacji, jeśli dane opisują pojedynczy podmiot, nie należy ich rozdzielać na wiele tabel. Ponieważ osoba ma jedną i tylko jedną datę urodzenia, powinna ona się znaleźć w tabeli zawierającej inne dane tej osoby. Czasami jednak zapisywanie określonych danych razem z innymi danymi w tabeli nie jest zalecane. Na przykład rozważmy tabele pokazane na rysunku 4.11. Dane zapisane w tabeli tblSecurityIDs są poufne. Nie chcielibyśmy, aby wszystkie osoby mające dostęp do publicznych danych dotyczących klienta (nazwisko, adres itp.) miały także dostęp do poufnego kodu bezpieczeństwa używanego podczas zakupów bądź do wystawiania faktur.
Rozdział 4. Relacje między tabelami
135
Gdyby zachodziła konieczność, tabelę tblSecurityIDs można by umieścić na innym dysku w sieci lub nawet, w celu ochrony przed niepowołanym dostępem, przechowywać na przenośnym nośniku informacji. Innym przypadkiem, kiedy trzeba zastosować relację jeden do jednego, jest sytuacja, kiedy liczba pól w tabeli przekroczy dozwoloną liczbę 255. Choć takie sytuacje występują rzadko, czasem może się zdarzyć, że w pojedynczej tabeli znajduje się zbyt wiele pól. Najprostszym rozwiązaniem jest rozdzielenie danych na wiele tabel i powiązanie ich za pomocą klucza głównego (wykorzystując w każdej z tabel tę samą wartość klucza). Jeszcze inna sytuacja występuje w przypadku przesyłania danych bądź współdzielenia ich pomiędzy bazami danych. Pracownik zajmujący się wysyłką towarów nie powinien mieć dostępu do wszystkich danych klientów. Zamiast nieistotnych informacji, takich jak nazwy stanowisk, daty urodzenia, dodatkowe numery telefonów i adresy e-mail, baza danych pracownika zajmującego się wysyłką towarów powinna zawierać tylko nazwisko klienta, jego adres oraz inne informacje dotyczące wysyłki. Rekord w tabeli informacji o klientach bazy danych pracownika zajmującego się wysyłką pozostaje w relacji jeden do jednego z odpowiadającym mu rekordem w głównej tabeli danych o klientach zapisanej na centralnym komputerze w firmie. Chociaż dane są zapisane w osobnych plikach .accdb, łącza pomiędzy tabelami mogą być aktywne, co oznacza, że modyfikacje w głównej tabeli są natychmiast uwzględniane w pliku pracownika zajmującego się wysyłką. W tabelach połączonych relacją jeden do jednego niemal zawsze występuje ten sam klucz główny — na przykład identyfikator zamówienia lub numer pracownika. Bardzo rzadko występuje potrzeba utworzenia oddzielnego pola kluczowego w drugiej tabeli wchodzącej w skład relacji jeden do jednego.
Jeden do wielu Znacznie częstszym typem relacji występujących między tabelami w relacyjnych bazach danych jest relacja jeden do wielu. W takiej relacji każdy rekord z pierwszej tabeli (rodzica) jest powiązany z jednym lub większą liczbą rekordów z drugiej tabeli (dziecka). Każdy rekord z drugiej tabeli jest powiązany z jednym i tylko jednym rekordem z pierwszej tabeli. Bez wątpienia relacje jeden do wielu są najczęstszym typem relacji spotykanych w systemach relacyjnych baz danych. Przykładami relacji jeden do wielu mogą być:
Klienci i zamówienia — każdy klient (strona „jeden”) może złożyć kilka zamówień (strona „wiele”), ale poszczególne zamówienia są przesyłane przez jednego klienta.
Nauczyciel i uczniowie — każdy nauczyciel ma wielu uczniów, ale każdy uczeń ma jednego nauczyciela (oczywiście w ramach określonej klasy).
Pracownicy i wypłaty — każdy pracownik może otrzymać wiele wypłat, ale określoną wypłatę można przekazać tylko jednemu pracownikowi.
Pacjenci i kuracje — każdy pacjent jest poddawany zerowej bądź większej od zera liczbie kuracji w związku z chorobą, ale określona kuracja może być zastosowana u wielu pacjentów.
136
Część II Tabele Accessa
Zgodnie z tym, czego dowiemy się w punkcie „Tworzenie relacji i wymuszanie przestrzegania integralności odwołań” w dalszej części tego rozdziału, tworzenie relacji jeden do wielu między tabelami Accessa jest bardzo łatwe. Relację jeden do wielu zilustrowano na rysunku 4.12. W relacjach pokazanych na tym rysunku użyto tabel z bazy danych Northwind Traders. Z rysunku jasno wynika, że każdy rekord z tabeli klientów jest powiązany z kilkoma rekordami z tabeli zamówień. Zamówienie można przesłać tylko do jednego klienta, zatem pokazany układ w pełni odzwierciedla cechy relacji jeden do wielu.
Rysunek 4.12. W bazie danych Northwind Traders występują liczne relacje jeden do wielu
Chociaż rekordy po stronie „wiele” relacji pokazanej na rysunku 4.12 posortowano alfabetycznie według pola z identyfikatorem klienta, nie ma wymogu, aby rekordy w tabeli po tej stronie relacji były uporządkowane w jakiejkolwiek kolejności. Chociaż do objaśnienia relacji jeden do wielu między tabelami zazwyczaj używa się wyrażenia rodzic-dziecko, czasami można spotkać inne określenia takiego projektu, na przykład ogół-szczegóły (ang. master-detail). Należy zapamiętać, że celem mechanizmów zapewniających integralność odwołań jest zapobieżenie utracie rekordów po stronie „wiele” relacji. Mechanizmy te gwarantują, że w tabeli „wiele” nigdy nie znajdzie się osierocony rekord — taki, dla którego nie istnieje odpowiadający mu rekord rodzic. Jak się wkrótce przekonamy, istotne jest, aby zapamiętać, która tabela występuje po stronie „jeden”, a która po stronie „wiele”.
Zwróćmy uwagę na to, jak trudne byłoby zarejestrowanie wszystkich zamówień złożonych przez klienta, gdyby informacje o zamówieniach nie były zapisane w osobnej tabeli. Alternatywa, jaką jest kartotekowa baza danych omówiona we wcześniejszej części tego rozdziału, wymaga znacznie więcej aktualizacji w porównaniu z układem jeden do wielu zaprezentowanym na rysunku 4.12. Za każdym razem, kiedy klient złoży zamówienie w firmie Northwind Traders, następuje dodanie nowego rekordu do tabeli zamówień. Do tej tabeli dodawane jest tylko pole z identyfikatorem klienta (np. AROUT), które
Rozdział 4. Relacje między tabelami
137
spełnia rolę klucza obcego odwołującego się do tabeli klientów. Utrzymywanie informacji o klientach jest stosunkowo proste, ponieważ rekord każdego klienta występuje tylko raz w tabeli klientów.
Wiele do wielu Od czasu do czasu w relacyjnych systemach baz danych wykorzystuje się relacje wiele do wielu. W układzie wiele do wielu każdy rekord w obydwu tabelach może być powiązany z jednym lub większą liczbą rekordów. Mogą też wystąpić rekordy, dla których w drugiej tabeli nie ma żadnego odpowiednika. Przykład zaprezentowano na rysunku 4.13. Każdy student w tabeli tblStudents może należeć do więcej niż jednego klubu, a każdy klub z tabeli tblClubs może mieć więcej niż jednego członka.
Rysunek 4.13. Baza danych o studentach i klubach jest przykładem relacji wiele do wielu
Jak można wywnioskować na podstawie rysunku 4.13, relacje wiele do wielu są w pewnym sensie trudniejsze do zrozumienia, ponieważ nie można ich bezpośrednio zamodelować w systemach relacyjnych baz danych takich jak Access. Zamiast nich relację wiele do wielu rozbija się na dwie osobne relacje jeden do wielu połączone ze sobą za pomocą tabeli łączącej (ang. join table). Tabela ta wchodzi w relację jeden do wielu z obydwiema tabelami wchodzącymi w skład relacji wiele do wielu. Zasada ta może być na pozór nieco myląca, jednak dokładniejsza analiza rysunku 4.13 pozwala docenić zalety takiego układu. Na rysunku 4.13 można zauważyć, że student o identyfikatorze 12 (Jerzy Wielicki) należy do klubów ogrodniczego i fotograficznego (ClubID = 2 i ClubID = 3). Jest to przykładowy student należący do wielu klubów. Zarówno Jerzy Wielicki, jak i Edward Małecki (o identyfikatorach 12 i 6) należą do klubu fotograficznego (ClubID = 3). To przykład ilustrujący, że do jednego klubu może należeć wielu studentów. Każdy student może należeć do wielu klubów, a każdy klub może mieć wielu członków.
138
Część II Tabele Accessa
Z powodu dodatkowych komplikacji związanych z koniecznością zastosowania tabeli łączącej często uważa się relacje wiele do wielu za trudniejsze do ustanowienia i utrzymania. Na szczęście implementacja tego typu relacji w Accessie jest dość prosta, jeśli przestrzega się kilku reguł. Reguły te omówiono w kilku miejscach w tej książce. Na przykład w celu zaktualizowania dowolnej strony relacji wiele do wielu (np. w celu zmiany przynależności studenta do klubu) tabela łącząca musi zawierać klucze główne z obu tabel powiązanych relacją. Relacje wiele do wielu spotyka się dość powszechnie w środowiskach biznesowych:
Prawnicy i klienci (lub lekarze i pacjenci) — każdy prawnik może prowadzić kilka procesów, a jednocześnie każdego klienta w każdym procesie może reprezentować więcej niż jeden prawnik.
Pacjenci i ochrona ubezpieczeniowa — wiele osób chroni więcej niż jedna polisa ubezpieczeniowa. Na przykład jeśli pracodawcy zarówno męża, jak i żony zapewniają ubezpieczenie medyczne, oboje małżonkowie są chronieni dwiema polisami.
Wypożyczalnie płyt DVD i ich klienci — w ciągu roku każda płyta DVD jest wypożyczana przez wiele osób. Jednocześnie w ciągu roku każdy z klientów wypożycza wiele płyt DVD.
Prenumeratorzy czasopism — większość czasopism wychodzi w nakładach liczonych w tysiącach lub nawet milionach. Wiele osób prenumeruje więcej niż jedno czasopismo.
W bazie danych MiniAuta dla Kolekcjonerów występuje relacja wiele do wielu między tabelami tblCustomers i tblSalesPayments, a rolę tabeli łączącej spełnia tabela tblSales. Każdy klient może zakupić więcej niż jeden towar, a zapłata za każdy z nich może być rozłożona na więcej niż jedną płatność. Oprócz powiązania klientów i płatności transakcji są w tabeli tblSales także inne informacje, na przykład data transakcji i numer faktury. Tabela łącząca w relacjach wiele do wielu często zawiera informacje dotyczące powiązanych danych. Biorąc pod uwagę potencjalny stopień skomplikowania złączeń wiele do wielu, należy się cieszyć, że są one nieco mniej popularne od prostych relacji jeden do wielu. Jak widać na rysunku 4.13, tabela łącząca może zawierać także inne dane oprócz kluczy głównych z łączonych tabel. Tabela tblStudentToClubJoin obejmuje pole z datą dołączenia danego studenta do określonego klubu.
Reguły integralności Access zezwala na stosowanie reguł integralności odwołań, które chronią dane przed utratą lub zniszczeniem. Integralność odwołań oznacza zachowanie relacji między tabelami w przypadku aktualizacji, usuwania i innych operacji na rekordach. W modelu relacyjnym zdefiniowano kilka reguł mających na celu wymuszenie przestrzegania integralności odwołań relacyjnych baz danych. Dodatkowo Access posiada własny zbiór reguł integralności odwołań, nad których przestrzeganiem czuwa silnik bazy danych ACE.
Rozdział 4. Relacje między tabelami
139
Wyobraźmy sobie aplikację płacową, w której nie obowiązują żadne reguły używania danych w bazie. W takim systemie można by wystawić czeki niepowiązane z pracownikami. Z punktu widzenia biznesowego wystawianie czeków dla pracowników-zjaw jest bardzo groźne. Sytuacja taka może trwać do momentu kontroli, która wykryje niedociągnięcia. Integralność odwołań bazuje na polach kluczowych tabel. Integralność odwołań oznacza, że silnik bazy danych sprawdza pola kluczowe za każdym razem, kiedy w tabeli jest dodawany, modyfikowany lub usuwany klucz główny bądź obcy. Jeśli modyfikacja wartości pola kluczowego stanie się przyczyną nieprawidłowej relacji, mówi się o naruszeniu integralności odwołań. Tabele można zaprojektować w taki sposób, aby integralność odwołań była wymuszana automatycznie. Rysunek 4.14 przedstawi relację między tabelami klientów i transakcji. Tabela tblCustomers jest powiązana z tabelą tblSales za pośrednictwem pola CustomerID. Pole CustomerID w tabeli tblCustomers jest kluczem głównym tej tabeli, natomiast pole CustomerID w tabeli tblSales jest kluczem obcym. Relacja łączy każdego klienta z fakturą dotyczącą transakcji. W tej relacji tabela tblCustomers jest rodzicem, natomiast tabela tblSales — dzieckiem.
Rysunek 4.14. Typowa relacja w bazie danych
Osierocone rekordy w aplikacji bazy danych są bardzo niedobrym symptomem. Ponieważ informacje o sprzedaży są zazwyczaj wyświetlane jako lista produktów sprzedanych poszczególnym klientom, to faktura sprzedaży niepowiązana z klientem w większości przypadków nie będzie wykryta. Z łatwością można sprawdzić, które towary sprzedano firmie Strefa Zabawek, ale na podstawie dowolnego rekordu transakcji trudno stwierdzić brak istnienia klienta, który dokonał zakupu. Na rysunku 4.14 rekordy sprzedaży powiązane z firmą Strefa Zabawek zostały oznaczone za pomocą prostokątów zakreślonych wokół danych w tabeli tblSales.
140
Część II Tabele Accessa
Ponieważ nad przestrzeganiem reguł integralności odwołań czuwa silnik bazy danych Accessa, integralność danych jest zapewniona w momencie pojawienia się danych w bazie: w tabelach, kwerendach bądź formularzach. Po zdefiniowaniu wymagań integralności aplikacji nie trzeba się martwić tym, że dane w powiązanych tabelach zostaną utracone lub zdezorganizowane. W aplikacjach bazodanowych zapewnienie integralności odwołań jest niezwykle istotne. Wielu projektantów uważa, że występowaniu osieroconych rekordów można zapobiec, wykorzystując kod VBA lub odpowiedni projekt interfejsu użytkownika. Prawda jest jednak taka, że w większości baz dane zapisane w określonej tabeli mogą być używane w różnych miejscach w aplikacji (a nawet w różnych aplikacjach). Biorąc jednocześnie pod uwagę fakt, że sporo projektów baz danych realizuje się przez wiele lat i bierze w nich udział wielu programistów, trzeba uznać, że zapewnienie właściwego sposobu ochrony danych jest bardzo trudne. Najlepszym sposobem zapewnienia integralności danych zapisanych w dowolnym systemie baz danych jest wykorzystanie silnika bazy danych do wymuszenia integralności odwołań. Dzięki ogólnym zasadom integralności odwołań modelu relacyjnego rekordy zapisane w relacyjnych tabelach nie mogą zostać utracone lub pomylone. Z oczywistych powodów ważna jest ochrona kluczy głównych łączących tabele. Również zmiany wprowadzone w tabeli, które mają wpływ na inne tabele (np. usunięcie rekordu po stronie „jeden” relacji jeden do wielu), powinny być uwzględnione w powiązanej tabeli. W innym przypadku dane w obu tabelach szybko stracą synchronizację
Klucz główny nie może mieć wartości null Zgodnie z pierwszą zasadą integralności odwołań żaden klucz główny nie może zawierać wartości null. Wartość null to taka, która po prostu nie istnieje. Wartość pola, do którego nigdy nie przypisano wartości (nawet domyślnej), wynosi null. W tabeli bazy danych nie mogą się znajdować wiersze, które mają wartość null w polu klucza głównego, ponieważ podstawowym przeznaczeniem kluczy głównych jest zapewnienie niepowtarzalności wiersza. Oczywiste jest, że wartości null nie mogą być niepowtarzalne, a model relacyjny nie będzie działał, jeśli klucze główne będą miały wartość null. Dlatego Access nie zezwala na ustawienie pola, w którym znajdują się wartości null, jako klucza głównego. Co więcej, Access nie potrafi oszacować wartości null. Ponieważ wartość null nie istnieje, nie można jej porównać z żadną inną wartością. Nie jest ona ani większa, ani mniejsza od żadnej innej wartości — po prostu nie istnieje. Dlatego nie można wykorzystywać wartości null do wyszukiwania rekordów w tabeli ani do tworzenia relacji między dwiema tabelami. Access automatycznie wymusza przestrzeganie pierwszej reguły integralności odwołań. Podczas dodawania danych do tabel nie można pozostawić pustych pól kluczy głównych bez wygenerowania ostrzeżenia (jest to jeden z powodów, dla których pola typu Autonumerowanie tak dobrze się sprawdzają w roli kluczy głównych). Po wyznaczeniu pola w tabeli Accessa jako klucza głównego Access nie dopuści do usunięcia danych w tym polu ani do ich modyfikacji w taki sposób, by powstały duplikaty wartości w innym rekordzie.
Rozdział 4. Relacje między tabelami
141
W przypadku używania złożonych kluczy głównych składających się z kilku pól wszystkie pola wchodzące w skład klucza głównego muszą zawierać wartości. Żadne pole nie może być puste. Kombinacja wartości w złożonym kluczu głównym musi być niepowtarzalna.
Wszystkim wartościom kluczy obcych muszą odpowiadać klucze główne Zgodnie z drugą zasadą integralności odwołań wartościom kluczy obcych muszą odpowiadać klucze główne. Oznacza to, że w relacji jeden do wielu każdemu rekordowi w tabeli po stronie „wiele” (czyli dziecku) musi odpowiadać rekord w tabeli po stronie „jeden” (czyli rodzic). Rekord po stronie „wiele” relacji bez odpowiadającego mu rekordu po stronie „jeden” to tzw. rekord osierocony, który powinien być usunięty z bazy danych. Identyfikacja osieroconych rekordów w bazie danych może być bardzo trudna, dlatego należy przede wszystkim nie dopuścić do ich pojawienia się w tabeli. Druga reguła integralności odwołań oznacza, że:
Nie wolno dodawać wierszy do tabeli po stronie „wiele” (dziecko), jeśli nie istnieją odpowiadające im rekordy po stronie „jeden” (rodzic). Jeśli rekord-dziecko zawiera pole IDRodzica, wartość IDRodzica musi pasować do istniejącego rekordu w tabeli-rodzica.
Nie można zmienić wartości klucza głównego w tabeli po stronie „jeden”, jeśli zmiana ta spowodowałaby powstanie osieroconych rekordów w tabeli podrzędnej.
Usunięcie wiersza po stronie „jeden” nie może powodować osierocenia odpowiadających mu rekordów po stronie „wiele”.
W przykładzie dotyczącym transakcji klucz obcy w każdym rekordzie tabeli tblSales (strona „wiele”) musi pasować do klucza głównego w tabeli tblCustomers. Nie można usunąć wiersza w tabeli tblCustomers (strona „jeden”), jeśli nie usunie się odpowiadających mu rekordów w tabeli tblSales. Jednym z ciekawych efektów stosowania reguł integralności odwołań jest fakt, iż istnieje możliwość występowania rekordu-rodzica, któremu nie odpowiada żaden rekorddziecko. Intuicyjnie taka sytuacja ma sens. W firmie rzeczywiście mogą być pracownicy, którzy jeszcze nie otrzymali wypłaty. Mogłoby się też zdarzyć, że firma MiniAuta dla Kolekcjonerów zatrudniła nowego pracownika, który jeszcze nie zrealizował żadnej transakcji. Większości rekordów-rodziców odpowiada jeden lub kilka rekordów-dzieci, ale nie jest to warunek konieczny dla relacyjnych baz danych. Jak przekonamy się w następnym podrozdziale, Access umożliwia łatwe definiowanie reguł integralności do zastosowania w aplikacjach. Należy jednak pamiętać, że nieprzestrzeganie reguł integralności odwołań stwarza ryzyko powstania osieroconych rekordów oraz innych problemów z integralnością danych.
142
Część II Tabele Accessa
Klucze Kiedy tworzymy tabele, tak jak to miało miejsce w rozdziale 3., powinniśmy dla każdej z nich zdefiniować klucz główny, którego zawartość jest unikalna dla każdego rekordu. Zapewni to, że w tabeli nie będą nigdy istniały rekordy zawierające identyczne wartości. Można na przykład mieć kilku klientów o nazwisku Michał Sitkowski, którzy nawet mogą mieszkać pod tym samym adresem (ojciec i syn). W takim przypadku trzeba zdecydować, w jaki sposób utworzyć w tabeli klientów rekordy, aby odróżnić od siebie poszczególnych Michałów Sitkowskich. Unikatowa identyfikacja każdego rekordu w tabeli — właśnie to ma zapewnić klucz główny. Na przykład w bazie danych MiniAuta dla Kolekcjonerów pole CustomerID (unikatowy numer, który przypisujemy każdemu klientowi składającemu zamówienie) jest kluczem głównym tabeli tblCustomers — każdy rekord w tabeli ma w tym polu inną wartość (nie istnieją dwa rekordy o takim samym identyfikatorze). Jest to ważne z kilku powodów:
Nie chcemy mieć w tabeli tblCustomers dwóch rekordów dla tego samego klienta, ponieważ w takim przypadku uaktualnienie informacji dotyczących klienta będzie praktycznie niemożliwe.
Chcemy mieć pewność, że każdy rekord w tabeli zawiera precyzyjne dane po to, aby informacje pobrane z tabeli także były precyzyjne.
Nie chcemy, aby tabela (wraz z jej rekordami) była większa, niż jest to konieczne. Dodanie zdublowanych (redundantnych) pól i rekordów tylko komplikuje bazę danych, a nie daje żadnego pożytku.
Dzięki możliwości przypisania pojedynczej, unikalnej wartości każdemu rekordowi tabela staje się przejrzysta i czytelna. W terminologii baz danych określa się to mianem integralności jednostkowej. Mając różne wartości klucza głównego w każdym rekordzie (np. w polu CustomerID w tabeli tblCustomers), można zawsze rozróżnić dwa rekordy (w tym przypadku klientów), nawet jeśli pozostałe pola w rekordach są identyczne. Jest to ważne, ponieważ w tabeli łatwo może się znaleźć dwóch klientów o popularnym nazwisku, takim jak na przykład Andrzej Kowalski. Teoretycznie do identyfikacji klienta można by wykorzystać jego nazwisko oraz adres, ale dwóch Andrzejów Kowalskich może mieszkać w tym samym województwie, mieście, a nawet pod tym samym adresem (na przykład ojciec i syn — Andrzej Marek Kowalski i Andrzej Marian Kowalski). Celem stosowania kluczy głównych jest tworzenia w tabelach rekordów, których niepowtarzalność jest gwarantowana. Jeżeli w trakcie tworzenia tabel w Accessie nie utworzy się kluczy głównych, Access zapyta, czy ma sam to zrobić. Jeżeli odpowiemy twierdząco, utworzy klucz główny w postaci pola typu Autonumerowanie. Pole typu Autonumerowanie jest automatycznie wstawiane przy dodawaniu każdego nowego rekordu. Wartości tej nie można zmodyfikować w przypadku, gdy raz zostanie ustawiona. Co więcej, po wprowadzeniu wartości typu Autonumerowanie do tabeli nigdy nie można jej wykorzystać po raz kolejny, nawet wtedy, gdy rekord zawierający tę wartość zostanie usunięty i wartości tej już nie będzie w tabeli. Ponieważ pole typu Autonumerowanie jest dodawane do nowego rekordu przed wszystkimi innymi danymi, to jeśli z jakiegoś powodu nowy rekord nie zostanie zapisany, nowa wartość pola typu Autonumerowanie nigdy nie będzie użyta w tabeli.
Rozdział 4. Relacje między tabelami
143
Określanie klucza głównego Jak opisano powyżej, tabela zwykle ma unikalne pole (lub kombinację pól), czyli klucz główny, który zapewnia unikalność każdego rekordu. Często jest to pole identyfikatora typu Krótki tekst lub Autonumerowanie. W celu określenia wartości dla pola identyfikatora można zdefiniować metodę generowania unikatowej wartości dla pola. Może to być najprostsza metoda, czyli pozwolenie Accessowi na automatyczne konstruowanie unikatowych wartości typu Autonumerowanie, ale można też samemu tworzyć identyfikatory, na przykład przez sklejenie pierwszej litery rzeczywistej wartości z kolejną liczbą (takie jak A001, A002, A003, B001, B002 itd.). Metoda generowania unikatowych wartości może także bazować na losowych kombinacjach liter i liczb (pod warunkiem, że będą one niepowtarzalne dla każdego rekordu) lub opierać się na złożonych obliczeniach wykorzystujących kilka wartości z innych pól tabeli. Wartość klucza głównego nie musi jednak mieć w aplikacji konkretnego znaczenia. Klucz główny istnieje w tabeli tylko po to, by zapewnić niepowtarzalność każdego wiersza, oraz jako identyfikator umożliwiający tworzenie relacji z innymi tabelami. Wielu projektantów aplikacji Accessa rutynowo używa pól typu Autonumerowanie w roli kluczy głównych, ponieważ spełniają one wszystkie wymagania i nie komplikują niepotrzebnie aplikacji. Stosowanie kluczy głównych o określonym znaczeniu możne nawet prowadzić do niejasności po zmianie danych w tabeli. Jeśli klucz główny w tabeli z informacjami o pracownikach to pierwsza litera nazwiska wraz z numerem porządkowym, Anna Nowak może mieć identyfikator N001. Gdy wyjdzie za mąż i zmieni nazwisko, identyfikator przestanie być spójny z danymi z rekordu. Identyfikator nadal będzie niepowtarzalny, ale może mylić użytkowników, którzy oczekują zależności identyfikatora od nazwiska. Tabela 4.1 przedstawia i objaśnia przykładowy sposób tworzenia wartości kluczy głównych we wszystkich tabelach bazy danych aplikacji MiniAuta dla Kolekcjonerów. Jak widać w tabeli 4.1, stworzenie metody określania klucza głównego nie wymaga wiele pracy (ani nawet wyobraźni). Zawsze skuteczny jest podstawowy schemat wykorzystujący kolejne liczby. Access automatycznie zawiadomi użytkownika, jeżeli ten będzie próbował wpisać powtarzające się wartości klucza głównego. Aby uniknąć powtarzania się wartości, można po prostu dodać do kolejnej liczby wartość 1. Tabela 4.1. Wyznaczanie kluczy głównych Tabela
Tworzenie wartości klucza głównego
tblCustomers
Firmy: pole typu Autonumerowanie przypisane przez Accessa
tblSales
Numer faktury: pole typu Autonumerowanie
tblSalesLineItems
Numer faktury (z tabeli transakcji) oraz pole typu Autonumerowanie
tblProducts
Numer produktu określany przez osobę wprowadzającą nowy produkt
tblSalesPayments
Numer faktury (z tabeli transakcji) oraz pole typu Autonumerowanie
tblSalesperson
Identyfikator przedstawiciela: pole typu Autonumerowanie
tblCategories
Kategoria produktu: określana przez osobę wprowadzającą nowy rekord
144
Część II Tabele Accessa
Chociaż wykorzystanie logiki (zaimplementowanej na przykład za pomocą kodu VBA) do wygenerowania unikatowych wartości w polu klucza głównego nie jest trudne, zdecydowanie najprostszym i najłatwiejszym sposobem jest używanie w roli kluczy głównych tabeli pól typu Autonumerowanie. Specjalne cechy pól typu Autonumerowanie (automatyczne generowanie, niepowtarzalne wartości, brak możliwości modyfikacji itp.) powodują, że pola te są idealnymi kandydatami na klucze główne. Co więcej, wartości typu Autonumerowanie to nic innego jak 4-bajtowa liczba całkowita. Dzięki temu zarządzanie nią przez silnik bazy danych jest bardzo szybkie i łatwe. Biorąc pod uwagę wszystkie te powody, w tabelach systemu MiniAuta dla Kolekcjonerów w roli kluczy głównych wykorzystano wyłącznie pola typu Autonumerowanie. Pola Autonumerowanie zawsze są niepowtarzalne, ale nie ma gwarancji, że będą zawierały kolejne wartości. W ciągu wartości w takich polach z różnych powodów (np. w wyniku usunięcia rekordów) mogą pojawić się luki, dlatego nie należy zakładać, że w polach tych znajdują się kolejne numery.
Można by sądzić, że wykorzystanie kolejnych liczb utrudnia odszukanie interesujących informacji w tabelach. Należy jednak pamiętać, że zwykle nie wyszukuje się informacji w tabeli na podstawie wartości pola identyfikatora. Zazwyczaj informacje wyszukuje się z uwzględnieniem przeznaczenia tabeli. Na przykład w tabeli tblCustomers informacji dotyczących określonego klienta będzie się szukało według jego nazwiska i imienia lub obu tych pól. Nawet jeśli w wielu rekordach występuje to samo nazwisko, do znalezienia właściwego klienta można użyć innych pól w tabeli (takich jak kod pocztowy, numer telefonu). Jeżeli nie znamy z góry identyfikatora, to prawdopodobnie nigdy nie będziemy musieli na jego podstawie wyszukiwać informacji na temat klienta.
Korzyści wynikające ze stosowania kluczy głównych Czy zdarzyło Ci się kiedyś składać po raz pierwszy w jakiejś firmie zamówienie, a na drugi dzień zdecydować się na jego zmianę? Czasami firma pyta wtedy o numer klienta. Klient zwykle odpowiada, że go nie pamięta. Przedstawiciel firmy w takim przypadku pyta klienta o jakieś inne dane, na przykład kod pocztowy lub nazwisko. Wtedy, gdy już zawęzi listę klientów, zapyta o adres. Po odnalezieniu nazwiska w bazie danych będzie mógł dotrzeć do numeru klienta. W niektórych firmach wykorzystuje się numery telefonów lub adresy e-mail jako unikalne dane pozwalające zidentyfikować klientów. Zagadnienia związane z kluczami głównymi i obcymi były omawiane w rozdziale 1., ale ponieważ pojęcia te są tak ważne w aplikacjach bazodanowych, ponownie opisaliśmy te kwestie w tym rozdziale.
Systemy baz danych zazwyczaj zawierają więcej niż jedną tabelę. Tabele te są ze sobą w jakiś sposób powiązane. Na przykład w bazie danych MiniAuta dla Kolekcjonerów tabele tblCustomers i tblSales są powiązane za pośrednictwem pola CustomerID. Ponieważ każdy klient to pojedyncza osoba, w tabeli tblCustomers potrzebny jest tylko jeden rekord. Jednak każdy klient może dokonywać wielu transakcji, co powoduje, że potrzebna jest inna tabela służąca do przechowywania informacji na temat tych transakcji — tblSales. Każda transakcja jest jedną fizyczną transakcją (w określonym dniu i o określonej godzinie). Pole CustomerID służy do powiązania klientów z transakcjami.
Rozdział 4. Relacje między tabelami
145
Klucz główny w tabeli-rodzicu (pole CustomerID w tabeli tblCustomers) jest powiązany z kluczem obcym w tabeli-dziecku (pole CustomerID w tabeli tblSales). Poza pełnieniem funkcji łącznika pomiędzy tabelami klucz główny w Accessie zapewnia następujące korzyści:
Pola kluczy głównych zawsze są poindeksowane, co znacznie przyspiesza wykonywanie kwerend, wyszukiwanie oraz sortowanie.
Każdorazowo podczas dodawania do tabeli nowych rekordów Access wymusza wprowadzanie w nich wartości (lub automatycznie sam wprowadza wartość w przypadku pól typu Autonumerowanie). Dzięki temu uzyskujemy gwarancję, że baza danych będzie spełniała wymagania integralności odwołań.
Podczas dodawania nowych rekordów do tabeli ze zdefiniowanym kluczem głównym Access sprawdza, czy dane w kolumnie klucza głównego nie powtarzają się, i zapobiega wprowadzaniu duplikatów. W ten sposób zapewnia integralność danych.
Domyślnie Access wyświetla dane w kolejności wynikającej z wartości klucza głównego. Indeks jest specjalnym wewnętrznym plikiem utworzonym po to, aby umieszczać rekordy w tabeli w pewien określony sposób. Na przykład pole klucza głównego w tabeli tblCustomers jest indeksem, który porządkuje rekordy w tabeli w kolejności określonej przez pole CustomerID. Dzięki wykorzystaniu indeksowanych tabel Access może wyświetlać rekordy w określony sposób oraz szybko wyszukiwać za pomocą indeksu dowolny rekord w tabeli.
Wybór klucza głównego Po lekturze poprzednich podrozdziałów Czytelnicy prawdopodobnie dobrze wiedzą, że wybór klucza głównego w tabeli to ważny krok w kierunku wzmocnienia projektu bazy danych. Odpowiednio zaimplementowane klucze główne pomagają w stabilizacji i ochronie danych zapisanych w bazach danych Accessa. Zgodnie z tym, co przeczytaliśmy w poprzednich podrozdziałach, pamiętajmy, że generalną zasadą rządzącą kluczami głównymi jest niepowtarzalność wartości pola kluczowego w bazie danych. Ponadto idealny klucz główny powinien być stabilny. Klucze główne składające się z pojedynczych pól, a klucze złożone Jeśli w tabeli nie istnieje idealny klucz główny w postaci pojedynczej wartości, można połączyć pola i utworzyć złożony klucz główny. Na przykład istnieje niewielkie prawdopodobieństwo, aby samo imię bądź samo nazwisko mogło służyć jako klucz główny, ale już połączenia imienia z nazwiskiem i datą urodzenia może umożliwić znalezienie kombinacji wartości, które nadają się do wykorzystania w roli klucza głównego. Jak będzie się można przekonać w punkcie „Tworzenie relacji i wymuszanie przestrzegania integralności odwołań” w dalszej części tego rozdziału, tworzenie kombinacji pól w celu ich wykorzystania jako kluczy głównych jest w Accessie bardzo łatwe. W przypadku korzystania z kluczy złożonych należy przestrzegać kilku reguł:
Żadne z pól wchodzących w skład klucza złożonego nie może mieć wartości null.
146
Część II Tabele Accessa
Bywa, że stworzenie klucza głównego na podstawie danych naturalnie występujących w tabeli jest trudne. Czasami rekordy w obrębie tabeli różnią się jednym bądź dwoma polami, pomimo że większość pozostałych pól w tabeli ma taką samą wartość.
Każde z pól może się powtarzać w obrębie tabeli, ale kombinacja pól tworzących klucz złożony nie może się powtarzać.
Jednak podobnie jak w przypadku innych aspektów projektu bazy danych, z kluczami złożonymi może być związanych wiele problemów:
Występowanie kluczy złożonych zwykle komplikuje projekt bazy danych. Jeśli użyjemy trzech pól w tabeli nadrzędnej do zdefiniowania klucza głównego tabeli, te same trzy pola muszą występować we wszystkich tabelach podrzędnych.
Zapewnienie istnienia wartości dla wszystkich pól wchodzących w skład klucza złożonego (tak, aby żadne z nich nie miało wartości null) również może być dość kłopotliwe. Większość projektantów unika stosowania kluczy złożonych, jeśli nie są one absolutnie konieczne. W wielu przypadkach problemy związane z zastosowaniem kluczy złożonych znacznie przewyższają niewielkie korzyści wynikające ze stosowania kluczy złożonych wygenerowanych na podstawie danych w obrębie rekordu.
Naturalne a sztuczne klucze główne Wielu projektantów jest zdania, że należy używać wyłącznie naturalnych kluczy głównych. Naturalne klucze główne uzyskuje się na podstawie danych występujących w tabeli, np. NIP-u lub numeru pracownika. Jeśli w tabeli nie istnieje pojedyncze pole, które mogłoby w unikatowy sposób identyfikować rekordy w tabeli, projektanci ci radzą łączenie pól w celu stworzenia złożonych kluczy głównych. Istnieje jednak wiele sytuacji, w których nie ma „doskonałego” naturalnego klucza w tabelach bazy danych. Chociaż takie pola jak NumerNIP wydają się idealnymi kandydatami do roli kluczy głównych, z danymi tego rodzaju występuje szereg problemów:
Dane te nie są uniwersalne. Nie każdy posiada NIP.
Wartość może być nieznana w czasie dodawania rekordu do bazy danych. Ponieważ klucze główne nigdy nie mogą mieć wartości null, trzeba zapewnić możliwość wprowadzania swego rodzaju tymczasowego klucza głównego w sytuacji, kiedy NIP nie jest znany. Następnie trzeba przedsięwziąć właściwe kroki w celu wprowadzenia poprawek zarówno w tabeli nadrzędnej, jak i w tabelach podrzędnych w momencie, kiedy wartość zostanie ustalona.
Wartości w rodzaju NIP-ów zwykle mają dość duży rozmiar. NIP ma co najmniej dziesięć znaków, nie licząc nawet kresek rozdzielających poszczególne grupy cyfr. Rozbudowane klucze główne niepotrzebnie komplikują obliczenia i działają wolniej od mniejszych kluczy głównych.
Istnieją ograniczenia prawne ich stosowania. NIP jest uważany za dane osobowe i podlega ochronie zgodnie z ustawą o ochronie danych osobowych (to samo dotyczy np. numeru ubezpieczenia społecznego w Stanach Zjednoczonych).
Rozdział 4. Relacje między tabelami
147
Zdecydowanie największym problemem jest fakt, iż dodanie rekordu do tabeli jest niemożliwe, jeśli wartość klucza głównego jest nieznana w momencie dodawania rekordu do bazy danych. Nawet jeśli wprowadzi się tymczasowe wartości do czasu poznania ostatecznej wartości, nakład pracy, jaki trzeba włożyć w rozwiązanie problemu, jest znaczny. W przypadku, gdy nie włączono opcji kaskadowej aktualizacji, nie można zmodyfikować wartości klucza głównego, jeśli w innych tabelach istnieją powiązane z nim rekordy.
Chociaż wartości typu Autonumerowanie nie występują naturalnie w danych w tabelach, to ze względu na istotne korzyści związane z używaniem prostych wartości liczbowych, które są generowane automatycznie i nie można ich usunąć bądź zmodyfikować, w większości przypadków są one idealnymi kandydatami do roli kluczy głównych. Tworzenie kluczy głównych Aby utworzyć klucz główny, należy otworzyć tabelę w widoku projektu, wybrać pole (lub pola), które ma być użyte w roli klucza głównego, i kliknąć przycisk Klucz podstawowy w zakładce NARZĘDZIA TABEL PROJEKTOWANIE na wstążce. Aby zaznaczyć więcej niż jedno pole w celu utworzenia klucza złożonego, należy przed kliknięciem przycisku Klucz podstawowy przytrzymać klawisz Ctrl i za pomocą myszy wybrać pola, które mają utworzyć klucz złożony. Sposoby definiowania kluczy głównych w tabelach opisano szczegółowo w rozdziale 2.
Tworzenie relacji i wymuszanie przestrzegania integralności odwołań Okno Relacje umożliwia zdefiniowanie relacji oraz reguł integralności odwołań, które mają być stosowane do tabel wchodzących w skład relacji. Utworzenie trwałych, zarządzanych relacji zapewniających zachowanie integralności odwołań pomiędzy tabelami Accessa jest łatwe: 1. Wybierz polecenie NARZĘDZIA BAZY DANYCH/Relacje. Wyświetli się okno Relacje. 2. Kliknij przycisk Pokaż tabelę na wstążce albo kliknij prawym przyciskiem myszy w oknie Relacje, po czym wybierz polecenie Pokaż tabelę z menu podręcznego. Na ekranie pojawi się okno Dodaj tabelę, podobne do pokazanego na rysunku 4.15. 3. Dodaj tabele tblBookOrders5 i tblOrderDetails do okna Relacje (dwukrotnie kliknij nazwę każdej tabeli w oknie dialogowym Pokaż tabelę albo zaznacz każdą tabelę i kliknij przycisk Dodaj). 4. Aby utworzyć relację, wystarczy przeciągnąć pole klucza głównego tabeli po stronie „jeden” i upuścić na kluczu obcym po stronie „wiele”. Można również przeciągnąć pole klucza obcego i upuścić je na polu klucza głównego. W tym przykładzie przeciągnij pole OrderID z tabeli tblBookOrders5 i upuść je na polu OrderID w tabeli tblBookOrderDetails. Access otworzy okno dialogowe Edytowanie relacji (zobacz rysunek 4.16), które umożliwia określenie szczegółów dotyczących relacji tworzonej między tabelami. Zwróćmy uwagę, że Access rozpoznał typ relacji między tabelami tblBookOrders5 i tblBookOrderDetails jako jeden do wielu.
148
Część II Tabele Accessa
Rysunek 4.15. Aby dodać tabelę do okna Relacje, należy kliknąć dwukrotnie jej nazwę
5. Określ reguły integralności odwołań, których przestrzeganie Access ma wymuszać w bazie danych. Spójrzmy na rysunek 4.16 i zwróćmy uwagę na opcję Kaskadowo usuń rekordy pokrewne. Gdyby jej nie zaznaczono, Access nie pozwoliłby na usunięcie rekordów z tabeli tblBookOrders5 (po stronie „jeden”), jeśli wcześniej ręcznie nie usunięto by wszystkich powiązanych rekordów z tabeli tblBookOrderDetails (po stronie „wiele”). Dzięki zaznaczeniu tego pola wyboru usuwanie w ramach relacji odbywa się automatycznie. Kaskadowe usuwanie rekordów może być niebezpieczne, ponieważ usuwanie w tabeli po stronie „wiele” jest wykonywane bez potwierdzenia. Rysunek 4.16. Wymuszanie przestrzegania integralności odwołań za pomocą okna dialogowego Edytowanie relacji
6. Kliknij przycisk Utwórz. Access wykreśli linię pomiędzy tabelami wyświetlanymi w oknie Relacje. Linia ta określa typ relacji. Symbol 1 na rysunku 4.17 oznacza, że tabela tblBookOrders5 znajduje się po stronie „jeden” relacji, natomiast symbol nieskończoności (∞) oznacza, że tabela tblBookOrderDetails jest po stronie „wiele”. Rysunek 4.17. Relacja jeden do wielu między tabelami tblBookOrders5 i tblBookOrderDetails
Rozdział 4. Relacje między tabelami
149
Określanie typu złączenia między tabelami Po prawej stronie okna Edytowanie relacji są cztery przyciski:
Utwórz — kliknięcie przycisku Utwórz powoduje powrót do okna Relacje, w którym będą uwzględnione wprowadzone wcześniej zmiany.
Anuluj — przycisk Anuluj unieważnia dokonane zmiany i także powoduje powrót do okna Relacje.
Typ sprzężenia — kliknięcie przycisku Typ sprzężenia powoduje otwarcie okna dialogowego Właściwości sprzężenia.
Utworzy nowe — za pomocą przycisku Utwórz nowe można utworzyć nową relację między dwiema tabelami i polami.
W przypadku uruchamiania kwerendy dotyczącej powiązanych tabel Access domyślnie zwraca tylko te rekordy, które występują w obu tabelach. W naszym przykładzie systemu płac, który omawialiśmy w punkcie „Reguły integralności specyficzne dla aplikacji” we wcześniejszej części tego rozdziału, oznacza to wyświetlanie danych tylko tych pracowników, dla których istnieją poprawne rekordy czeków płacowych w tabeli z danymi o czekach. W wynikach kwerendy nie będzie danych pracowników, którzy dotąd nie otrzymali czeku z wypłatą. Takie relacje czasami określa się jako złączenia wewnętrzne (ang. inner join), ponieważ występują w nich tylko te rekordy, które istnieją po obu stronach relacji. Nie jest to jednak jedyny typ złączeń obsługiwanych przez Accessa. Kliknięcie przycisku Typ sprzężenia powoduje otwarcie okna dialogowego Właściwości sprzężenia. Alternatywne ustawienia w oknie dialogowym Typ sprzężenia umożliwiają określenie, czy w wynikach mają się pojawić wszystkie rekordy zarówno z tabeli-rodzica, jak i z tabeli-dziecka, niezależnie od tego, czy istnieje odpowiednik po drugiej stronie (dopuszcza się możliwość występowania niedopasowanego rekordu-dziecka pod warunkiem, że klucz obcy w tabelidziecku ma wartość null). Takie złączenie (nazywane złączeniem zewnętrznym; ang. outer join) jest bardzo przydatne, ponieważ dokładnie odzwierciedla stan danych w aplikacji. W przypadku bazy danych MiniAuta dla Kolekcjonerów oznacza to wyświetlanie danych wszystkich klientów, niezależnie od tego, czy istnieją dla nich rekordy w tabeli transakcji — to jest to, o co nam chodzi. Aby zdefiniować złączenie zewnętrzne łączące klientów z transakcjami, wykonaj następujące czynności: 1. W oknie Relacje dodaj tabele tblCustomers i tblSales. 2. Przeciągnij pole CustomerID z jednej tabeli do drugiej. Pojawi się okno dialogowe Edytowanie relacji. 3. Kliknij przycisk Typ sprzężenia. Wyświetli się okno Właściwości sprzężenia (zobacz rysunek 4.18). Rysunek 4.18. Okno dialogowe Właściwości sprzężenia, służące do określania właściwości sprzężenia pomiędzy tabelami tblCustomers oraz tblSales. Zauważmy, że wybrano opcję uwzględniania wszystkich rekordów z tabeli klientów
150
Część II Tabele Accessa
4. Kliknij przycisk opcji Uwzględnia WSZYSTKIE rekordy z „tblCustomers” i tylko te rekordy z „tblSales”, dla których sprzężone pola są równe. 5. Kliknij OK. Access powróci do okna dialogowego Edytowanie relacji. 6. Kliknij OK. Access powróci do okna Relacje. W oknie Relacje powinna teraz pokazać się strzałka skierowana od tabeli tblCustomers w stronę tabeli tblSales. W tym momencie wszystko jest przygotowane do określenia więzów integralności pomiędzy dwiema tabelami złączenia zewnętrznego. Aby zmodyfikować istniejącą relację, kliknij dwukrotnie linię tej relacji w oknie Relacje. Pojawi się okno dialogowe Edytowanie relacji. Możesz w nim zmienić ustawienia dotyczące integralności odwołań i typu złączenia.
Jeśli złączenie zostanie zdefiniowane w sposób pokazany na rysunku 4.18, w kwerendach korzystających z tabel klientów i transakcji zostaną zwrócone rekordy wszystkich klientów — nawet tych, którzy jeszcze nie składali zamówień. Wprowadzenie takiego ustawienia pozwala na uzyskanie pełniejszego obrazu klientów firmy, wyświetlają się bowiem wszyscy klienci, a nie tylko ci, którzy składali zamówienia. Określanie typu złączenia dla wszystkich relacji w bazie danych nie jest absolutnie konieczne. W następnych rozdziałach dowiemy się, że można określić złączenia zewnętrzne dla każdej kwerendy w aplikacji. Wielu projektantów korzysta z domyślnych złączeń wewnętrznych dla wszystkich relacji w tworzonych przez siebie bazach danych i modyfikuje właściwości złączenia na poziomie indywidualnych kwerend w celu uzyskania pożądanych wyników. Wymuszanie więzów integralności Po zdefiniowaniu relacji, zweryfikowaniu tabel i pól łączących za pomocą okna dialogowego Edytowanie relacji oraz ustaleniu typu złączenia można określić więzy integralności pomiędzy tabelami. W tym celu należy zaznaczyć pole wyboru Wymuszaj więzy integralności znajdujące się w dolnej części okna Edytowanie relacji. To oznacza, że chcemy, by Access wymuszał stosowanie reguł integralności dla relacji między tabelami. Jeżeli zrezygnujemy z wymuszania więzów integralności, użytkownicy będą mogli dodawać nowe rekordy, zmieniać wartości w polach kluczowych oraz usuwać rekordy bez zwracania uwagi na więzy integralności — niesie to ze sobą ryzyko modyfikacji zawartości krytycznych pól i uszkodzenia danych aplikacji. Bez aktywnych więzów integralności można doprowadzić do powstania osieroconych rekordów (transakcji bez klienta). Dla zwykłych operacji (takich jak wpisywanie czy modyfikowanie informacji) więzy integralności powinny być wymuszane.
Wymuszanie więzów integralności daje również dostęp do dwóch innych opcji (kaskadowych aktualizacji i kaskadowego usuwania wierszy), które mogą się przydać w pewnych sytuacjach. Opcje te można znaleźć w dolnej części okna dialogowego Edytowanie relacji (zobacz rysunek 4.16). Po zaznaczeniu pola wyboru Wymuszaj więzy integralności i kliknięciu przycisku Utwórz (lub przycisku OK, jeżeli okno Edytowanie relacji zostało otwarte dla istniejącej relacji) może się okazać, że Access nie pozwoli na utworzenie tak zdefiniowanej relacji z zastosowanymi więzami integralności. Powodem prawdopodobnie jest to, że chcemy utworzyć relację dla tabel, w których rekordy naruszają reguły z tego wynikające
Rozdział 4. Relacje między tabelami
151
(np. w tabeli podrzędnej istnieją rekordy osierocone). W takiej sytuacji Access wyświetli ostrzeżenie w oknie dialogowym podobnym do pokazanego na rysunku 4.19. Ostrzeżenie w tym przypadku wyświetla się dlatego, że w tabeli tblSales istnieją rekordy, które nie mają odpowiedników w tabeli przedstawicieli. Z tego powodu Access nie może utworzyć więzów integralności pomiędzy wskazanymi tabelami, gdyż zapisane w nich dane naruszają reguły integralności.
Rysunek 4.19. Okno dialogowe z ostrzeżeniem o braku możliwości wymuszania więzów integralności z powodu naruszenia reguł Aby rozwiązać konflikty występujące pomiędzy istniejącymi tabelami, można za pomocą kreatora kwerend utworzyć kwerendę wyszukującą niedopasowane dane, która odnajdzie wszystkie rekordy po stronie „wiele” relacji naruszające reguły więzów integralności. Następnie można zmienić typ kwerendy na kwerendę usuwającą i za jej pomocą usunąć niewłaściwe rekordy lub wpisać poprawne wartości w polu SalespersonID.
Można usunąć nieodpowiednie rekordy, powrócić do okna relacji i wtedy ustalić wymuszanie więzów integralności pomiędzy tabelami. To, czy porządkowanie danych poprzez usuwanie rekordów jest właściwe, zależy od reguł biznesowych zarządzających aplikacją. Usuwanie zamówień tylko dlatego, że nie można wymusić więzów integralności, w większości przypadków jest niewłaściwe. Zaznaczenie opcji Kaskadowo aktualizuj pola pokrewne
Jeżeli w oknie Edytowanie relacji zaznaczy się pole Wymuszaj więzy integralności, Access uaktywni pole opcji o nazwie Kaskadowo aktualizuj pola pokrewne. Ta opcja mówi Accessowi o tym, że jeśli użytkownik zmieni zawartość powiązanych ze sobą pól (pól klucza głównego w tabeli nadrzędnej, np. CustomerID), zmiana ta będzie uwzględniona we wszystkich powiązanych tabelach. Jeśli pole klucza głównego w tabeli nadrzędnej jest powiązane z kilkoma tabelami, opcję tę należy zaznaczyć dla wszystkich powiązanych tabel. Jeśli się tego nie zrobi, opcja nie będzie działała prawidłowo.
Ogólnie rzecz biorąc, jest bardzo niewiele powodów, dla których warto by zmieniać wartość klucza głównego. Podany w punkcie „Wiązanie danych” we wcześniejszej części rozdziału przykład dotyczący brakującego NIP-u jest jednym z przypadków, kiedy może zachodzić potrzeba zastąpienia tymczasowego NIP-u stałym już po dodaniu danych pracownika do bazy danych. Jednak gdy używamy pól typu Autonumerowanie lub innych sztucznych wartości kluczy, po dodaniu rekordu do bazy danych bardzo rzadko występują powody, dla których należałoby zmodyfikować wartość klucza.
152
Część II Tabele Accessa Zaznaczenie opcji Kaskadowo usuń rekordy pokrewne
Opcja Kaskadowo usuń rekordy pokrewne instruuje Accessa o tym, że należy usunąć wszystkie powiązane rekordy pokrewne w przypadku usunięcie rekordu nadrzędnego. Chociaż czasami opcja ta może się przydać, to stosując ją, należy — podobnie jak w przypadku wielu innych opcji — zachować szczególną ostrożność. Na przykład jeżeli zaznaczymy pole wyboru Kaskadowo usuń rekordy pokrewne i spróbujemy usunąć określonego klienta (który przeprowadził się za granicę), Access najpierw usunie wszystkie związane z nim rekordy z tabel podrzędnych tblSales i tblSales LineItems, a dopiero potem usunie rekord klienta. Mówiąc inaczej: Access usunie wszystkie rekordy pozycji transakcji (szczegóły transakcji) dla wszystkich transakcji danego klienta, następnie wszystkie rekordy transakcji dla danego klienta i na końcu sam rekord klienta — wszystko podczas jednej operacji. Wielu Czytelników z pewnością już zauważyło, na czym polega podstawowy problem związany z kaskadowym usuwaniem rekordów. Jeśli razem z usunięciem danych o kliencie zostaną usunięte wszystkie rekordy dotyczące jego transakcji, nie będzie sposobu na utworzenie raportu zawierającego historyczne dane finansowe. Nie będzie można na przykład przedstawić wiarygodnych informacji na temat danych handlowych z poprzedniego roku, ponieważ wszystkie rekordy transakcji byłych klientów zostały usunięte z bazy danych. W tym konkretnym przykładzie utracilibyśmy również możliwość tworzenia raportów na temat trendów w sprzedaży, wielkości sprzedaży poszczególnych kategorii produktów, a także różnego rodzaju inne sposoby wykorzystania danych aplikacji. Znacznie sensowniejszym postępowaniem byłoby zdefiniowanie pola Active (typu Tak/Nie) w tabeli klientów. Pole to wskazywałoby klientów, którzy są aktywni. Z łatwością można by wówczas uwzględnić wartość pola Active w tych kwerendach, w których interesują nas tylko klienci aktywni (Active = Tak), i zignorować wartość pola Active w tych kwerendach, w których potrzebne są wszystkie transakcje (niezależnie od statusu aktywności klienta). Aby skorzystać z tej opcji, trzeba zaznaczyć pole Kaskadowo usuń rekordy pokrewne dla wszystkich relacji związanych z daną tabelą istniejących w bazie. Jeśli nie zaznaczy się tej opcji dla wszystkich tabel w łańcuchu powiązanych tabel, Access nie zezwoli na kaskadowe usuwanie rekordów.
Ogólnie rzecz biorąc, zezwalanie na kaskadowe usuwanie rekordów w bazie danych wydaje się złym pomysłem. Bardzo łatwo o przypadkowe usunięcie ważnych danych. Wyobraźmy sobie sytuację, w której użytkownik przypadkowo usuwa klienta, zerując całą historię jego transakcji — włącznie z płatnościami, wysyłkami, reklamacjami, promocjami i innymi działaniami. Jest bardzo mało sytuacji, w których można zezwolić użytkownikom na usuwanie wielu różnych rodzajów danych w pojedynczej operacji.
Przeglądanie wszystkich relacji Aby obejrzeć wszystkie relacje zdefiniowane w bazie danych, należy w zakładce NARZĘDZIA RELACJI PROJEKTOWANIE na wstążce wybrać polecenie Wszystkie relacje. Aby uprościć widok wyświetlany w oknie Relacje, można ukryć niektóre relacje poprzez usunięcie tabel wyświetlanych w tym oknie. Aby to zrobić, wystarczy kliknąć tabelę, a następnie wcisnąć klawisz Delete. Kiedy się to zrobi, Access usunie tabelę z okna Relacje. Usunięcie tabeli z okna Relacje nie powoduje usunięcia relacji między tabelą a innymi tabelami w bazie danych.
Rozdział 4. Relacje między tabelami
153
Podczas tworzenia tabel bazy danych należy sprawdzić, czy właściwość Wymagane dla pola klucza obcego w powiązanej tabeli (w przypadku tabel tblBookOrders5 i tblBookOrderDetails kluczem obcym jest pole OrderID w tabeli tblBookOrderDetails) ustawiono na wartość Tak. Ustawienie to daje pewność, że użytkownik wprowadzi wartość w polu klucza obcego, co daje możliwość utworzenia relacji między tabelami. Relacje utworzone w oknie Relacje mają charakter trwały i są zarządzane przez Accessa. Po utworzeniu trwałych relacji pojawiają się one domyślnie w oknie projektu kwerendy w momencie dodania tabel wchodzących w ich skład (kwerendy opisano bardziej szczegółowo w części III). Nawet bez zdefiniowania trwałych relacji między tabelami można stworzyć relacje tymczasowe za każdym razem, kiedy dodamy wiele tabel w oknie projektu kwerendy.
Usuwanie relacji Od czasu do czasu pojawia się potrzeba usunięcia relacji między tabelami. Okno Relacje to jedynie obraz relacji między tabelami. Jeśli otworzymy okno Relacje i po kliknięciu każdej z tabel wchodzących w skład relacji wciśniemy klawisz Delete, usuniemy obraz tabel wchodzących w skład relacji, ale nie samą relację. Aby usunąć relację, należy kliknąć linię łączącą tabele, a następnie wcisnąć klawisz Delete. Dopiero potem należy usunąć obraz każdej z tabel, które tworzyły relację.
Reguły integralności specyficzne dla aplikacji Oprócz reguł integralności wymuszanych przez silnik bazy danych ACE można zdefiniować szereg reguł biznesowych, które są wymuszane przez aplikacje tworzone w Accessie. W wielu przypadkach klienci lub użytkownicy informują o regułach biznesowych, które powinna spełniać aplikacja. Do zadań programisty należy utworzenie kodu Visual Basica, zaprojektowanie tabel, właściwości pól itp., czyli zaimplementowanie reguł biznesowych sformułowanych przez użytkowników. Typowe reguły biznesowe obejmują zagadnienia podobne do następujących:
Pracownik zajmujący się wprowadzaniem zamówień powinien wprowadzić swój identyfikator na formularzu używanym do wprowadzania danych.
Nie można wprowadzać liczby sztuk mniejszej od zera.
Cena jednostkowa sprzedaży nigdy nie może być niższa od ceny zakupu.
Data wysyłki zamówienia musi określać dzień po dacie zamówienia.
Najczęściej reguły te formułuje się w odniesieniu do tabeli w momencie jej projektowania. Wymuszenie takich reguł w znacznym stopniu wpływa na ochronę wartości danych zarządzanych przez bazę. Na przykład na rysunku 4.20 właściwość Reguła poprawności dla pola z liczbą sztuk (>=0) zapewnia, że liczba nigdy nie może być ujemna. Jeśli magazynier spróbuje wprowadzić liczbę ujemną w polu Quantity, wyświetli się okno z komunikatem o błędzie zawierające zdefiniowany tekst ostrzeżenia (Ta wartość nie może być ujemna).
154
Część II Tabele Accessa
Rysunek 4.20. Prosta reguła sprawdzania poprawności w dużym stopniu przyczynia się do ochrony integralności bazy danych
Reguły sprawdzania poprawności można również definiować na poziomie tabeli, używając właściwości Reguła poprawności w Arkuszu właściwości. Reguły te zapewniają ochronę danych w tabeli. Niestety, dla całej tabeli można utworzyć tylko jedną regułę. W związku z tym zdefiniowanie odpowiedniego tekstu dla wszystkich możliwych przypadków naruszenia reguły jest trudne. Właściwość Reguła poprawności ma pewne ograniczenia. Na przykład nie można wykorzystać w niej funkcji zdefiniowanych przez użytkownika. Ponadto w regułach nie można używać tu innych pól, danych z innych rekordów ani innych tabel. Reguły poprawności uniemożliwiają wprowadzanie danych zamiast wyświetlać ostrzeżenia, które użytkownik mógłby zignorować. Jeśli chcesz udostępniać ostrzeżenie, a przy tym umożliwić kontynuowanie pracy, nie stosuj reguł poprawności. W książce znajdziesz przykłady zastosowania kodu VBA do wymuszania reguł biznesowych.
Rozdział 5.
Praca z tabelami W tym rozdziale:
Arkusze danych
Okno arkusza danych
Otwieranie arkusza danych
Wpisywanie nowych danych
Poruszanie się między rekordami
Modyfikowanie wartości w arkuszu danych
Korzystanie z możliwości wycofywania zmian
Kopiowanie i wklejanie wartości w arkuszu danych
Zastępowanie wartości w arkuszu danych
Dodawanie nowych rekordów w arkuszu danych
Usuwanie rekordów w arkuszu danych
Wyświetlanie rekordów w arkuszu danych
Sortowanie i filtrowanie rekordów
Agregowanie danych
Drukowanie rekordów
W tym rozdziale skorzystamy z widoku arkusza danych do wprowadzania danych do tabel Accessa oraz do wyświetlania danych na wiele różnych sposobów. Korzystając z widoku arkusza danych, można obejrzeć wiele rekordów naraz w znanym formacie podobnym do arkusza kalkulacyjnego. Użyjemy tabel tblContacts i tblProducts do wprowadzania, modyfikowania i usuwania danych, a także poznamy inne własności dostępne w widoku arkusza danych. W tym rozdziale wykorzystano bazę danych Rozdział05.accdb. Jeżeli ktoś jeszcze nie skopiował przykładów na dysk swojego komputera, powinien zrobić to teraz.
156
Część II Tabele Accessa
Arkusze danych Arkusze danych to jeden z wielu sposobów na przeglądanie danych w Accessie. Arkusz danych przedstawia dane w postaci wierszy i kolumn. Widok arkusza danych tabeli zaprezentowano na rysunku 5.1. Każdy wiersz reprezentuje pojedynczy rekord w tabeli, a każda kolumna — jedno pole. Aby zobaczyć wiersze (rekordy), które nie mieszczą się na ekranie, należy przewinąć ekran w górę lub w dół. Aby obejrzeć niewidoczne kolumny (pola), wystarczy przewinąć ekran w lewo bądź w prawo. Rysunek 5.1. Typowe okno arkusza danych. Każdy wiersz reprezentuje pojedynczy rekord w tabeli, a każda kolumna jedno pole (np. z opisem lub datą produkcji danego modelu)
Wiele własności opisanych w niniejszym rozdziale ma zastosowanie również do formularzy Accessa. Większość formularzy Accessa w wybranym momencie wyświetla dane z jednego rekordu. Praca z danymi w takim formularzu przypomina pracę z danymi w pojedynczym wierszu arkusza danych.
Arkusze danych można dostosować do potrzeb, co zapewnia wiele różnych sposobów wyświetlania danych. Zmieniając rozmiar czcionki, szerokości kolumn i wysokość wierszy, można sprawić, że więcej danych zmieści się na ekranie. Zmiana kolejności wierszy i (lub) kolumn umożliwia logiczne organizowanie rekordów i pól. Dzięki blokowaniu kolumn pozostają one w tej samej pozycji podczas przewijania do innych części arkusza danych, a ukrywanie kolumn powoduje, że znikają one z ekranu. Filtrowanie danych pozwala na ukrycie rekordów, które nie spełniają żądanych kryteriów. Widok arkusza danych umożliwia wyświetlanie danych z różnych źródeł: tabel, kwerend i formularzy. W zależności od źródła danych niektóre własności arkuszy danych opisane w niniejszym rozdziale mogą działać nieco odmiennie. Dotyczy to zwłaszcza sytuacji, w której źródłem danych jest kwerenda lub formularz. W przypadku tych źródeł danych często się zdarza, że arkusz danych jest dostępny tylko do odczytu.
Rozdział 5. Praca z tabelami
157
Krótkie przypomnienie informacji o rekordach i polach Tabela jest kontenerem umożliwiającym przechowywanie powiązanych ze sobą informacji, np. danych pacjentów, listy kartek do wysłania (z okazji urodzin lub świąt), przypomnień o datach urodzin czy informacji płacowych. Każda tabela ma formalną strukturę. Składa się z pól, z których każde ma unikatową nazwę identyfikującą i opisującą przechowywane informacje oraz zawiera określonego typu dane (tekstowe, liczbowe, daty, godziny itp.). Typ danych decyduje o rodzaju informacji, jakie użytkownik może wprowadzać w danym polu. Kiedy informacje z tabeli są wyświetlane w arkuszu danych (dwuwymiarowym arkuszu z informacjami), Access wyświetla pola w kolumnach. Tabela składa się z rekordów. Każdy rekord zawiera informacje na temat pojedynczego podmiotu (np. określonego klienta lub towaru). Rekord składa się z informacji zapisanych we wszystkich polach w strukturze tabeli. Jeśli na przykład tabela zawiera trzy pola — nazwisko, adres i numer telefonu — to pierwszy rekord zawiera tylko jedno nazwisko, jeden adres i jeden numer telefonu. Drugi rekord także zawiera jedno nazwisko, jeden adres i jeden numer telefonu. Arkusz danych zapewnia idealny sposób przeglądania całej zawartości tabeli. Pojedynczy rekord wyświetla się w arkuszu danych jako jeden wiersz. Każdy wiersz zawiera informacje dotyczące tego rekordu. Pola wyświetlają się w arkuszu danych jako kolumny. Każda kolumna zawiera informacje dotyczące pojedynczego pola. Dzięki takiemu układowi w postaci wierszy i kolumn można przeglądać wiele danych naraz.
Okno arkusza danych Dane w widoku arkusza danych są domyślnie uporządkowane według klucza głównego, a pola występują w takiej kolejności, w jakiej zdefiniowano je w projekcie tabeli. W górnej części okna Accessa wyświetla się pasek tytułu (z nazwą pliku bazy danych), pasek narzędzi szybkiego dostępu i wstążka. W dolnej części okna Accessa znajduje się pasek stanu, który służy do wyświetlania różnych informacji na temat arkusza danych. Na przykład może zawierać opis pola, komunikaty o błędach, ostrzeżenia lub pasek postępu. Zwykle komunikaty o błędach i ostrzeżenia zamiast na pasku stanu pojawiają się w oknach dialogowych wyświetlanych na środku ekranu. Jeżeli funkcja któregoś z przycisków paska narzędzi jest nie całkiem jasna, można wskazać go za pomocą kursora myszy, a po chwili wyświetli się etykietka ekranowa zawierająca krótkie wyjaśnienie. Z prawej strony okna znajduje się pasek przewijania umożliwiający szybkie przemieszczanie się między rekordami. W czasie przesuwania belki wyświetla się etykietka informująca o docelowej pozycji (zobacz rysunek 5.1). Rozmiar belki (niewielkiego prostokąta na pasku przewijania) daje ogólne pojęcie na temat tego, ile wyświetla się rekordów z ogólnej liczby rekordów zapisanych w bazie. Na dole okna arkusza danych znajduje się pasek przewijania służący do poruszania się między polami (w lewo i w prawo), a w lewym dolnym rogu umieszczone są przyciski nawigacyjne (z lewej strony), za pomocą których również można się poruszać między rekordami.
Poruszanie się po arkuszu danych Najprostszym sposobem poruszania się w obrębie okna arkusza danych jest korzystanie z myszy — wystarczy kliknąć komórkę, w której chcemy wpisać lub zmodyfikować dane. Dodatkowo przemieszczanie się między rekordami i polami ułatwiają wstążki, paski przewijania oraz przyciski nawigacyjne. Arkusz danych można sobie wyobrazić jako
158
Część II Tabele Accessa
arkusz kalkulacyjny pozbawiony numerów wierszy i literowych oznaczeń kolumn. Zamiast tego kolumny mają nazwy, natomiast rekordy są unikatowe i umożliwiają w ten sposób zlokalizowanie dowolnej wartości. Klawisze służące do przemieszczania się w obrębie arkusza danych zaprezentowano w tabeli 5.1. Tabela 5.1. Poruszanie się po oknie arkusza danych Kierunek
Kombinacja klawiszy
Następne pole
Tab
Poprzednie pole
Shift+Tab
Pierwsze pole bieżącego rekordu
Home
Ostatnie pole bieżącego rekordu
End
Następny rekord
Strzałka w dół (↓)
Poprzedni rekord
Strzałka w górę (↑)
Pierwsze pole pierwszego rekordu
Ctrl+Home
Ostatnie pole ostatniego rekordu
Ctrl+End
Przewinięcie o jedną stronę w górę
PgUp
Przewinięcie o jedną stronę w dół
PgDn
Korzystanie z przycisków nawigacyjnych Przyciski nawigacyjne (zobacz rysunek 5.2) to sześć formantów umieszczonych w dolnej części okna arkusza danych. Za ich pomocą można poruszać się między rekordami. Dwa formanty położone najbardziej z lewej strony służą do przechodzenia odpowiednio do pierwszego i poprzedniego rekordu w arkuszu. Trzy formanty z prawej powodują przejście do następnego, ostatniego oraz nowego rekordu arkusza danych. Jeśli znamy numer rekordu (numer wiersza określonego rekordu), możemy przejść do niego poprzez kliknięcie pola numeru rekordu, wpisanie numeru rekordu i wciśnięcie klawisza Enter. Rysunek 5.2. Przyciski nawigacyjne arkusza danych
Jeżeli wpiszemy numer rekordu większy od liczby rekordów występujących w tabeli, wyświetli się komunikat z informacją, że przejście do określonego rekordu nie jest możliwe.
Rozdział 5. Praca z tabelami
159
Wstążka arkusza danych Wstążka arkusza danych (zobacz rysunek 5.3) umożliwia pracę z arkuszem danych. Na zakładce NARZĘDZIA GŁÓWNE znajduje się kilka znanych obiektów (jak również kilka nowych). W tym punkcie zamieszczono opis grup znajdujących się na wstążce. Poszczególne polecenia zostały opisane bardziej szczegółowo w dalszej części tego rozdziału.
Rysunek 5.3. Wstążka widoku arkusza danych, zakładka NARZĘDZIA GŁÓWNE Wstążki zostaną omówione w rozdziale 30.
Widoki Grupa Widoki umożliwia przełączanie między widokiem arkusza danych, tabeli przestawnej, wykresu przestawnego i widoku projektu. Wszystkie cztery opcje można zobaczyć po kliknięciu strzałki w dół polecenia Widok. Kliknięcie polecenia Widok projektu pozwala na wprowadzanie zmian w strukturze obiektu (tabeli, kwerendzie itp.). Aby powrócić do widoku arkusza danych, należy kliknąć polecenie Widok arkusza danych. Schowek W grupie Schowek są dostępne polecenia Wytnij, Kopiuj i Wklej. Działają one podobnie jak analogiczne polecenia w innych aplikacjach (Wordzie, Excelu itp.). Kliknięcie strzałki w dół polecenia Wklej daje dostęp do trzech opcji: Wklej, Wklej specjalnie oraz Dołącz i wklej. Polecenie Wklej specjalnie umożliwia wklejanie zawartości schowka w różnych formatach (tekst, CSV, rekordy itp.). Polecenie Dołącz i wklej wkleja zawartość schowka w postaci nowych rekordów — pod warunkiem, że skopiowano wiersz o podobnej strukturze. Sortowanie i filtrowanie Grupa Sortowanie i filtrowanie umożliwia zmianę kolejności wierszy, a także ograniczenie wyświetlanych wierszy na podstawie wybranych kryteriów. Rekordy Polecenia z grupy Rekordy umożliwiają zapisywanie, usuwanie lub dodawanie nowych rekordów do arkusza danych. Są tam również polecenia do wyświetlania podsumowań, sprawdzania pisowni, blokowania i ukrywania kolumn, a także zmiany wysokości wiersza i szerokości komórki.
160
Część II Tabele Accessa
Znajdowanie Grupa Znajdowanie pozwala na wyszukiwanie danych z zastępowaniem oraz przechodzenie do wskazanych rekordów w arkuszu danych. Polecenie Zaznacz umożliwia wybór jednego lub wszystkich rekordów. Okno Grupa Okno zawiera dwa przyciski ułatwiające zarządzaniem obiektami (formularzami, raportami, tabelami itp.), które są otwarte w głównym oknie Accessa:
Dostosuj do rozmiaru formularza — powoduje zmianę rozmiaru formularza w oknie w taki sposób, by odpowiadał rozmiarowi ustawionemu podczas tworzenia formularza. Domyślnie można zmieniać rozmiar formularzy w Accessie. W związku z tym użytkownik może ustawić nowy rozmiar. Przycisk Dostosuj do rozmiaru formularza przywraca rozmiar formularza do stanu określonego podczas projektowania.
Przełącz okna — umożliwia wybranie innego otwartego okna. Formularz lub raport, z którym użytkownik chce pracować, może być przykryty przez inny formularz lub raport. Przycisk Przełącz okna umożliwia szybki wybór obiektu, który ma się znaleźć na wierzchu otwartych dokumentów w głównym oknie Accessa.
Formatowanie tekstu Grupa Formatowanie tekstu umożliwia zmianę wyglądu pól tekstowych w arkuszu danych. Za pomocą poleceń z tej grupy można zmieniać czcionkę, rozmiar, ustawiać pogrubienie, kursywę, kolor itp. Wybranie atrybutu czcionki (np. pogrubiony) powoduje jego zastosowanie do wszystkich pól w arkuszu danych (wyjątek od tej reguły opisano w uwadze zamieszczonej bezpośrednio pod tym akapitem). Polecenia Wyrównaj do lewej, Wyrównaj do prawej i Wyrównaj do środka umożliwiają wyrównywanie danych w wybranej kolumnie. Kliknięcie polecenia Linie siatki pozwala na włączanie i wyłączanie linii siatki. Polecenie Alternatywny kolor wypełnienia/tła służy do zmiany kolorów kolejnych wierszy lub wyboru dla nich jednakowego koloru. Jeśli fokus znajduje się w polu innego typu niż Krótki tekst lub Długi tekst, to wszystkie formanty w grupie Formatowanie tekstu są zablokowane. Formanty z grupy Formatowanie tekstu zachowują się inaczej, jeśli aktualnie zaznaczone pole w arkuszu danych jest typu Długi tekst. Dla pól typu Długi tekst można zmieniać atrybuty czcionki (pogrubienie, podkreślenie, kursywa itp.) dla poszczególnych znaków lub słów w polu, ale jest to możliwe tylko wtedy, gdy właściwość Format tekstu ustawiono na Tekst sformatowany. Właściwość Format tekstu (mająca zastosowanie wyłącznie do pól typu Długi tekst) domyślnie ma wartość Zwykły tekst.
Otwieranie arkusza danych Aby otworzyć arkusz danych z poziomu okna bazy danych, wykonaj poniższe czynności: 1. Jeżeli baza danych Rozdział05.accdb jest otwarta, kliknij przycisk Tabele w okienku nawigacji. 2. Dwukrotnie kliknij nazwę tabeli, którą chcesz otworzyć (w naszym przykładzie tblProducts).
Rozdział 5. Praca z tabelami
161
Innym sposobem otwarcia arkusza danych jest kliknięcie prawym przyciskiem myszy tabeli tblProducts i wybranie polecenia Otwórz z menu podręcznego. Jeżeli znajdujesz się w którymś z okien widoków projektu tabeli, to aby wyświetlić dane w widoku arkusza danych, wystarczy kliknąć przycisk Widok arkusz danych w grupie Widoki na wstążce.
Wpisywanie nowych danych Po otwarciu arkusza danych widoczne są wszystkie rekordy znajdujące się w tabeli. Jeżeli dopiero co utworzono strukturę tabeli, nowy arkusz danych nie będzie zawierał żadnych danych. Na rysunku 5.4 pokazano pusty arkusz danych i fragment zakładki POLA na wstążce. W pustym arkuszu danych pierwszy wiersz zawiera gwiazdkę (*) w selektorze rekordu — oznacza to nowy rekord.
Rysunek 5.4. Pusty arkusz danych. Zwróćmy uwagę, że pierwszy rekord jest pusty i zawiera gwiazdkę w obszarze selektora rekordu
Zakładka NARZĘDZIA TABEL na wstążce zawiera prawie wszystkie narzędzia potrzebne do stworzenia kompletnej tabeli. Za jej pomocą można określić typ danych, domyślne formatowanie, indeksowanie oraz reguły sprawdzania poprawności na poziomie pól i tabeli, a także wykonać inne zadania z zakresu projektowania tabel. Jeśli arkusz danych zawiera już rekordy, nowy rekord wyświetla się w dolnej części arkusza danych. Aby ustawić kursor w wierszu nowego rekordu, należy kliknąć polecenie Nowy w grupie Rekordy na wstążce, kliknąć przycisk nawigacji Nowy (pusty) rekord w dolnej części arkusza danych lub po prostu kliknąć w ostatnim wierszu (zawierającym gwiazdkę). Kiedy użytkownik rozpoczyna wprowadzanie danych, gwiazdka zamienia się
162
Część II Tabele Accessa
w ołówek — oznacza to, że rekord jest poddawany edycji. Wiersz nowego rekordu (zawierający gwiazdkę) wyświetla się poniżej wiersza, w którym użytkownik wprowadza dane. Wskaźnik nowego rekordu zawsze znajduje się w ostatnim wierszu arkusza danych. Dodawanie nowego rekordu do tabeli tblProducts pokazano na rysunku 5.5. Rysunek 5.5. Dopisywanie rekordu do arkusza danych tabeli tblProducts
Aby dodać nowy rekord do tabeli tblProducts otwartej w widoku arkusza danych, wykonaj poniższe czynności: 1. Kliknij przycisk Nowy rekord w grupie Rekordy zakładki NARZĘDZIA GŁÓWNE na wstążce. 2. Wpisz we wszystkich polach tabeli wartości, przemieszczając się między polami za pomocą klawisza Enter lub Tab. W czasie dodawania lub modyfikowania rekordów wskaźnik rekordu może przyjmować jedną z trzech postaci:
Edytowany rekord — ikona w postaci ołówka.
Rekord jest zablokowany (w systemach wieloużytkownikowych) — ikona w postaci kłódki.
Nowy rekord — ikona w postaci ołówka. Jeżeli rekord zawiera pole typu Autonumerowanie, to Access w odpowiadającej mu kolumnie wyświetli tekst (Nowy). Nie można wprowadzać własnych wartości do pól tego typu, należy po prostu nacisnąć klawisz Enter lub Tab, aby przejść do następnej kolumny. Po wprowadzeniu danych Access automatycznie umieści w tym polu odpowiednią liczbę.
Zapisywanie rekordu Przejście do innego rekordu powoduje zapisanie rekordu, który edytowaliśmy. Zapisanie edytowanego rekordu następuje również podczas poruszania się między polami za pomocą klawisza Tab, a także po kliknięciu przycisków nawigacyjnych, kliknięciu Zapisz w grupie Rekordy na wstążce oraz zamknięciu tabeli. Sygnałem, który wskazuje na to, że rekord zapisano, jest zniknięcie symbolu ołówka z obszaru selektora rekordów.
Rozdział 5. Praca z tabelami
163
Aby możliwe było zapisanie rekordu, we wszystkich jego polach muszą się znajdować prawidłowe wartości. Pola są sprawdzane pod względem typu danych, niepowtarzalności (w przypadku zdefiniowania unikatowego indeksu) oraz wszelkich pozostałych reguł sprawdzania poprawności określonych we właściwości Reguła poprawności. Jeśli tabela zawiera klucz główny, który nie jest polem typu Autonumerowanie, w celu uniknięcia wyświetlenia komunikatu o błędzie pokazanego na rysunku 5.6 trzeba sprawdzić, czy wprowadzono niepowtarzalną wartość w polu klucza głównego. Najłatwiejszym sposobem uporania się z tym problemem jest wykorzystanie pola typu Autonumerowanie w roli klucza głównego.
Rysunek 5.6. Komunikat o błędzie Accessa wyświetlany przy próbie zapisania rekordu z powtarzającą się wartością klucza głównego. Aby uniknąć wystąpienia takiego błędu, w roli klucza głównego należy zastosować pole typu Autonumerowanie Przycisk Cofnij na pasku narzędzi szybkiego dostępu powoduje cofnięcie zmian w bieżącym rekordzie oraz w ostatnio zapisanym rekordzie. Po zmodyfikowaniu drugiego rekordu nie można cofnąć zmian w zapisanym rekordzie. Rekord można zapisać na dysku bez opuszczania rekordu, naciskając klawisze Shift+Enter.
Wiesz już, jak należy wprowadzać, modyfikować i zapisywać dane w nowych lub istniejących rekordach. W kolejnym punkcie dowiesz się, w jaki sposób Access sprawdza poprawność danych wprowadzanych w polach.
Automatyczne sprawdzanie poprawności typów danych Access sprawdza automatycznie poprawność pewnych typów danych. Dzięki temu nie trzeba we właściwościach tabeli definiować dla nich żadnych reguł sprawdzania poprawności. Typy danych, których poprawność Access potrafi sprawdzić automatycznie, to między innymi: Liczba/Waluta Data/Godzina Tak/Nie
Access sprawdza poprawność typu danych przy wyjściu z pola. Kiedy wprowadzi się literę w polu typu Liczba lub Waluta, początkowo nie wyświetla się ostrzeżenie informujące o tym, że wprowadzanie tych znaków jest niedozwolone. Jeśli jednak przejdziemy do innego pola za pomocą klawisza Tab lub po prostu klikniemy w innym polu, Access wyświetli ostrzeżenie podobne do pokazanego na rysunku 5.7, umożliwiające wprowadzenie nowej wartości albo zmianę typu danych kolumny na typ tekstowy.
164
Część II Tabele Accessa
Rysunek 5.7. Ostrzeżenie wyświetlane w przypadku, gdy użytkownik wprowadzi dane nieodpowiednie dla typu danych pola. Access oferuje kilka możliwości naprawienia problemu
Komunikat ten wyświetli się, jeśli użytkownik wprowadzi inne niedozwolone znaki (symbole, litery itp.), wprowadzi więcej niż jeden znak kropki dziesiętnej lub wprowadzi zbyt dużą liczbę dla określonego typu liczbowego. Access sprawdza, czy w polach typu Data/Godzina wprowadzono prawidłowe wartości dat lub godzin. Próba wprowadzenia daty 2005-14-45 lub godziny 37:39:12 albo wpisania niedozwolonego znaku w polu Data/Godzina spowoduje wyświetlenie ostrzeżenia podobnego do tego, które pokazano na rysunku 5.7. Pola typu Tak/Nie wymagają wprowadzenia jednej z predefiniowanych wartości:
Tak — Tak, Prawda, Wł, -1 lub liczby różnej od 0 (co odpowiada wartości -1).
Nie — Nie, Fałsz, Wył lub 0.
Oczywiście można zdefiniować własne dozwolone wartości za pomocą właściwości Format pola, ale ogólnie rzecz biorąc, wymienione wartości są jedynymi dozwolonymi. W przypadku wpisania niepoprawnej wartości wyświetli się ostrzeżenie z komunikatem o nieprawidłowej wartości. Domyślna wartość właściwości Typ kontrolki dla pól typu Tak/Nie to Pole wyboru. Aby uniemożliwić użytkownikom wprowadzenie nieprawidłowych danych w polach typu Tak/Nie, należy wyświetlać w nich pola wyboru.
W jaki sposób właściwości wpływają na wprowadzanie danych? Ponieważ dostępne typy danych różnią się między sobą, do każdego z nich stosujemy inne techniki wprowadzania. Z punktu „Zapisywanie rekordu” we wcześniejszej części tego rozdziału dowiedziałeś się, że niektóre testy poprawności danych są wykonywane automatycznie. Podczas projektowania tabeli tblContacts trzeba jednak zdefiniować kilka formatów i reguł sprawdzania poprawności danych. Sposoby wprowadzania danych opisano w poniższych punktach.
Rozdział 5. Praca z tabelami
165
Wprowadzanie standardowych danych tekstowych Pierwsze pole w tabeli tblContacts — ContactID —jest typu Autonumerowanie, natomiast pozostałe pola w tabeli są typu Krótki tekst. Po pominięciu pola ContactID po prostu wpisujemy wartości w poszczególnych polach. Dla pola ZipCode ustawiono maskę wprowadzania (00\-000;0;). Dla pól Phone i Fax także wykorzystano maski wprowadzania (!\(999") "000\-0000;0;). 0 w masce wprowadzania oznacza wymaganą cyfrę, a 9 — cyfrę opcjonalną. W masce wprowadzania kodu pocztowego wymaganych jest pięć cyfr. Do pól tekstowych, o ile nie zdefiniujemy dla nich masek wprowadzania, można wprowadzać dowolne znaki. Aby wprowadzić pole Krótki tekst lub Długi tekst składające się z wielu wierszy, należy wcisnąć klawisz Ctrl+Enter w celu dodania nowego wiersza. Jest to przydatne na przykład w przypadku formatowania długich łańcuchów znaków zawierających adresy składające się z wielu wierszy.
Wprowadzanie danych typu Data/Godzina Pola OrigCustDate i LastSalesDate z tabeli tblContacts są typu Data/Godzina. Dla obydwu zastosowano format Data krótka (16-03-2012). Moglibyśmy jednak zdefiniować format jako Data średnia (16-Mar-12) albo Data długa (16 marca 2012). Skorzystanie z jednego z tych formatów oznacza, że niezależnie od tego, jak wpiszemy datę — podając miesiąc i rok, dzień, miesiąc i rok albo miesiąc, dzień i rok — data zawsze wyświetli się we wskazanym formacie (data krótka [16-03-2012], data średnia [16-Mar-12] lub data długa [16 marca 2012]). Dlatego możemy wpisać datę jako 13/8/4 albo 13 kwi 4, a po opuszczeniu pola Access i tak wyświetli wartość w sposób zgodny ze zdefiniowanym formatem. W rzeczywistości daty są przechowywane w bazie danych bez formatowania. Z tego powodu format wybrany w formularzu nie ma wpływu na sposób przechowywania danych. Format ma wpływ wyłącznie na sposób wyświetlania danych. Nie zmienia sposobu przechowywania danych w tabeli. Ogólnie rzecz biorąc, stosowanie masek wprowadzania dla danych typu Data/Godzina nie jest dobrym pomysłem. Microsoft Access i bez nich dobrze sprawdza poprawność wprowadzanych wartości dat i godzin. Znacznie bardziej prawdopodobne jest to, że maska wprowadzania w formantach zawierających datę doprowadzi do problemów, niż że pomoże ich uniknąć.
Wprowadzanie danych liczbowych i walutowych ze sprawdzaniem poprawności Dla pola CreditLimit w tabeli tblContacts zdefiniowano regułę sprawdzania poprawności. Zdefiniowano dla niego właściwość Reguła poprawności, która ma na celu ograniczenie kwoty kredytu do 250 000 zł. W przypadku naruszenia reguły wyświetla się okno dialogowe z tekstem reguły sprawdzania poprawności określonym dla pola. Aby zezwolić klientowi na wyższą kwotę kredytu niż 250 000 zł, należy zmodyfikować regułę sprawdzania poprawności w projekcie tabeli. Symbol waluty wykorzystywany w Accessie (w tym przypadku symbol zł) jest określony za pomocą opcji regionalnych dostępnych za pośrednictwem apletu Opcje regionalne i językowe w panelu sterowania.
166
Część II Tabele Accessa
Wprowadzanie danych w polach typu Obiekt OLE W arkuszu danych można wprowadzać dane typu Obiekt OLE (ang. Object Linking and Embedding — dosł. łączenie i osadzanie obiektów), chociaż obiektu nie widać w arkuszu. W polach typu Obiekt OLE można zapisywać różne rodzaje informacji, m.in.:
zdjęcia w postaci map bitowych,
pliki dźwiękowe,
wykresy biznesowe,
pliki Worda lub Excela.
W polach typu Obiekt OLE w Accessie można zapisywać dowolne obiekty obsługiwane przez serwery OLE. Obiekty OLE zazwyczaj są wprowadzane w formularzach. Dzięki temu można zobaczyć bądź usłyszeć wartość lub z niej skorzystać. W widoku arkuszy danych obiekty OLE są widoczne w postaci napisów informujących o tym, z jakim obiektem mamy do czynienia (w polu typu Obiekt OLE może się wyświetlać np. tekst Bitmap Image). Obiekt OLE można wprowadzić w polu arkusza danych dwoma sposobami:
przez wklejenie go ze schowka,
przez kliknięcie pola typu Obiekt OLE prawym przyciskiem myszy i wybranie polecenia Wstaw obiekt z rozwijanego menu.
Wprowadzanie danych w polu typu Długi tekst Przedostatnim polem w omawianej tabeli jest pole Notes typu Długi tekst. Typ ten dopuszcza wpisanie do jednego gigabajta tekstu w każdym polu. W trakcie wpisywania tekstu w polu typu Długi tekst widać tylko kilka znaków — reszta nie mieści się w polu. Naciskając klawisze Shift+F2, można wyświetlić okno Powiększenie, które zaopatrzone jest w pasek przewijania (zobacz rysunek 5.8) i umożliwia wyświetlenie większej liczby znaków. Aby wyświetlić cały tekst z zastosowaniem innego kroju lub rozmiaru czcionki, można użyć przycisku Czcionka… dostępnego w dolnej części okna (na rysunku 5.8 znacznie powiększono czcionkę okna Powiększenie w porównaniu z domyślnym rozmiarem 8 punktów). Rysunek 5.8. Okno Powiększenie. Zwróćmy uwagę, że pozwala ono wyświetlić dużo więcej danych — co prawda nie cały możliwy do wpisania tekst, ale stosunkowo długi fragment
Przy pierwszym wywołaniu okna powiększenia cały tekst jest zaznaczony. Aby anulować zaznaczenie tekstu, można kliknąć w dowolnym miejscu okna. Jeśli użytkownik przypadkowo usunie cały tekst lub zmieni coś, czego nie chciał zmieniać, może kliknąć przycisk Anuluj i powrócić do arkusza danych, gdzie dane są zapisane w pierwotnej postaci.
Rozdział 5. Praca z tabelami
167
Z okna Powiększenie (Shift+F2) można korzystać podczas projektowania obiektów Accessa (tabel, formularzy, raportów, kwerend), aby zobaczyć tekst, który nie mieści się na ekranie.
Poruszanie się między rekordami w arkuszu danych Sytuacje, w których konieczne jest dokonanie modyfikacji w istniejących rekordach, nie należą wcale do rzadkości. Oto kilka powodów wystąpienia takich sytuacji: uzyskano nowe informacje, które wymuszają zmianę istniejących wartości, lub wykryto błędy, które wymuszają zmianę istniejących wartości. Kiedy użytkownik zdecyduje się na wprowadzenie modyfikacji danych w tabeli, pierwszym krokiem jest jej otwarcie — oczywiście jeżeli jeszcze nie jest otwarta. Korzystając z listy tabel w okienku nawigacji, otwórz tabelę tblProducts dwukrotnym kliknięciem jej nazwy widocznej na liście. Jeśli tabela wyświetla się w widoku projektu, należy kliknąć przycisk Widok arkusza danych, by przełączyć się do widoku arkusza danych. Jeżeli otworzymy w Accessie arkusz danych dla tabeli, która ma tabele powiązane ze sobą, na początku tabeli wyświetli się kolumna ze znakiem plus (+) umożliwiająca dostęp do powiązanych rekordów lub podarkuszy danych. Kliknięcie znaku plus w wierszu powoduje wyświetlenie podarkusza danych związanego z tym wierszem.
Poruszanie się między rekordami Do dowolnego rekordu możemy się dostać, przewijając ekran aż do jego odnalezienia, a następnie umieszczając w nim kursor. Jednak jeżeli tabela jest bardzo duża, przewijanie wszystkich rekordów może zająć dużo czasu, potrzebne są zatem inne metody szybkiego dotarcia do żądanych rekordów. Do przemieszczania się między rekordami można używać pionowego paska przewijania. Kliknięcie któregoś z przycisków strzałek należących do paska przewijania powoduje przesunięcie tylko o jeden rekord. Aby przesunąć się o wiele rekordów, trzeba przeciągnąć belkę przewijania lub kliknąć obszar między belką a przyciskiem strzałki. Obserwuj etykietki ekranowe wyświetlające się w trakcie przemieszczania się w inny obszar arkusza danych za pomocą pasków przewijania. Access nie uaktualnia pola numeru rekordu aż do chwili kliknięcia danego pola.
Do przemieszczania się między rekordami można również wykorzystać pięć przycisków nawigacyjnych (zobacz rysunek 5.2). Aby przejść do żądanego rekordu, należy kliknąć jeden z tych przycisków. Jeżeli znamy numer rekordu (numer wiersza zawierającego określony rekord), możemy kliknąć pole numeru rekordu, wpisać go tam, po czym nacisnąć klawisz Enter. Można też skorzystać z polecenia Przejdź do w grupie Znajdowanie na wstążce, aby przejść do pierwszego, poprzedniego, następnego, ostatniego lub nowego rekordu.
168
Część II Tabele Accessa
Wyszukiwanie określonej wartości Chociaż można szybko przejść do określonego rekordu (jeżeli zna się jego numer) lub do określonego pola bieżącego rekordu, to zazwyczaj chodzi o to, aby odnaleźć rekord zawierający określoną wartość. Można skorzystać z następujących metod zlokalizowania określonej wartości w polu:
Wybierz polecenie Znajdź (ikona lornetki) z grupy Znajdowanie na wstążce.
Naciśnij klawisze Ctrl+F.
Użyj pola Wyszukaj w dolnej części okna arkusza danych.
Wykonanie dwóch pierwszych operacji spowoduje wyświetlenie okna dialogowego Znajdowanie i zamienianie przedstawionego na rysunku 5.9. Aby ograniczyć wyszukiwanie tylko do określonego pola, przed otwarciem okna dialogowego należy umieścić kursor w wybranym polu. Wyszukiwanie danego wpisu można także rozszerzyć na całą tabelę, wybierając wartość Bieżący dokument z pola kombi Szukaj w. Rysunek 5.9. Okno dialogowe Znajdowanie i zamienianie. Najszybsza metoda jego wyświetlenia to naciśnięcie kombinacji klawiszy Ctrl+F
Jeżeli zaznaczysz cały rekord, klikając jego selektor (mały szary prostokąt obok rekordu), to Access automatycznie będzie przeszukiwał wszystkie pola.
Okno dialogowe Znajdowanie i zamienianie umożliwia określenie wielu parametrów wyszukiwania. W polu kombi Znajdź wpisuje się wartość, która ma zostać wyszukana. Można też wyświetlić listę wcześniej wyszukiwanych w danej bazie danych elementów i wybrać jeden z nich. Wartość można wpisać bezpośrednio w takiej formie, w jakiej występuje w bazie, lub skorzystać z trzech rodzajów znaków wieloznacznych. Symbole wieloznaczne obsługiwane w oknie dialogowym Znajdź przedstawiono w tabeli 5.2. Można połączyć symbole wieloznaczne, aby precyzyjniej określić kryteria wyszukiwania. Na przykład wzorzec 196[!2-8] pasuje do wartości 1961 i 1969, natomiast nie pasuje do żadnej wartości pomiędzy nimi. Rozwijana lista Uwzględnij zawiera trzy elementy, które eliminują potrzebę stosowania symboli wieloznacznych:
Dowolna część pola — w przypadku wybrania tej opcji Access wyszukuje wartości w dowolnej części pola. Operacja wyszuka słowa „Ford” w dowolnym miejscu pola, dlatego zostaną znalezione takie wartości, jak Ford Mustang, 2008 Ford F-150 oraz Ford Galaxy 500.
Rozdział 5. Praca z tabelami
169
Tabela 5.2. Symbole wieloznaczne Znak
Opis
Przykład
* (gwiazdka)
Odpowiada dowolnej liczbie znaków
Ford* pozwala znaleźć wartość Ford Mustang
? (znak zapytania)
Odpowiada jednemu znakowi
F?rd pozwala znaleźć wartość Ford
[] (nawiasy
Odpowiada jednemu znakowi z podanej listy
19[67]1 pozwala znaleźć wartości 1961 i 1971
! (wykrzyknik)
W nawiasach klamrowych pozwala wykluczyć określone znaki
19[!67]1 pozwala znaleźć wartość 1951, ale nie pasuje do 1961
- (myślnik)
W nawiasach klamrowych pozwala określić przedział znaków
196[2-8] pozwala znaleźć wartości od 1962 do 1968
# (kratka)
Odpowiada jednej cyfrze
1:## pasuje do wartości 1:18, ale już nie do 1:9
kwadratowe)
Całe pole — domyślną wartością jest Całe pole. Ta opcja powoduje, że wyszukiwane są tylko wartości całkowicie odpowiadające wpisanym. Na przykład jeżeli wybrano opcję Całe pole, a wyszukiwana jest wartość Ford, to Access odnajdzie tylko pole, którego całą wartość stanowi wpis Ford.
Początek pola — wyszukiwanie wartości Ford z opcją Początek pola wyszukuje słowa na początku pola. W efekcie zwraca wszystkie wiersze, w których słowo „Ford” stanowi pierwsze cztery znaki pola.
Oprócz opisanych pól kombi można także użyć dwóch pól wyboru znajdujących się na dole okna Znajdowanie i zamienianie:
Uwzględnij wielkość liter — określa, czy w trakcie wyszukiwania mają być rozróżniane małe i duże litery. Domyślnie pole nie jest zaznaczone (małe i duże litery nie są rozróżniane). Wtedy wyszukanie wartości NOWAK zwróci zarówno NOWAK, jak i Nowak W przypadku zaznaczenia tego pola wyboru trzeba wpisać wyszukiwaną wartość literami dokładnie takiej wielkości, jaka występuje w polach (typy danych Liczba, Waluta oraz Data/Godzina nie mają żadnych atrybutów związanych z wielkością liter). Jeżeli zaznaczono pole wyboru Uwzględnij wielkość liter, Access nie będzie brał pod uwagę stanu pola Przeszukaj pola z uwzględnieniem formatowania (jest to drugie pole wyboru), które ogranicza wyszukiwanie jedynie do wartości wyświetlanych w tabeli (owo pole wyboru należy zaznaczyć, jeżeli zdefiniowano dla pól formaty wyświetlania w arkuszu danych).
Przeszukaj pola z uwzględnieniem formatowania — pole to jest domyślnie zaznaczone, co powoduje, że wyszukiwane są tylko ciągi znaków, które mają ten sam wzorzec znaków co wpis w polu Znajdź. Aby wyszukiwać wpisy niezależnie od formatowania, należy anulować zaznaczenie tego pola wyboru. Na przykład jeśli wyszukujemy w polu Cost wartości 16 500 PLN, to jeśli zaznaczono pole wyboru Przeszukaj pola z uwzględnieniem formatowania, w polu Znajdź trzeba wpisać spację. Aby wyszukiwać wartość niesformatowaną (16500), należy anulować zaznaczenie tego pola wyboru.
170
Część II Tabele Accessa
Zaznaczenie pola wyboru Przeszukaj pola z uwzględnieniem formatowania może spowolnić proces wyszukiwania.
Wyszukiwanie rozpoczyna się po kliknięciu przycisku Znajdź następny. Jeżeli Access znajdzie odpowiednią wartość w arkuszu danych, zaznaczy ją i ustawi na niej kursor. Aby znaleźć kolejne wystąpienie wartości, należy ponownie kliknąć przycisk Znajdź następny. Okno dialogowe pozostanie otwarte, co umożliwia wyszukanie wielu wystąpień danej wartości. Aby zmienić kierunek wyszukiwania, należy wybrać jedną z trzech opcji kierunku (W górę, W dół, Wszystkie) w polu Wyszukaj. Po znalezieniu szukanej wartości można zamknąć okno dialogowe, klikając przycisk Zamknij. Aby szybko znaleźć pierwsze wystąpienie określonej wartości, można skorzystać z pola Wyszukaj wyświetlającego się w dolnej części okna arkusza danych (zobacz rysunek 5.1). W przypadku skorzystania z pola Wyszukaj Access wyszukuje wartości w całym arkuszu danych, w dowolnej części pola. Gdy wpisujemy słowo „FORD” w polu Wyszukaj, arkusz danych przemieszcza aktywną komórkę w miarę wpisywania kolejnych liter. Najpierw znajduje literę F, następnie FO itd. Po znalezieniu wartości operacja wyszukiwania zatrzymuje się. W celu znalezienia kolejnych wystąpień należy wcisnąć klawisz Enter.
Modyfikowanie wartości w arkuszu danych Jeżeli pole, w którym aktualnie znajduje się kursor, jest puste, można wpisać w nim nową wartość. W czasie wprowadzania do pól nowych wartości obowiązują te same reguły co przy dodawaniu nowego rekordu.
Ręczne zamienianie istniejących wartości Po wejściu do danego pola albo zostaje zaznaczona cała jego zawartość, albo nie zostaje zaznaczony żaden znak. Ogólna reguła jest taka, że jeśli do wejścia do pola użyto klawiatury (klawisza Tab lub klawiszy ze strzałkami), to wszystkie znaki są w nim zaznaczone (zaznaczony tekst wyświetla się w trybie kolorów odwrotnych). Kiedy użytkownik zacznie wpisywać tekst z klawiatury, zaznaczona zawartość jest automatycznie zastępowana nową. W przypadku kliknięcia w polu występująca w nim wartość nie jest zaznaczona. Aby zaznaczyć całą zawartość pola za pomocą myszy, można użyć jednej z poniższych metod:
Kliknij miejsce po lewej stronie wartości (tam, gdzie kursor przyjmuje postać dużego znaku plus).
Kliknij miejsce z lewej strony wartości, przytrzymaj wciśnięty lewy przycisk myszy, a następnie przeciągnij kursor nad całą wartością, aż zostanie zaznaczona.
Kliknij pole, a następnie naciśnij klawisz F2. Wartość wpisaną w polu można zastąpić wartością domyślną zdefiniowaną we właściwości Wartość domyślna pola. Aby to zrobić, należy zaznaczyć wartość, a następnie nacisnąć kombinację klawiszy Ctrl+Alt+Spacja. Aby zastąpić istniejącą wartość wartością występującą w poprzednim rekordzie, należy nacisnąć kombinację klawiszy Ctrl+’ (apostrof). Naciśnięcie klawiszy Ctrl+; (średnik) powoduje wstawienie do pola bieżącej daty.
Rozdział 5. Praca z tabelami
171
Naciśnięcie klawiszy Ctrl+– (minus) powoduje usunięcie całego bieżącego rekordu.
Modyfikacja istniejącej wartości Aby zmodyfikować wartość w polu, a nie całkowicie zastąpić ją inną, można za pomocą myszy ustawić kursor przed dowolnym znakiem występującym w polu, co spowoduje uaktywnienie trybu wstawiania. W miarę wpisywania kolejnych znaków istniejące będą przesuwane w prawo. Naciśnięcie klawisza Insert powoduje włączenie trybu zastępowania — każdy wpisany znak zastąpi jeden istniejący. Wśród istniejących znaków można przemieszczać kursor za pomocą klawiszy strzałek — nie powoduje to ich zmiany. Znaki z lewej strony kursora można usuwać za pomocą klawisza Backspace, natomiast z prawej klawiszem Delete. Dostępne techniki edycji przedstawiono w tabeli 5.3. Tabela 5.3. Techniki edycji Operacja edycji Umieszczenie kursora w polu Wstawienie wartości do pola Zaznaczenie całego pola Zastąpienie istniejącej wartości nową Przeniesienie punktu wstawiania na początek pola Przeniesienie punktu wstawiania na koniec pola
Klawisze Naciśnij klawisz strzałki w prawo (→) lub w lewo (←) Umieść kursor w polu i wpisz nową wartość Naciśnij klawisz F2 Zaznacz całe pole i wpisz nową wartość Naciśnij klawisze Ctrl+← (strzałka w lewo) lub wciśnij klawisz Home Naciśnij klawisze Ctrl+→ (strzałka w prawo) lub wciśnij klawisz End Naciśnij klawisze Shift+← (strzałka w lewo) Naciśnij klawisze Shift+→ (strzałka w prawo) Naciśnij klawisze Ctrl+Shift+← (strzałka w lewo) Naciśnij klawisze Ctrl+Shift+→ (strzałka w prawo) Zaznacz całą zawartość pola i wpisz nową wartość
Zaznaczenie poprzedniego znaku Zaznaczenie następnego znaku Zaznaczenie od punktu wstawiania do początku Zaznaczenie od punktu wstawiania do końca Zastąpienie istniejącej wartości nową Zastąpienie bieżącej wartości wartością Naciśnij klawisze Ctrl+’ (apostrof) poprzedniego pola Zastąpienie bieżącej wartości wartością domyślną pola Naciśnij klawisze Ctrl+Alt+Spacja Wstawienie znaku podziału wiersza w polu typu Naciśnij klawisze Ctrl+Enter Krótki tekst lub Długi tekst Naciśnij klawisze Shift+Enter lub przejdź do innego Zapisanie bieżącego rekordu rekordu Wstawienie bieżącej daty Naciśnij klawisze Ctrl+; (średnik) Wstawienie bieżącego czasu Naciśnij klawisze Ctrl+: (dwukropek) Dodanie nowego rekordu Naciśnij klawisze Ctrl++ (znak plus) Usunięcie bieżącego rekordu Naciśnij klawisze Ctrl+– (znak minus) Zmiana wartości pola wyboru lub przycisku opcji Naciśnij klawisz Spacja Cofnięcie modyfikacji bieżącego pola Naciśnij klawisz Esc lub kliknij przycisk Cofnij Naciśnij klawisz Esc lub kliknij przycisk Cofnij Cofnięcie modyfikacji bieżącego rekordu po raz drugi, po cofnięciu zmian w bieżącym polu
172
Część II Tabele Accessa
Pola, których nie można edytować Zawartości niektórych pól nie można edytować. Wśród nich wyróżnić można:
Pola typu Autonumerowanie — Access obsługuje pola typu Autonumerowanie automatycznie. Wylicza ich wartość każdorazowo w momencie tworzenia nowego rekordu. Mogą one pełnić funkcję klucza głównego.
Pola obliczeniowe — w formularzach i kwerendach mogą występować pola, których wartość jest wynikiem wyrażenia. Wartości tych pól nie są w rzeczywistości przechowywane w tabelach i nie można ich edytować.
Pola w rekordach zablokowanych przez innych użytkowników — jeżeli inny użytkownik zablokuje rekord, nie można edytować żadnego z jego pól.
Używanie funkcji Cofnij Przycisk Cofnij na pasku narzędzi szybkiego dostępu często jest nieaktywny i nie można go używać (ponieważ nie ma operacji, które można by cofnąć). Jednak podczas edycji rekordu można za pomocą tego przycisku wycofać zmiany dokonane w bieżącym polu. Ten sam efekt osiągniemy poprzez naciśnięcie klawisza Esc — spowoduje to anulowanie wprowadzonej właśnie modyfikacji lub poprzednio zmienionego pola. Dwukrotne naciśnięcie klawisza Esc spowoduje anulowanie wszystkich modyfikacji dokonanych w całym rekordzie. Po wpisaniu wartości w polu można wycofać zmianę tej wartości poprzez kliknięcie przycisku Cofnij. Kliknięcie tego przycisku umożliwia również anulowanie zmiany dokonanej w poprzednim polu po przejściu do innego pola. Za pomocą tej opcji wycofamy też wszystkie zmiany dokonane w bieżącym rekordzie przed jego zapisaniem. Po zapisaniu rekordu także jest jeszcze możliwe anulowanie zmian. Jednak po rozpoczęciu edycji kolejnego rekordu zmiany dokonane w poprzednim stają się trwałe. Nie należy liczyć na to, że polecenie Cofnij umożliwi anulowanie zmian po wprowadzeniu ich w wielu rekordach. Podczas pracy w widoku arkusza danych zmiany są zapisywane przy przejściu z rekordu do rekordu. Zmiany można cofnąć tylko dla jednego rekordu.
Kopiowanie i wklejanie wartości Kopiowanie lub wycinanie danych i umieszczanie ich w schowku należy do zadań pakietu Microsoft Office lub systemu Windows (w zależności od typu danych); nie jest to funkcja Accessa. Po wycięciu czy skopiowaniu wartości można ją wkleić w innym polu lub rekordzie, wybierając polecenie Wklej z grupy Schowek na wstążce. Dane można wycinać, kopiować i wklejać z dowolnej aplikacji systemu Windows lub między różnymi zadaniami w Accessie. Dzięki tej technice możliwe jest skopiowanie całych rekordów między tabelami czy bazami danych, a także skopiowanie wartości z arkusza danych do Worda lub Excela.
Rozdział 5. Praca z tabelami
173
Kliknięcie strzałki w dół polecenia Wklej daje dostęp do trzech opcji:
Wklej — wkleja zawartość schowka do jednego pola.
Wklej specjalnie — umożliwia wklejanie zawartości schowka w różnych formatach (tekst, CSV, rekordy itp.).
Dołącz i wklej — wkleja zawartość schowka w postaci nowych rekordów, pod warunkiem że skopiowano wiersz o podobnej strukturze. Aby wyciąć lub skopiować jeden lub więcej rekordów do schowka, należy zaznaczyć rekord lub grupę rekordów, używając selektorów. Następnie, w celu wprowadzenia ich do tabeli o podobnej strukturze, należy skorzystać z polecenia Dołącz i wklej.
Zastępowanie wartości Aby zastąpić istniejącą w polu wartość, można zlokalizować ręcznie rekord i dokonać w nim zmiany lub wykorzystać okno dialogowe Znajdowanie i zamienianie. Okno to można wyświetlić na kilka sposobów:
Wybierz polecenie Zamień w grupie Znajdowanie na wstążce.
Naciśnij klawisze Ctrl+H.
Wspomniane okno dialogowe umożliwia zamianę wartości w bieżącym polu lub w całym arkuszu danych. Za jego pomocą można znaleźć określoną wartość i zamienić ją na nową w każdym miejscu pola lub tabeli. Po wyświetleniu okna Znajdowanie i zamienianie najpierw należy kliknąć zakładkę Zamień, a następnie wpisać w polu Znajdź wartość, którą chcemy odnaleźć. Po ustaleniu wszystkich pozostałych opcji wyszukiwania (np. anulowaniu zaznaczenia pola wyboru Przeszukaj pola z uwzględnieniem formatowania) można kliknąć przycisk Znajdź następny. Spowoduje to znalezienie pierwszego wystąpienia szukanej wartości. Aby zamienić odnaleziony wpis (wskazywany przez kursor) na określony, należy wpisać wartość w polu Zamień na i kliknąć przycisk Zamień. Na przykład rysunek 5.10 przedstawia sposób wyszukania w polu kategorii tabeli tblProducts wartości Mini Vany i zamiany jej na Minivany. Rysunek 5.10. Okno dialogowe Znajdowanie i zamienianie otwarte na zakładce Zamień. Przedstawiony przykład umożliwia zamianę wartości Mini Vany na Minivany
Można najpierw określić opcje wyszukiwania na zakładce Znajdź, a następnie kliknąć zakładkę Zamień i kontynuować proces zamiany. Jednak dużo łatwiej jest od razu posługiwać się zakładką Zamień. Należy wpisać wartość, którą chcemy odnaleźć, oraz wartość,
174
Część II Tabele Accessa
którą ją chcemy zastąpić. Po wypełnieniu okna dialogowego wybranymi informacjami należy kliknąć jeden z przycisków znajdujących się z boku okna:
Znajdź następny — wyszukuje następne pole zawierające wartość wpisaną w polu Znajdź.
Anuluj — zamyka okno bez wykonania operacji wyszukiwania i zamiany.
Zamień — zamienia wartość tylko w bieżącym polu (uwaga: przedtem trzeba użyć przycisku Znajdź następny).
Zamień wszystkie — znajduje wszystkie pola zawierające wartość wpisaną w polu Znajdź i automatycznie zastępuje je nową wartością. Z opcji tej należy skorzystać tylko wtedy, gdy mamy pewność, że chcemy zamienić wszystkie wartości. Należy dokładnie sprawdzić wartość w polu Wyszukaj, aby mieć pewność, że nie dokonamy niepożądanej zamiany danych w całym arkuszu.
Dodawanie nowych rekordów Istnieje kilka sposobów dodawania rekordów w arkuszu danych:
Kliknij w ostatnim wierszu okna arkusza danych — tam, gdzie wskaźnik rekordu ma postać gwiazdki.
Kliknij przycisk nawigacyjny Nowy (pusty) rekord (pierwszy od prawej).
Kliknij polecenie Nowy z grupy Rekordy na wstążce.
Kliknij polecenie Przejdź do/Nowy z grupy Znajdowanie na wstążce.
Przejdź do ostatniego rekordu i wciśnij strzałkę w dół (↓).
Wciśnij kombinację klawiszy Ctrl++.
Kliknij prawym przyciskiem myszy selektor dowolnego rekordu i z menu podręcznego wybierz opcję Nowy rekord. Niezależnie od wybranego rekordu nowy pojawi się na dole arkusza.
Po przejściu do nowego rekordu należy wprowadzić dane w odpowiednich polach, a następnie zapisać rekord.
Usuwanie rekordów Aby usunąć rekordy, należy zaznaczyć rekord lub grupę rekordów za pomocą selektorów. Następnie należy wcisnąć klawisz Delete lub kliknąć polecenie Usuń z grupy Rekordy na wstążce (lub z menu otwieranego prawym przyciskiem myszy). Rozwijane menu Usuń zawiera polecenie Usuń rekord, które powoduje usunięcie bieżącego rekordu nawet wtedy, gdy go nie zaznaczono. Po naciśnięciu klawisza Delete lub wybraniu odpowiedniego polecenia na wstążce wyświetli się okno dialogowe z pytaniem o potwierdzenie usunięcia (zobacz rysunek 5.11). Kliknięcie przycisku Tak spowoduje usunięcie rekordów. Jeśli użytkownik kliknie Anuluj, żadne zmiany nie zostaną wprowadzone.
Rozdział 5. Praca z tabelami
175
Rysunek 5.11. Okno dialogowe usuwania rekordów ostrzega, że zostanie usunięta określona liczba rekordów — domyślnym wyborem jest Tak (zgoda na usunięcie rekordów), należy zatem zachować ostrożność Domyślnym wyborem dla tego okna dialogowego jest Tak. Naciśnięcie klawisza Enter automatycznie spowoduje usunięcie rekordów. Jeżeli użytkownik przypadkowo usunie w ten sposób rekordy, ich przywrócenie nie będzie możliwe. Jeżeli pomiędzy tabelami istnieją ustalone relacje z zaznaczoną opcją Wymuszaj więzy integralności (np. tabela tlbContacts jest powiązana z tabelą tblSales), nie można usunąć rekordu nadrzędnego relacji (tlbContacts), z którym są związane rekordy potomne (tblSales), o ile nie zostanie zaznaczona opcja Kaskadowo usuń rekordy pokrewne. W przeciwnym przypadku wyświetli się okno dialogowe z komunikatem o tym, że rekord nie może zostać zmieniony ani usunięty, ponieważ tabela '' zawiera rekordy z nim powiązane.
Aby zaznaczyć kilka sąsiadujących ze sobą rekordów, należy kliknąć selektor pierwszego z wybranych rekordów, a następnie przeciągnąć wskaźnik rekordu na ostatni z nich. Można też kliknąć pierwszy rekord, a następnie wcisnąć klawisz Shift i kliknąć ostatni z grupy rekordów, które mają być zaznaczone. W celu zaznaczenia kilku sąsiadujących ze sobą rekordów za pomocą klawiatury, wciśnij kombinację Shift+Spacja, aby zaznaczyć bieżący rekord, a następnie wybierz kombinację Shift+↓ (strzałka w dół) lub Shift+↑ (strzałka w górę), by objąć zaznaczeniem przyległe rekordy.
Wyświetlanie rekordów Istnieją techniki umożliwiające zwiększenie wydajności użytkownika podczas dodawania lub modyfikowania rekordów. Można zmieniać kolejność pól, ukrywać i blokować kolumny, zmieniać wysokość wierszy i szerokość kolumn, zmieniać czcionkę wyświetlania napisów oraz usuwać lub modyfikować sposób wyświetlania linii siatki.
Zmiana kolejności pól Access domyślnie wyświetla kolumny w arkuszu danych w takiej kolejności, w jakiej są zdefiniowane w strukturze tabeli. Czasami w celu umożliwienia lepszej analizy danych może wystąpić potrzeba wyświetlenia wybranych kolumn obok siebie. Aby zmienić kolejność wyświetlania kolumn, należy zaznaczyć wybraną z nich poprzez kliknięcie jej nagłówka i przeciągnąć ją w nowe miejsce (zobacz rysunek 6.12). Jednocześnie można zaznaczyć i przesunąć jedną lub więcej kolumn. Przypuśćmy, że chcesz umieścić pole QtyInStock przed polem Description w arkuszu danych tabeli tblProducts. Aby to osiągnąć, wykonaj następujące czynności: 1. Ustaw kursor myszy na nazwie pola QtyInStock. Kursor zamieni się w strzałkę skierowaną w dół.
176
Część II Tabele Accessa
Rysunek 5.12. Zaznaczenie i przeciągnięcie kolumny w celu zmiany kolejności wyświetlania pól
2. Kliknij, aby zaznaczyć kolumnę. Cała kolumna QtyInStock jest teraz zaznaczona. 3. Zwolnij przycisk myszy. 4. Kliknij ponownie nagłówek kolumny. Kursor powinien przyjąć postać strzałki połączonej z prostokątem. 5. Przeciągnij kolumnę w lewo pomiędzy pole Description a pole Features. Między tymi polami pojawi się cienka, czarna kolumna (zobacz rysunek 5.12). 6. Zwolnij przycisk myszy. Kolumna zostanie przeniesiona przed pole Description arkusza danych. Ta metoda umożliwia przenoszenie pojedynczych kolumn lub kilku kolumn znajdujących się obok siebie. Aby zaznaczyć kilka pól, należy kliknąć kolumnę i przy wciśniętym przycisku myszy przeciągnąć kursor nad kilkoma kolumnami. Po zaznaczeniu można przesuwać pola w prawo i w lewo w granicach okna. Przesuwanie pól w widoku arkusza danych nie wpływa na ich kolejność w strukturze tabeli.
Zmiana szerokości wyświetlanych pól Szerokość wyświetlanych pól można zmieniać albo definiując ją w oknie dialogowym (jako liczbę znaków), albo przeciągając linie oddzielające kolumny. W trakcie przeciągania krawędzi kolumny kursor przyjmuje postać dwukierunkowej strzałki. Aby poszerzyć lub zwęzić kolumnę, wykonaj następujące czynności: 1. Umieść kursor myszy pomiędzy dwiema nazwami kolumn na linii oddzielającej pola. Kiedy kursor znajdzie się we właściwym miejscu, powinien się zamienić w poziomą dwukierunkową strzałkę.
Rozdział 5. Praca z tabelami
177
2. Przeciągnij linię rozdzielającą kolumny w lewo (aby zwęzić) lub w prawo (aby poszerzyć) kolumnę. Szerokość kolumny można błyskawicznie optymalnie dopasować (do najdłuższej wartości występującej w polu), klikając dwukrotnie prawą jej krawędź w chwili, kiedy kursor ma kształt dwukierunkowej strzałki. Zmiana szerokości kolumn nie wpływa na liczbę znaków dopuszczalnych w polach tabeli. Jest to po prostu określenie ilości miejsca przeznaczonej do wyświetlania danych z kolumny.
Innym sposobem zmiany szerokości pola jest kliknięcie kolumny prawym przyciskiem myszy i wybranie opcji Szerokość kolumny z menu podręcznego. Spowoduje to wyświetlenie okna dialogowego Szerokość kolumny (zobacz rysunek 5.13). W polu Szerokość kolumny należy wpisać liczbę znaków, które mają się zmieścić w kolumnie, lub zaznaczyć pole wyboru Szerokość standardowa, aby ustawić szerokość kolumny na rozmiar domyślny. Aby dopasować szerokość kolumny do najszerszej widocznej wartości, należy kliknąć przycisk Dopasuj optymalnie. Rysunek 5.13. Okno dialogowe Szerokość kolumny
Przesuwając prawą krawędź kolumny na lewą, można ukryć kolumnę. Ten sam efekt można osiągnąć poprzez ustawienie w oknie dialogowym szerokości kolumny na 0. Aby ponownie wyświetlić ukryte w ten sposób kolumny, trzeba wybrać polecenie Więcej/Odkryj kolumny w grupie Rekordy na wstążce.
Zmiana wysokości wyświetlanych rekordów Czasami trzeba zwiększyć wysokość wiersza w celu umożliwienia wyświetlenia tekstu czcionką o większym rozmiarze lub wyświetlenia tekstu w wielu wierszach. Wysokość rekordu (czyli wiersza) można zmienić, przeciągając linie oddzielające rekordy lub wybierając polecenie Więcej/Wysokość wiersza z grupy Rekordy na wstążce. W czasie przeciągania linii oddzielającej rekordy kursor przyjmuje postać pionowej dwukierunkowej strzałki — widać ją z lewej strony rysunku 5.14. Aby zmniejszyć lub zwiększyć wysokość wiersza, wykonaj poniższe czynności: 1. Umieść kursor myszy pomiędzy selektorami rekordów dwóch wierszy. Kursor przyjmie postać dwukierunkowej pionowej strzałki. 2. Przeciągnij krawędź rekordu w górę (zmniejszanie) lub w dół (zwiększanie), aby zmienić naraz wysokość wszystkich wierszy.
178
Część II Tabele Accessa
Rysunek 5.14. Zmiana wysokości wiersza. Wystarczy umieścić kursor myszy tak jak pokazano i przeciągnąć linię aż do osiągnięcia żądanej wysokości
Operacja zmiany wysokości wiersza wpływa na wysokość wszystkich wierszy arkusza danych. W arkuszu danych nie mogą się znajdować wiersze o różnej wysokości.
Rozmiar wierszy można także zmieniać za pomocą polecenia Więcej/Wysokość wiersza z grupy Rekordy na wstążce. Spowoduje to wyświetlenie okna dialogowego Wysokość wiersza, gdzie można podać rozmiar wiersza w punktach. Aby przywrócić domyślny rozmiar wierszy, należy zaznaczyć pole wyboru Wysokość standardowa. Jeżeli przeciągnie się linię oddzielającą rekordy tak, że będzie nachodziła na linię sąsiednią, wszystkie rekordy zostaną ukryte. To samo się zdarzy, jeżeli jako wysokość wiersza w oknie dialogowym wpiszemy liczbę bliską zera (np. 0,1). Aby wyświetlić z powrotem rekordy, należy użyć okna dialogowego Wysokość wiersza i ustawić większą wartość wysokości wiersza.
Zmiana czcionki Domyślnie Access wyświetla wszystkie dane w arkuszu danych, używając czcionki Calibri o rozmiarze 11. Aby zmienić wygląd tekstu na arkuszu danych, należy skorzystać z poleceń i rozwijanych list z grupy Formatowanie tekstu na wstążce (zobacz rysunek 5.15). Rysunek 5.15. Zmiana czcionki arkusza danych bezpośrednio ze wstążki. Można wybrać krój czcionki, rozmiar oraz inne atrybuty czcionki dla całego arkusza danych
Rozdział 5. Praca z tabelami
179
Zmiana czcionki obejmuje wszystkie dane zawarte w arkuszu. Aby zobaczyć na ekranie jak najwięcej danych, należy użyć bardzo małej czcionki. Można także włączyć tryb wyświetlania w wyższej rozdzielczości (o ile pozwala na to sprzęt). Aby lepiej widzieć litery, wystarczy zwiększyć rozmiar czcionki lub kliknąć przycisk Pogrubienie.
Wyświetlanie linii oddzielających komórki i różne kolory wierszy Normalnie pomiędzy poszczególnymi polami (kolumnami) oraz pomiędzy poszczególnymi rekordami (wierszami) są wyświetlane linie. Za pomocą polecenia Linie siatki z grupy Formatowanie tekstu na wstążce (zobacz rysunek 5.15) można zdecydować, czy linie te mają się wyświetlać czy nie. Z rozwijanej listy Linie siatki można wybrać następujące opcje:
Linie siatki: oba rodzaje,
Linie siatki: poziome,
Linie siatki: pionowe,
Linie siatki: brak.
Za pomocą list Kolor wypełnienia i Alternatywny kolor wypełnienia/tła z grupy Formatowanie tekstu można zmieniać kolory tła na arkuszu danych. Paleta Kolor wypełnienia zmienia kolor wszystkich wierszy arkusza danych, natomiast paleta Alternatywny kolor wypełnienia/tła zmienia kolor wierszy parzystych (gdy ustawiony jest kolor na tej palecie, paleta Kolor wypełnienia określa kolor tylko nieparzystych wierszy). Jeśli ktoś nie chce, aby kolory wyświetlały się naprzemiennie, może wybrać opcję Brak koloru na palecie Alternatywny kolor wypełnienia. Po zmianie ustawień dotyczących linii siatki bądź naprzemiennych kolorów wierszy Access wyświetli pytanie, czy chcemy zapisać zmiany w układzie arkusza danych. Aby zmiany były trwałe, kliknij przycisk Tak. Okno dialogowe Formatowanie arkusza danych (zobacz rysunek 5.16) umożliwia pełną kontrolę nad wyglądem arkusza danych. Aby je otworzyć, należy skorzystać z polecenia Formatowanie arkusza danych wyświetlającego się w prawym dolnym rogu grupy Formatowanie tekstu na wstążce. Za pomocą przełączników Płaski, Wypukły i Wklęsły w grupie Efekt komórki można zmienić wygląd siatki na trójwymiarowy. Pola wyboru Poziome i Pionowe w grupie Pokazywane linie siatki pozwala wybrać linie, które mają być wyświetlane. Za pomocą list Kolor tła, Alternatywny kolor tła i Kolor linii siatki można zmieniać odpowiednie kolory, korzystając z dostępnych palet kolorów. Przykład w środku okna dialogowego prezentuje podgląd wprowadzonych zmian. Listy rozwijane w grupie Style krawędzi i linii umożliwiają modyfikację wyglądu linii siatki. Za ich pomocą można zmienić style obramowania arkusza danych i podkreślenia nagłówka kolumny. Druga lista pozwala wybrać styl linii odpowiadający wyborowi w pierwszej z rozwijanych list. Dostępne są następujące style linii:
Obramowanie przezroczyste,
Ciągłe,
180
Część II Tabele Accessa
Rysunek 5.16. Okno dialogowe Formatowanie arkusza danych. Za jego pomocą można dostosować wygląd arkusza danych
Kreski,
Krótkie kreski,
Kropki,
Kropki z odstępami,
Kreska-Kropka,
Kreska-Kropka-Kropka,
Podwójna ciągła.
Rysunek 5.17 przedstawia arkusz danych, w którym zastosowano linie kropkowane zamiast ciągłych oraz większy kontrast pomiędzy naprzemiennymi wierszami. Aby dostosować arkusz danych do własnych upodobań, można skorzystać z różnych kolorów i stylów. Rysunek 5.17. Różne style linii i kolory wierszy dla arkusza danych
Rozdział 5. Praca z tabelami
181
Wyrównywanie danych w kolumnach Przyciski wyrównywania pozwalają wyrównać dane w kolumnie do lewej lub prawej albo do środka. Za ich pomocą można wybrać wyrównanie różne od ustawień domyślnych, które Access stosuje na podstawie typu danych pola (dane tekstowe są wyrównane do lewej, liczby i daty — do prawej). Aby zmienić wyrównanie danych w kolumnie, wykonaj następujące czynności: 1. Ustaw kursor w dowolnym miejscu w kolumnie, dla której chcesz zmienić wyrównanie. 2. Aby zmienić wyrównanie danych w kolumnie, kliknij polecenie Wyrównaj do lewej, Wyrównaj do środka lub Wyrównaj do prawej w grupie Formatowanie tekstu na wstążce (zobacz rysunek 5.15).
Ukrywanie i odkrywanie kolumn Kolumny można ukryć, przeciągając ich prawe krawędzie do poprzedniej kolumny lub ustalając ich szerokość na 0: 1. Ustaw kursor w dowolnym miejscu kolumny, którą chcesz ukryć. 2. Wybierz polecenie Więcej/Ukryj kolumny w grupie Rekordy na wstążce. Kolumna zniknie z ekranu. W rzeczywistości szerokość kolumny została ustawiona na 0. Aby ukryć większą liczbę kolumn, należy je najpierw zaznaczyć, a następnie wybrać polecenie Więcej/Ukryj kolumny. Po ukryciu kolumn można je ponownie wyświetlić za pomocą opcji Więcej/Odkryj kolumny z grupy Rekordy na wstążce. Kliknięcie tej opcji powoduje wyświetlenie okna dialogowego umożliwiającego wybiórcze ukrywanie i odkrywanie kolumn poprzez określenie dla nich żądanego statusu (zobacz rysunek 5.18). Następnie należy kliknąć przycisk Zamknij, a wówczas wybrane pola zostaną wyświetlone w arkuszu danych. Za pomocą wspomnianego okna dialogowego można również ukrywać jedną lub kilka kolumn poprzez anulowanie zaznaczenia pola wyboru obok każdego z pól, które chcemy ukryć. Rysunek 5.18. Ukrywanie i wyświetlanie kolumn za pomocą okna dialogowego Odkrywanie kolumn
182
Część II Tabele Accessa
Blokowanie kolumn Jeśli chcemy przewijać arkusz o dużą liczbę pól w lewo i w prawo, a jednocześnie chcemy, aby określone kolumny były cały czas widoczne na ekranie, możemy użyć opcji Więcej/ Zablokuj z grupy Rekordy na wstążce. W ten sposób można na przykład spowodować, aby pola ProductID i Description były zawsze widoczne w czasie przewijania arkusza danych w poszukiwaniu innych cech produktu. Zablokowane kolumny wyświetlają się cały czas z lewej strony arkusza danych, podczas gdy pozostałe pola można przewijać w poziomie. Aby zablokować więcej niż jedną kolumnę równocześnie, muszą one występować obok siebie (oczywiście jeżeli nie są tak położone, to trzeba je najpierw przenieść). W celu odblokowania kolumn należy wybrać opcję Więcej/Odblokuj. Po odblokowaniu kolumn nie wracają one na pierwotne miejsca. Trzeba przenieść je ręcznie.
Zapisywanie zmienionego układu arkusza W trakcie zamykania arkusza danych zapisywane są wszystkie zmiany dotyczące danych, ale mogą zostać utracone informacje na temat zmiany układu. Po wprowadzeniu wszystkich koniecznych modyfikacji w wyglądzie arkusza nikt z reguły nie chce powtarzać tych operacji przy każdym kolejnym otwarciu pliku. Jeśli użytkownik wprowadzi dowolne zmiany w układzie danych, podczas zamykania arkusza Access wyświetla pytanie o to, czy zapisać modyfikacje. Aby zachować zmiany, należy kliknąć Tak. Aby ręcznie zapisać zmiany układu, należy kliknąć przycisk Zapisz na pasku narzędzi szybkiego dostępu. Jeżeli wykonujesz na bieżąco opisywane przykłady, nie zapisuj zmian dla tabeli tblProducts, ponieważ jej wygląd nie będzie pasował do dalszych zrzutów.
Zapisywanie rekordu Access zapisuje rekord w chwili opuszczenia go. Aby zapisać rekord bez jego opuszczania, należy nacisnąć kombinację klawiszy Shift+Enter lub wybrać polecenie Zapisz z grupy Rekordy na wstążce. Zamknięcie arkusza danych również powoduje zapisanie rekordu.
Sortowanie i filtrowanie rekordów w arkuszu danych Grupa Sortowanie i filtrowanie na wstążce (zobacz rysunek 5.19) umożliwia zmianę kolejności wierszy i zawężenie liczby wyświetlanych wierszy. Za pomocą poleceń z tej grupy można wyświetlać rekordy we wskazanym porządku. Sposób użycia tych poleceń zademonstrowano w poniższych punktach. Rysunek 5.19. Grupa Sortowanie i filtrowanie umożliwia modyfikowanie kolejności rekordów i zawężanie liczby wyświetlanych wierszy
Rozdział 5. Praca z tabelami
183
Korzystanie z funkcji szybkiego sortowania Czasami trzeba posortować rekordy według określonej kolejności. Przyciski szybkiego sortowania umieszczone na wstążce umożliwiają sortowanie zaznaczonych kolumn w kolejności rosnącej lub malejącej. Aby skorzystać z tych poleceń, należy kliknąć pole, według którego chcemy posortować dane, a następnie kliknąć przycisk Rosnąco lub Malejąco. Dane zostaną natychmiast wyświetlone w żądanej kolejności. Można je także posortować poprzez kliknięcie prawym przyciskiem myszy w kolumnie i wybranie jednego z poleceń Sortuj. Dla pól typu Krótki tekst dostępne są opcje Sortuj od A do Z i Sortuj od Z do A, natomiast dla pól liczbowych można wybrać polecenie Sortuj od najmniejszych do największych lub Sortuj od największych do najmniejszych. Niektórych pól (np. typów Obiekt OLE i Długi tekst) nie można sortować. Aby posortować dane według wartości zawartych w kilku kolumnach, należy zaznaczyć więcej niż jedną kolumnę. W tym celu trzeba zaznaczyć najpierw jedną kolumnę (sposób zaznaczania kolumny przedstawiono wcześniej, w punkcie „Zmiana kolejności pól”), a następnie nacisnąć klawisz Shift i, nie zwalniając go, przesunąć kursor w prawo. Po kliknięciu jednego z przycisków szybkiego sortowania Access posortuje rekordy najpierw według wartości w kolumnie zaznaczonej jako pierwsza, a potem według wartości w kolejnych zaznaczonych kolumnach. Aby zaznaczyć kilka kolumn, które ze sobą nie sąsiadują, należy najpierw przysunąć je do siebie (zgodnie z opisem podanym wcześniej, w punkcie „Zmiana kolejności pól”). Aby wyświetlić rekordy w pierwotnej kolejności, należy wybrać polecenie Usuń sortowanie w grupie Sortowanie i filtrowanie na wstążce.
Używanie filtrowania według wyboru Filtrowanie według wyboru to mechanizm, który umożliwia wybieranie rekordów na podstawie wartości bieżącego pola. Na przykład można ustawić kursor w kolumnie Category tabeli tblProducts i kliknąć polecenie Rosnąco. Access posortuje dane według kategorii pojazdu. Następnie ustawimy kursor w kolumnie Category w polu o wartości Ciężarowe. Teraz wystarczy kliknąć polecenie Zaznaczenie w grupie Sortowanie i filtrowanie na wstążce i wybrać pozycję Równa się „Ciężarowe”. Access wyświetli wszystkie rekordy, w których pole Category ma wartość "Ciężarowe". Po kliknięciu polecenia Zaznaczenie dostępne są cztery opcje:
Równa się „Ciężarowe”,
Nie równa się „Ciężarowe”,
Zawiera „Ciężarowe”,
Nie zawiera „Ciężarowe”.
Obszar z prawej strony przycisków nawigacyjnych (w dolnej części okna arkusza danych) informuje o tym, czy w arkuszu danych zastosowano filtr. Dodatkowo polecenie Przełącz filtr na wstążce jest podświetlone, co oznacza, że zastosowano filtr. Kliknięcie tego polecenia powoduje usunięcie filtru. W takim przypadku specyfikacja filtru nie znika — jest on jedynie wyłączony. Aby ponownie zastosować ten sam filtr, należy kliknąć polecenie Przełącz filtr jeszcze raz.
184
Część II Tabele Accessa
Filtrowanie według wyboru jest addytywne. Po zastosowaniu filtru można kontynuować filtrowanie za pomocą polecenia Zaznaczenie. Wystarczy kliknąć prawym przyciskiem myszy zawartość pola, dla której chcemy zastosować filtr, a następnie wybrać dostępną opcję z menu.
Aby jeszcze bardziej zawęzić działanie filtra, a następnie zobaczyć wszystkie rekordy, które nie spełniają wybranego kryterium (np. takie, gdzie pole Make jest różne od Chevrolet), należy ustawić kursor w polu o wartości, którą chcemy wykluczyć (tam, gdzie pole Make ma wartość Chevrolet), kliknąć je prawym przyciskiem myszy i z opcji filtrowania dostępnych w menu podręcznym wybrać opcję Nie równa się „Chevrolet”. Jeżeli użyjemy polecenia Zaznaczenie dla liczbowych pól danych lub pól z datami, możemy określić zakres poprzez wybranie opcji Między z listy dostępnych opcji po kliknięciu przycisku polecenia. Wystarczy wprowadzić wartości w polach Najmniejsza i Największa dla liczb oraz Najstarsza i Najnowsza dla dat, aby ograniczyć zbiór rekordów do tych, które należą do wskazanego zakresu. Jak można sobie wyobrazić, za pomocą tej techniki można przejrzeć wszystkie transakcje obsłużone przez wybranego przedstawiciela w określonych przedziałach czasu lub dla określonych produktów. Filtrowanie według wyboru oferuje niewiarygodne możliwości wniknięcia w kolejne poziomy danych. Nawet jeśli klikniemy przycisk Usuń filtr w celu wyświetlenia wszystkich rekordów, Access w dalszym ciągu będzie przechowywał w pamięci specyfikację utworzonej kwerendy. Na rysunku 5.20 pokazano arkusz danych poddany działaniu opisanego powyżej filtra, z otwartą listą Filtrowanie według wyboru dla pola Category. Rysunek 5.20. Używanie filtrowania według wyboru. W tym przypadku wyświetlają się rekordy wszystkich samochodów ciężarowych oprócz samochodów marki Chevrolet
Jeżeli zastosujemy filtr w arkuszu danych, to w nagłówku każdej z kolumn wyświetla się wskaźnik informujący o tym, czy w odniesieniu do tej kolumny zastosowano filtr. Wskazanie go myszą powoduje wyświetlenie podpowiedzi zawierającej warunek filtru. Kliknięcie tej podpowiedzi umożliwia określenie dodatkowych kryteriów dla kolumny.
Rozdział 5. Praca z tabelami
185
Do tego celu można wykorzystać rozwijane menu pokazane na rysunku 5.21. Aby wyświetlić podobne menu dla kolumny, dla której nie zastosowano filtra, można kliknąć strzałkę w dół wyświetlającą się w nagłówku kolumny.
Rysunek 5.21. Filtrowanie pola Category. Do ustawienia kryteriów dla pola można skorzystać z menu filtrów kolumny
Menu zawiera polecenia umożliwiające sortowanie kolumny w porządku rosnącym lub malejącym, usuwanie filtra z pola, wybór określonego filtra oraz wybór wartości, które mają się wyświetlić w arkuszu danych. Lista dostępnych poleceń zmienia się na podstawie typu danych kolumny. W tym przypadku lista Filtry tekstu umożliwia wprowadzenie kryteriów filtrowania danych na podstawie wpisanych wartości. Pola wyboru na tej liście zawierają dane występujące w kolumnie. W naszym przykładzie mamy do wyboru (Zaznacz wszystko), (Puste), Ciężarowe, Minivany, Motocykl, Osobowe, Osobowy, Specjalne i SUV. Zaznaczenie pozycji (Zaznacz wszystko) powoduje wyświetlenie w arkuszu danych wszystkich wartości, niezależnie od wartości pola. Zaznaczenie pozycji (Puste) powoduje wyświetlenie rekordów niezawierających danych. Zaznaczenie dowolnej wartości danych powoduje wyświetlenie tylko tych rekordów, dla których wskazane pole zawiera wybrane wartości. Kliknięcie pozycji Minivany i Osobowe spowoduje wyświetlenie rekordów, dla których pole Category ma wartość Minivany lub Osobowe. Jeśli chcemy filtrować dane, ale nie możemy znaleźć wartości, którą chcielibyśmy użyć, możemy wybrać polecenie Filtry tekstu (albo Filtry liczb lub Filtry dat itp.) i wybrać jedno z dostępnych poleceń (Równa się, Nie równa się, Zaczyna się od itp.). Spowoduje to wyświetlenie okna dialogowego, w którym można wpisać żądaną wartość.
Używanie filtrowania według formularza Mechanizm filtrowania według formularza pozwala wprowadzać kryteria w pojedynczym wierszu arkusza danych. Po kliknięciu przycisku Filtrowanie według formularza arkusz danych zmienia się w jeden wiersz z listami rozwijanymi w każdej kolumnie. Listy
186
Część II Tabele Accessa
te zawierają wszystkie niepowtarzalne wartości z poszczególnych kolumn. Zakładka Lub w dolnej części okna umożliwia formułowanie warunków OR dla każdej z grup. Aby włączyć tryb filtrowania według formularza (zobacz rysunek 5.22), należy wybrać polecenie Zaawansowane/Filtrowanie według formularza w grupie Sortowanie i filtrowanie na wstążce. Rysunek 5.22. Filtrowanie według formularza umożliwia zdefiniowanie jednocześnie wielu warunków filtrowania. Warto zwrócić uwagę na zakładkę Lub znajdującą się w dolnej części okna
Wartości wyszukiwane w polach można wybierać za pomocą pól kombi lub wpisywać bezpośrednio w polach. Aby zobaczyć rekordy, w których pole Category ma wartość Ciężarowe lub SUV-y, należy wybrać wartość Ciężarowe z rozwijanej listy Category, kliknąć zakładkę Lub u dołu okna, a następnie wybrać SUV-y z rozwijanej listy Category. Aby zobaczyć rekordy, w których pole Category ma wartość SUV-y, a pole QtyInStock wartość 1, należy wybrać wartość SUV-y z rozwijanej listy Category i wpisać 1 w kolumnie QtyInStock. Po wprowadzeniu żądanych kryteriów należy skorzystać z polecenia Włącz filtr, by zastosować filtr (Przycisk Przełącz filtr pokazano na rysunku 5.19). Korzystając z zakładki Lub, utworzymy dowolną liczbę warunków. Jednak aby zdefiniować jeszcze bardziej zaawansowane metody filtrowania, można użyć polecenia Zaawansowane/Filtr/sortowanie zaawansowane z grupy Sortowanie i filtrowanie na wstążce. Spowoduje to przejście do ekranu QBE służącego do konstrukcji bardziej złożonych kwerend. Posługiwanie się kwerendami oraz używanie operatorów i wyrażeń omówiono w rozdziałach 8. i 9.
Agregowanie danych Arkusze danych Accessa zawsze bardzo przypominały arkusze kalkulacyjne Excela. Arkusze kalkulacyjne i arkusze danych nie tylko wyglądają podobnie, ale także pod wieloma względami podobnie działają. Jak dowiedzieliśmy się z tego rozdziału, arkusze danych Accessa umożliwiają sortowanie, wyszukiwanie rekordów i blokowanie kolumn, a także mają inne własności bliźniaczo podobne do funkcji arkuszy Excela. Jednak oprócz tego jeszcze do niedawna arkusze Accessa i arkusze Excela nie miały ze sobą zbyt wiele wspólnego.
Rozdział 5. Praca z tabelami
187
W odróżnieniu od arkuszy Excela arkusze Accessa nie pozwalały na wykonywanie podsumowań w wierszach i kolumnach ani innego rodzaju agregacji danych. Począwszy od Accessa 2007 arkusze danych zawierają wiersz Suma u dołu. Aby wyświetlić wiersz Suma, należy kliknąć przycisk Sumy w grupie Rekordy na wstążce NARZĘDZIA GŁÓWNE (przycisk Sumy jest oznaczony grecką literą sigma, podobnie jak przycisk Autosumowanie w Excelu). Każdą kolumnę w wierszu Suma można wykorzystać do innego obliczenia (suma, średnia, minimum, maksimum, zliczanie rekordów, odchylenie standardowe i wariancja). Aby skorzystać z wiersza Suma, otwórz tabelę lub formularz w widoku arkusza danych, a następnie kliknij przycisk Sumy w grupie Rekordy na wstążce NARZĘDZIA GŁÓWNE (zobacz rysunek 5.23). Access doda wiersz Suma u dołu arkusza danych, bezpośrednio pod wierszem Nowy.
Rysunek 5.23. Wiersz Suma w arkuszu danych
Kliknięcie w kolumnie w wierszu Suma powoduje przekształcenie komórki arkusza w listę rozwijaną. Poszczególne pozycje na liście są specyficzne dla typu danych kolumny. Na przykład w kolumnach tekstowych na rozwijanej liście są tylko pozycje Brak i Liczba, natomiast kolumny liczbowe zawierają pełen zbiór dostępnych podsumowań (suma, średnia, liczba itp.). Dla kolumn Data/Godzina dostępne są opcje Brak, Średnia, Liczba, Minimum i Maksimum. Obliczenia wybranych podsumowań są dynamiczne. W miarę modyfikowania danych w arkuszu danych bądź tabeli wyniki obliczeń wyświetlanych w wierszu Suma są automatycznie aktualizowane w bardzo krótkim czasie po wprowadzeniu modyfikacji. Obliczenie wielu sum wiąże się z pewnym obniżeniem wydajności, dlatego w niektórych sytuacjach, kiedy specjalne własności sumowania nie są potrzebne, można ukryć wiersz Suma. Opcje podsumowań wybranych dla kolumn arkusza danych są trwałe. Po zamknięciu arkusza danych i ponownym otwarciu wiersz Suma wyświetla się ponownie. Aby wyłączyć wiersz Suma, otwórz arkusz danych, a następnie kliknij przycisk Sumy w grupie Rekordy w zakładce NARZĘDZIA GŁÓWNE. Interesującą cechą wiersza Suma jest fakt, że w przypadku jego usunięcia można go później przywrócić do poprzedniej postaci (wystarczy jeszcze raz kliknąć przycisk Sumy).
188
Część II Tabele Accessa
Drukowanie rekordów Wszystkie rekordy zawarte w arkuszu danych można wydrukować w prostym układzie wierszy i kolumn. Sformatowane raporty nauczymy się konstruować w rozdziale 20. Na razie najprostszym sposobem drukowania jest kliknięcie ikony Drukuj na pasku narzędzi szybkiego dostępu. Spowoduje to wydrukowanie arkusza danych na domyślnej drukarce systemu Windows. Dodatkowe opcje drukowania znajdziemy w menu dostępnym za pomocą przycisku PLIK (zobacz rysunek 5.24). Rysunek 5.24. Menu Drukuj pakietu Microsoft Office
Wydruk odzwierciedla wszystkie opcje układu obowiązujące w czasie tworzenia wydruku. Kolumny ukryte nie są drukowane. Linie siatki są drukowane tylko w przypadku, gdy włączono krawędzie komórek. Wydruk uwzględnia także zdefiniowane wysokości wierszy i szerokości kolumn. Na pojedynczej stronie może się zmieścić jedynie określona liczba kolumn i wierszy — wydruk zajmie tyle stron, aby cały arkusz danych się na nich zmieścił. Jeżeli to konieczne, Access dzieli wydruk tak, aby dopasować go do pojedynczych stron. Na przykład wydruk tabeli tblProducts zajmuje 9 stron. Do wydrukowania wszystkich pól potrzebne są 3 strony, natomiast aby wydrukować wszystkie wiersze niezbędne są 3 strony. Jeden rekord tabeli tblContacts rozciąga się na 4 strony. Liczba stron zależy od zdefiniowanego układu i użytej drukarki.
Drukowanie arkusza danych Procesem drukowania można sterować za pomocą okna dialogowego Drukowanie, które otwiera się po wybraniu polecenia Drukuj. W tym oknie dialogowym można dostosować wydruk poprzez wybór różnych opcji:
Rozdział 5. Praca z tabelami
Zakres wydruku — drukuje cały arkusz danych lub tylko wybrane strony czy rekordy.
Liczba kopii — określa liczbę kopii, jakie mają zostać wydrukowane.
Sortuj — określa, czy poszczególne kopie mają być sortowane.
189
Można też zmienić drukarkę, kliknąć przycisk Właściwości i ustawić opcje dotyczące wybranej drukarki. Przycisk Ustawienia umożliwia zdefiniowanie marginesów i nagłówków.
Korzystanie z podglądu wydruku Chociaż w samym arkuszu danych możliwe jest określenie wszystkich informacji koniecznych do drukowania, to jednak opierając się wyłącznie na nim, nie mamy pewności, czy szerokość i wysokość wierszy i kolumn jest odpowiednia lub czy w celu ulepszenia wydruku nie należy zmienić czcionki na inną. Aby obejrzeć zadanie drukowania, można kliknąć polecenie Podgląd wydruku w menu Drukuj, co spowoduje wyświetlenie okna Podgląd wydruku. Domyślny widok podglądu w trybie pojedynczej strony to pierwsza strona wydruku. Aby wybrać inne widoki oraz powiększyć lub pomniejszyć widok na podglądzie, można skorzystać z poleceń dostępnych na wstążce. Kliknięcie polecenia Drukuj powoduje wydrukowanie arkusza danych na drukarce. Aby zamknąć podgląd wydruku i powrócić do widoku arkusza danych, należy kliknąć polecenie Zamknij podgląd wydruku po prawej stronie wstążki.
190
Część II Tabele Accessa
Rozdział 6.
Importowanie i eksportowanie danych W tym rozdziale:
Wprowadzenie do danych zewnętrznych
Wybór odpowiednich opcji importowania i eksportowania
Tworzenie specyfikacji importu
Eksport danych do zewnętrznych tabel i plików
W tym rozdziale pokazujemy, jak za pomocą importowania przenieść dane z zewnętrznych źródeł do bazy danych Accessa. Wyjaśniamy też, jak dzięki eksportowaniu tworzyć zewnętrzne pliki na podstawie danych z bazy. Proces importowania polega na dodawaniu do baz Accessa danych z zewnętrznych źródeł, np. z plików XML. Eksportowanie danych z Accessa prowadzi do utworzenia poza bazą nowych elementów, takich jak plik XML lub Excela z danymi z Accessa. W tym rozdziale wykorzystano wiele plików do importowania oraz dwie bazy danych Accessa: Rozdział06_1.accdb oraz Rozdział06_2.accdb. Obie bazy danych będą wykorzystane do importowania i eksportowania danych. Jeżeli ktoś jeszcze nie skopiował tych plików do swojego komputera, powinien zrobić to teraz. W przykładach znajduje się też szereg plików pomocniczych w różnych formatach (.xls, .xml, .txt itd.). Pamiętaj, aby skopiować także te pliki.
Access i dane zewnętrzne Wymiana informacji między Accessem a innymi programami ma bardzo istotne znaczenie w świecie współczesnych baz danych. Informacje są zwykle przechowywane w bardzo różnorodnych aplikacjach i formatach. Access (podobnie jak wiele innych produktów) ma własny, rodzimy format plików, który zapewnia integralność odwołań oraz obsługę wzbogaconych typów danych, takich jak obiekty OLE. W większości sytuacji format ten wystarcza; od czasu do czasu zdarza się jednak, że trzeba przenieść dane z jednego pliku bazy danych Accessa do drugiego lub wykorzystać dane w formacie z innego programu.
192
Część II Tabele Accessa
Typy danych zewnętrznych Access może wymieniać dane z wieloma różnymi aplikacjami. Zdarza się, że trzeba uzyskać dane z innych plików baz danych (takich jak FoxPro albo dBASE) lub pobrać informacje z serwera SQL Server, serwera Oracle albo pliku tekstowego. Access może przenosić dane między kilkoma kategoriami aplikacji takimi jak: inne aplikacje systemu Windows, aplikacje z komputerów Macintosha, inne systemy zarządzania bazami danych, pliki tekstowe oraz pliki z systemów mainframe.
Metody pracy z danymi zewnętrznymi Często trzeba przenieść dane z innej aplikacji lub pliku do bazy danych Accessa (albo na odwrót). Może się zdarzyć, że będą nam potrzebne informacje, które wcześniej wpisaliśmy do arkusza kalkulacyjnego. Można przepisać je ręcznie albo zaimportować do bazy danych. Access zawiera narzędzia, które umożliwiają wymianę informacji z innymi bazami danych lub arkuszami kalkulacyjnymi. Access potrafi wymieniać dane z wieloma różnymi typami plików, takimi jak:
obiekty baz danych Accessa (wszystkie typy),
pliki tekstowe,
pliki Excela,
bazy danych ODBC (SQL Server, Sybase Server, Oracle Server i inne bazy danych zgodne ze standardem ODBC),
HTML-owe tabele, listy i dokumenty,
dokumenty XML,
dane z Outlooka,
dokumenty Microsoft Exchange,
dane z SharePointa,
dokumenty Worda,
dokumenty w formacie RTF.
Access może pracować z zewnętrznymi źródłami danych na kilka sposobów:
Łączenie — tworzy łącze do tabeli w innej bazie danych Accessa albo dołącza dane przechowywane w innym formacie. Przy łączeniu wykorzystuje się dane w ich źródłowym formacie (np. pliki Excela lub XML). Dołączone dane pozostają w pierwotnym pliku. Pliku zawierającego połączone dane nie można przenieść ani usunąć. Nie można też zmienić jego nazwy. W innym przypadku, kiedy dane będą potrzebne następnym razem, Access nie będzie ich mógł zlokalizować. Jeśli nie można uniknąć przeniesienia lub zmiany nazwy połączonego źródła danych, warto wykorzystać narzędzia Accessa przeznaczone do ponownego łączenia bazy ze źródłem.
Rozdział 6. Importowanie i eksportowanie danych
193
Importowanie — kopiuje dane ze źródła danych, innej bazy danych Accessa albo pliku z bazą innej aplikacji do tabeli Accessa. Zaimportowane dane podlegają konwersji na właściwy typ danych Accessa, są zapisywane w tabeli i od tej pory Access nimi zarządza.
Eksportowanie — kopiuje dane z tabeli Accessa do pliku tekstowego, innej bazy danych Accessa albo pliku w formacie używanym w innej aplikacji. Podobnie jak przy importowaniu modyfikacje źródłowych danych nie mają wpływu na wyeksportowane informacje. Łączenie danych zewnętrznych z Accessem omawiamy w rozdziale 7.
Każda z metod ma swoje zalety i wady. Opisujemy je w kolejnych punktach. Kiedy należy dołączyć dane zewnętrzne? Łączenie w Accessie pozwala na pracę z danymi w formacie innej aplikacji, a więc na współdzielenie pliku z pierwotną aplikacją. Jeśli pozostawimy dane w formacie innej bazy danych, Access będzie mógł wczytywać dane wciąż używane przez pierwotną aplikację. Jest to przydatne, kiedy chcemy pracować w Accessie z danymi, którymi posługują się również inne programy. Jednak korzystanie z dołączonych danych związane jest z pewnymi ograniczeniami. Nie można na przykład aktualizować danych w połączonych arkuszach Excela lub plikach tekstowych. Możliwość korzystania z danych zewnętrznych jest też przydatna przy używaniu Accessa jako frontonu bazy danych SQL Server — można połączyć się z tabelą systemu SQL Server i aktualizować dane bezpośrednio tam, zamiast przesyłać je później wsadowo. Bazy danych Accessa często są łączone z danymi zewnętrznymi. Dzięki temu użytkownicy formularzy Accessa mogą dodawać i aktualizować dane zewnętrzne lub korzystać z nich w raportach Accessa. W Accessie można utworzyć łącze do następujących typów danych:
innej tabeli Accessa (.accdb, .accde, .accdr, .mdb, mda, mde),
arkusza kalkulacyjnego Excela,
folderów Outlooka,
plików tekstowych,
plików XML,
dokumentów HTML,
list SharePointa,
baz danych ODBC. W Accessie można dołączyć dane w różnych formatach (np. tabele z HTML-a, pliki tekstowe, pliki Excela i dokumenty XML) w trybie tylko do odczytu. Można używać i przeglądać tabele w formacie HTML lub tekstowym, ale nie można ich aktualizować ani dodawać do nich rekordów z wykorzystaniem Accessa.
194
Część II Tabele Accessa
Największą wadą tabel dołączonych jest to, że Access nie może wymuszać więzów integralności między tabelami (chyba że połączymy się z bazą danych Accessa lub wszystkie dołączone tabele znajdują się w innym systemie zarządzania bazami danych, który obsługuje więzy integralności). Tabele dołączone mogą też okazać się mniej wydajne od tabel lokalnych. W zależności od rodzaju i lokalizacji źródła danych użytkownicy mogą odczuć znaczące opóźnienie w trakcie otwierania formularzy lub raportów opartych na połączonych danych. Problemy z wydajnością stają się jeszcze bardziej widoczne, gdy w kwerendach stosuje się sprzężenia danych połączonych i lokalnych. Ponieważ Access nie może przeprowadzić optymalizacji danych zewnętrznych, sprzężenia często są niewydajne, a ich obliczenie wymaga dużo pamięci i cykli procesora. Jednak wyjątkowe możliwości Accessa w zakresie pracy z wieloma rodzajami danych zewnętrznych sprawiają, że jest to idealna platforma do rozwijania aplikacji, w których jest to potrzebne. Kiedy należy zaimportować dane zewnętrzne? Importowanie danych pozwala fizycznie wprowadzić zewnętrzną tabelę lub źródło danych do nowej lub istniejącej tabeli Accessa. Access automatycznie konwertuje dane z zewnętrznego formatu i kopiuje je do swojej tabeli. Można nawet zaimportować obiekty danych do innej bazy danych lub projektu Accessa, zamiast tego, który jest otwarty. Jeśli wiemy, że dane będą używane tylko w Accessie, powinniśmy je zaimportować. Ogólnie rzecz biorąc, Access działa szybciej z własnymi tabelami. Ponieważ importowanie powoduje utworzenie kopii danych, można usunąć stary plik po zaimportowaniu kopii do Accessa. Czasem bywa to jednak niewskazane. Dane mogą pochodzić na przykład z wciąż używanego arkusza kalkulacyjnego Excela. W takich przypadkach lepiej zachować zdublowane dane i pogodzić się z tym, że będą zajmować więcej miejsca (i że w obu plikach mogą pojawić się różne dane).
Jednym z podstawowych powodów importowania danych jest dostosowywanie ich do własnych potrzeb. Po zaimportowaniu tabeli do bazy Accessa można z nią pracować w taki sposób, jakby była zapisana w bieżącej bazie danych. Z drugiej strony, w dołączonych tabelach można wprowadzać tylko niektóre zmiany. Nie można na przykład określić klucza podstawowego ani reguł wprowadzania danych, przez co nie można wymusić integralności. Ponadto dołączone tabele prowadzą do plików zewnętrznych, które Access wyszukuje w określonej lokalizacji. Utrudnia to dystrybucję aplikacji. Dane w nieobsługiwanych programach Może się zdarzyć (choć to mało prawdopodobne), że wystąpi potrzeba skorzystania z danych pewnego programu, które są zapisane w nieobsługiwanym formacie bazy danych lub pliku. W takich przypadkach program zwykle może wyeksportować lub przekształcić swoje dane do jednego z formatów rozpoznawanych przez Accessa. Aby użyć danych z takich programów, należy wyeksportować je do formatu rozpoznawanego przez Accessa, a następnie zaimportować do Accessa. Większość aplikacji potrafi eksportować dane do plików XML. Jeśli format ten jest niedostępny, większość programów — nawet tych działających w innych systemach operacyjnych — potrafi eksportować dane do plików tekstowych z ogranicznikami albo o stałej szerokości pól, które można następnie zaimportować do Accessa.
Rozdział 6. Importowanie i eksportowanie danych
195
Dane do bazy danych Accessa często importuje się z przestarzałego systemu zastępowanego nową aplikacją w Accessie. Po zakończeniu procesu importowania starą aplikację można usunąć z komputera użytkownika. W przypadku częstego importowania danych z tego samego źródła można zautomatyzować ten proces za pomocą makra albo procedury języka VBA. Bywa to bardzo przydatne, jeśli regularnie importujemy dane z zewnętrznego źródła albo przeprowadzamy skomplikowane przekształcenia na importowanych danych.
Kiedy warto eksportować dane zewnętrzne? Wyeksportowane dane można przekazać do innej aplikacji. W trakcie eksportowania Access automatycznie przekształca dane na format zewnętrzny i kopiuje je do pliku, który można wczytać w innej aplikacji. Jak już wspomniano, czasem trzeba zaimportować dane do Accessa, aby móc je zmodyfikować (nie wystarczy połączyć tabeli z zewnętrznym źródłem danych). Jeśli chcesz zachować możliwość pracy ze zmodyfikowanymi danymi w zewnętrznej aplikacji, musisz utworzyć nowy plik przez wyeksportowanie zmienionych danych. Częstym powodem eksportowania danych jest chęć udostępnienia ich użytkownikom, którzy nie mają zainstalowanego Accessa.
Typy importu i eksportu Przed przystąpieniem do analizy procesów importowania i eksportowania spróbujemy w zwięzły sposób omówić niektóre opcje importowania danych do Accessa i eksportowania danych z Accessa. Bazy Accessa czasem nazywa się lądowiskiem dla wielu typów danych. Wynika to z tego, że Access ma możliwość używania i wymiany danych z wieloma aplikacjami. Na przykład można pobrać dane z innych baz danych, takich jak FoxPro lub dBase. Czasami trzeba również uzyskać informacje z bazy danych SQL Server, Oracle, pliku tekstowego lub nawet dokumentu XML. Access ma możliwość przenoszenia danych pomiędzy różnymi kategoriami aplikacji, silnikami baz danych, a nawet różnych platformami (komputery mainframe, komputery Macintosh). Otwórz bazę danych Rozdział06_1.accdb w Accessie i kliknij zakładkę DANE ZEWNĘTRZNE na wstążce (zobacz rysunek 6.1). Zobaczysz następujące grupy: Importowanie i łączenie, Eksportowanie, Zbieranie danych oraz Listy połączone z siecią Web.
Rysunek 6.1. Zakładka DANE ZEWNĘTRZNE obejmuje różne źródła danych dostępne w Accessie
Grupa Importowanie i łączenie obejmuje następujące opcje:
Zapisane operacje importowania,
Menedżer tabel połączonych,
196
Część II Tabele Accessa
Excel,
Access,
Baza danych ODBC,
Plik tekstowy,
Plik XML,
Więcej — kliknij ten przycisk, aby otworzyć listę rozwijaną Więcej. Obejmuje ona następujące opcje:
Lista programu SharePoint,
Usługi danych,
Dokument HTML,
Folder programu Outlook.
Grupa Eksportowanie obejmuje wymienione poniżej opcje:
Zapis. dane eksportu,
Excel,
Plik tekstowy,
Plik XML,
PDF lub XPS,
Wiadomość e-mail,
Access,
Korespondencja seryjna w programie Word,
Więcej — kliknij ten przycisk, aby otworzyć listę rozwijaną Więcej. Znajdziesz na niej następujące opcje:
Word,
Lista programu SharePoint,
Baza danych ODBC,
Dokument HTML.
Microsoft najwyraźniej dobrze przygotował Accessa do pełnienia funkcji lądowiska dla danych.
Importowanie zewnętrznych danych Proces importowania polega na skopiowaniu zewnętrznych danych do bazy danych Accessa. Zewnętrzne dane pozostają w pierwotnym stanie, a do Accessa importowana jest ich kopia. W przypadku importowania pliku (w przeciwieństwie do łączenia tabel) kopiujemy
Rozdział 6. Importowanie i eksportowanie danych
197
zawartość zewnętrznego źródła do tabeli Accessa. W trakcie tej operacji zewnętrzne źródło danych nie jest modyfikowane. Po zakończeniu procesu importowania nie są zachowywane żadne połączenia z zewnętrznym źródłem. Informacje można zaimportować albo do nowych, albo do istniejących tabel. Wszystkie typy danych można zaimportować do nowych tabel. Jednak w przypadku niektórych typów importu — na przykład przy importowaniu arkuszy kalkulacyjnych i plików tekstowych — dane trzeba importować do istniejących tabel, ponieważ pliki tekstowe i arkusze nie zawsze mają strukturę tabeli zgodną z Accessem.
Importowanie z innej bazy danych Accessa Do bieżącej bazy danych można importować obiekty z bazy źródłowej. Można importować tabele, kwerendy, formularze, raporty, makra lub moduły. W celu zaimportowania obiektu do bieżącej bazy danych Accessa wykonaj następujące czynności: 1. Otwórz docelową bazę danych, do której chcesz importować obiekty. W tym przypadku otwórz bazę danych Rozdział06_1.accdb. 2. Kliknij zakładkę DANE ZEWNĘTRZNE. 3. Kliknij opcję Access w sekcji Importowanie, a następnie kliknij przycisk Przeglądaj, aby określić nazwę pliku źródłowej bazy danych Accessa (Rozdział06_2.accdb). 4. Zaznacz przycisk opcji Importuj tabele, kwerendy, formularze, raporty, makra i moduły do bieżącej bazy danych, a następnie kliknij przycisk OK. Pojawi się okno dialogowe Importowanie obiektów (zobacz rysunek 6.2). Znajdują się tu obiekty bazy danych, które można zaimportować. Rysunek 6.2. Z jednej bazy danych Accessa do drugiej można zaimportować wiele typów obiektów
198
Część II Tabele Accessa
W trakcie pracy z zewnętrzną bazą danych Accessa można importować obiekty dowolnego rodzaju, w tym tabele, kwerendy, formularze, raporty, makra i moduły z kodem VBA.
5. Wybierz jedną z tabel i kliknij OK. Jeśli obiekt już istnieje w docelowej bazie danych, do nazwy importowanego obiektu zostanie dodany kolejny numer w celu odróżnienia zaimportowanego obiektu od tego, który występował wcześniej w docelowej bazie danych. Jeśli w docelowej bazie danych jest tabela tblWydziały, nowa zaimportowana tabela będzie miała nazwę tblWydziały1. Pojawi się okno dialogowe Pobieranie danych zewnętrznych — Zapisz kroki importowania. Udostępnia ono bardzo wygodną funkcję: pozwala zapisać proces importowania, co pokazano na rysunku 6.3.
Rysunek 6.3. Funkcja zapisywania kroków importowania pozwala zapisywać wykonywane często procesy w celu ich późniejszego wykorzystania
6. Podaj nazwę procesu importowania, tak aby móc łatwo sobie przypomnieć, do czego dany proces służy. Później możesz uruchomić zapisany proces importowania, klikając przycisk Zapisane operacje importowania w grupie Importowanie zakładki DANE ZEWNĘTRZNE na wstążce (zobacz rysunek 6.4). W oknie dialogowym Zarządzanie zadaniami danych można zmienić nazwę zapisywanego procesu importu, lokalizację pliku źródłowego, a także opis procesu. Pozostałych informacji na temat procesu importu (np. nazwy docelowej tabeli) nie można modyfikować. Jeśli chcesz zmienić inne informacje, utwórz nowy proces importu o odpowiednich cechach.
Rozdział 6. Importowanie i eksportowanie danych
199
Rysunek 6.4. Zapisane wcześniej procesy importowania można ponownie uruchomić Okno dialogowe Zarządzanie zadaniami danych obejmuje przycisk Utwórz zadanie programu Outlook, który służy do zapisywania procedury importu jako zaplanowanego zadania Outlooka. Jest to bardzo wygodny sposób automatycznego wykonywania procesu importowania w regularnych odstępach czasu.
Importowanie danych z arkusza kalkulacyjnego Excela Można zaimportować dane z arkuszy kalkulacyjnych Excela do nowej albo istniejącej tabeli. Najważniejsze jest to, że każda komórka danych w kolumnie arkusza musi zawierać dane tego samego typu. W trakcie importowania danych z Excela Access odgaduje typ danych dla każdego pola w nowej tabeli. Robi to na podstawie pierwszych kilku wierszy danych Excela (innych niż nagłówki kolumn). Jeśli któryś z dalszych wierszy w arkuszu Excela obejmuje niezgodne dane, może wystąpić błąd importowania. W arkuszu z rysunku 6.5 kolumna Age powinna zawierać wyłącznie liczby, ale zawiera jedną tekstową reprezentację wieku. Może to spowodować błąd w trakcie importowania. Dlatego dane z piątego wiersza należy zmodyfikować, aby cała kolumna zawierała dane liczbowe (zobacz rysunek 6.6). Można zaimportować lub dołączyć wszystkie dane z arkusza Excela albo tylko dane z nazwanego zakresu komórek. Jeśli nadamy zakresowi w arkuszu kalkulacyjnym nazwę, importowanie danych do Accessa będzie łatwiejsze. Arkusz jest często podzielony na grupy komórek (zakresy). Jedna z tych grup może, na przykład, zawierać listę transakcji danego klienta. Sekcja poniżej listy transakcji może zawierać łączne kwoty transakcji z wszystkimi klientami, sumy dla poszczególnych typów produktów albo sumy według miesiąca nabycia. Nadanie nazw poszczególnym grupom komórek umożliwia ograniczenie importu do określonej części arkusza.
200
Część II Tabele Accessa
Rysunek 6.5. Access umożliwia importowanie danych z arkusza Excela, ale z pewnymi ograniczeniami
Rysunek 6.6. Kolumny w arkuszu Excela powinny obejmować dane tego samego typu
Aby zaimportować arkusz Excela o nazwie EMPLIST.xls, wykonaj następujące czynności: 1. Kliknij przycisk Excel w zakładce DANE ZEWNĘTRZNE. 2. Przejdź do pliku Excela. 3. Wybierz opcję Importuj dane źródłowe do nowej tabeli w bieżącej bazie danych i kliknij przycisk OK. Na pierwszym ekranie kreatora importowania arkuszy (zobacz rysunek 6.7) zobaczysz listę arkuszy i nazwanych zakresów ze skoroszytu Excela, a także podgląda danych. 4. Wybierz arkusz lub nazwany zakres i ponownie kliknij przycisk Dalej.
Rozdział 6. Importowanie i eksportowanie danych
201
Rysunek 6.7. Kreator importu arkuszy
5. Na następnym ekranie (zobacz rysunek 6.8) zaznacz pole wyboru Pierwszy wiersz zawiera nagłówki kolumn i kliknij przycisk Dalej. Nie chcemy, aby nagłówki kolumn Excela były zapisane jako wartości pól. Access wykorzystuje nagłówki do utworzenia nazw pól nowej tabeli.
Rysunek 6.8. Czy pierwszy wiersz zawiera nagłówki kolumn?
202
Część II Tabele Accessa
6. Na następnym ekranie (zobacz rysunek 6.9) można określić nową nazwę dla pola, ustawić jego typ danych, usunąć pola, a także utworzyć indeks. Po zakończeniu wykonywania tych operacji kliknij przycisk Dalej.
Rysunek 6.9. Można zmienić domyślne ustawienia wybrane przez Accessa
7. Na następnym ekranie ustaw klucz główny dla nowej tabeli (zobacz rysunek 6.10) i kliknij przycisk Dalej. Klucz główny w niepowtarzalny sposób identyfikuje każdy wiersz w tabeli. Zachowaj ostrożność przy wybieraniu klucza głównego dla importowanych plików. Wskazane pole musi zawierać wartości zgodne z regułami tworzenia kluczy głównych. Nie może obejmować wartości null ani powtórzeń. Klucz główny tabeli służy do identyfikowania wierszy tabeli, dlatego jeśli żadna kolumna z arkusza Excela się do tego nie nadaje, najlepiej pozwolić Accessowi na dodanie domyślnego pola z kluczem głównym. Pola klucza głównego generowane przez Accessa zawsze mają typ Autonumerowanie i są zgodne z regułami normalizacji danych. Klucze główne omówiono w rozdziałach 3. i 4.
8. Określ nową nazwę tabeli, a następnie kliknij przycisk Zakończ. Jeśli importujesz plik Excela o takiej samej nazwie jak już dołączony plik Excela, Access wyświetli pytanie o to, czy chcesz zastąpić istniejący plik. Najlepiej nadać importowanej tabeli nową nazwę, chyba że rzeczywiście zamierzasz zastąpić dołączoną.
9. Proces importowania można zapisać i uruchomić ponownie później. Nowa tabela znajdzie się w okienku nawigacyjnym Accessa.
Rozdział 6. Importowanie i eksportowanie danych
203
Rysunek 6.10. Określanie klucza głównego dla nowej tabeli
Importowanie list SharePointa Listy SharePointa to potencjalne źródła danych dla baz Accessa. Ponieważ listy te znajdują się na serwerach WWW, dane z nich są dostępne w internecie dla uprawnionych użytkowników. W ten sposób za pomocą Accessa można współużytkować dane na całym świecie. W części VIII tej książki znajdziesz wprowadzenie do usług SharePointa i omówienie korzystania z nich.
Ponieważ w firmowych intranetach usługi SharePointa są coraz popularniejsze, Access z pewnością pozostanie ważną technologią w środowiskach korporacyjnych.
Importowanie danych z plików tekstowych Jest wiele przypadków, kiedy trzeba korzystać z plików tekstowych, na przykład przy przesyłaniu danych między firmami. Ponadto dane z systemów mainframe są zazwyczaj przenoszone do aplikacji w komputerach osobistych za pomocą plików tekstowych. W Accessie można importować dwa typy plików tekstowych: z ogranicznikami albo o stałej szerokości pól. Do importowania i eksportowania obu typów plików, w Accessie wykorzystuje się ten sam kreator. Pliki tekstowe z ogranicznikami Pliki tekstowe z ogranicznikami bywają też nazywane plikami z polami oddzielonymi przecinkami albo z polami oddzielonymi znakami tabulacji. Każdy rekord znajduje się tu w oddzielnym wierszu pliku. Pola w wierszu nie są uzupełniane spacjami, separatorem
204
Część II Tabele Accessa
pól jest najczęściej przecinek lub tabulator, a niektóre pola muszą być otoczone ogranicznikami (takimi jak znaki apostrofu lub cudzysłowu). Oto przykład pliku tekstowego rozdzielanego przecinkami: 1;Dankowska;Natalia;5/1/92 0:00:00;4000 2;Fulkowski;Andrzej;8/14/92 0:00:00;6520 3;Lubińska;Janina;4/1/92 0:00:00;1056 4;Piernikowska;Małgorzata;5/3/93 0:00:00;4000 5;Bochenek;Stefan;10/17/93 0:00:00;5000 6;Surma;Michał;10/17/93 0:00:00;1000 7;Król;Robert;1/2/94 0:00:00;1056 8;Celińska;Leokadia;3/5/94 0:00:00;1056 9;Dudziński;Józef;11/15/94 0:00:00;1056
Zwróćmy uwagę, że powyższy plik zawiera dziewięć rekordów (wierszy tekstu) i pięć pól. Pola są oddzielone przecinkami. Pola tekstowe nie są ograniczone znakami cudzysłowu. Każdy rekord ma inną długość, ponieważ różne są długości danych. Aby zaimportować plik tekstowy z ogranicznikami o nazwie ImportDelim.txt, wykonaj następujące czynności: 1. Otwórz bazę danych Rozdział06_1.accdb. 2. Kliknij zakładkę DANE ZEWNĘTRZNE. 3. W sekcji Importowanie kliknij Importuj plik tekstowy. 4. Odszukaj plik tekstowy ImportDelim.txt, wybierz go i kliknij przycisk OK. Następny ekran, jaki się wyświetli, to pierwsza strona kreatora importowania tekstu (zobacz rysunek 6.11). Kreator importu tekstu wyświetla dane w pliku tekstowym i pozwala wybrać między plikiem z ogranicznikami a plikiem o stałej szerokości pól.
Rysunek 6.11. Pierwszy ekran Kreatora importu tekstu
Rozdział 6. Importowanie i eksportowanie danych
205
5. Wybierz opcję Ograniczony i kliknij przycisk Dalej. Pojawi się następny ekran Kreatora importu tekstu (zobacz rysunek 6.12). Jak pokazano na rysunku 6.12, na tym ekranie można określić typ separatora używany w pliku tekstowym. Separator to określony znak umieszczany między polami w pliku tekstowym z ogranicznikami — często jest to średnik, choć może to być dowolny inny znak.
Rysunek 6.12. Drugi ekran Kreatora importu tekstu
6. Wybierz znak rozdzielający pola. Jeśli używany jest nietypowy separator, wybierz opcję Inny i wpisz znak w polu Inny. Jeśli separator pojawia się w wartościach pól pliku tekstowego, mogą wystąpić problemy. Gdy do rozdzielania pól używasz przecinka, a jedno z pól zawiera wartość Acme Widgets, Inc., Access będzie miał trudności z zaimportowaniem pliku. Rozwiązaniem jest umieszczenie pól tekstowych w cudzysłowach ("Acme Widgets, Inc."). Dzięki temu przecinek nie zostanie błędnie uznany za separator pól. Cudzysłów jest w tym kontekście kwalifikatorem tekstu. Cudzysłowy pełnią tu funkcję kwalifikatora. Najczęściej używa się w tym celu apostrofów i właśnie cudzysłowów. Zwykle można w ten sposób rozwiązać problemy związane z występowaniem znaków specjalnych w polach z danymi.
7. Jeśli pierwszy wiersz obejmuje nazwy pól importowanej tabeli, zaznacz pole Pierwszy wiersz zawiera nazwy pól. Po ustawieniu opcji na tym ekranie należy kliknąć przycisk Dalej. Kilka dalszych ekranów wygląda bardzo podobnie jak przy importowaniu arkuszy Excela. Można zmienić nazwy pól, określić klucz główny, a także zapisać proces importowania do wykorzystania później. Dla zaimportowanego pliku tekstowego ustaw opisową nazwę tabeli w Accessie. Access przy tworzeniu nowej tabeli domyślnie używa nazwy pliku tekstowego. Nowa tabela pojawia się w okienku nawigacyjnym Accessa.
206
Część II Tabele Accessa Aby podać puste pole w pliku tekstowym z ogranicznikami, nie wprowadzaj żadnych znaków (nawet odstępu) między przecinkami. Puste pole na końcu wiersza można dodać przez umieszczenie w tym miejscu przecinka.
Importowanie plików o stałej szerokości pól W plikach tekstowych o stałej szerokości pól każdy rekord również występuje w innym wierszu. Pola w każdym z rekordów mają jednak stałą długość. Jeśli zawartość pola nie jest wystarczająco długa, dodaje się do niego spacje tak, jak pokazano na rysunku 6.13. Rysunek 6.13. Typowy plik tekstowy o stałej szerokości pól
Zwróćmy uwagę, że pola nie są rozdzielone ogranicznikami. Zamiast tego rozpoczynają się dokładnie na tej samej pozycji w każdym rekordzie. Każdy rekord ma dokładnie tę samą długość. Warto również zauważyć, że wartości tekstowe, na przykład imiona i nazwiska, nie są ujęte w cudzysłów. Nie ma potrzeby wyróżniania wartości tekstowych, ponieważ każde pole ma określoną długość. Wszystko, co znajduje się w obrębie pozycji pola, jest interpretowane jako dane i nie wymaga ograniczników. Jeśli tabela Accessa, do której importujemy dane, ma pole klucza głównego, plik tekstowy nie może zawierać duplikatów w tym polu, bo w przeciwnym razie operacja importu zakończy się błędem, a wiersze z powtarzającymi się wartościami klucza głównego nie zostaną pobrane.
Aby zaimportować plik tekstowy o stałej długości pól, wykonaj następujące czynności: 1. Otwórz bazę danych Rozdział06_1.accdb. 2. Kliknij zakładkę DANE ZEWNĘTRZNE. 3. Wybierz polecenie Plik tekstowy z grupy Importowanie i łączenie. 4. Znajdź plik ImportFixed.txt, wybierz go, a następnie kliknij przycisk OK. Wyświetli się pierwszy ekran Kreatora importu tekstu (zobacz rysunek 6.11). Kreator wyświetla dane z pliku tekstowego i pozwala wybrać, czy są one rozdzielone ogranicznikami, czy znajdują się w polach o stałej szerokości.
Rozdział 6. Importowanie i eksportowanie danych
207
5. Wybierz opcję Stała szerokość i kliknij przycisk Dalej. Kolejny ekran powinien teraz przypominać okno pokazane na rysunku 6.14.
Rysunek 6.14. Ekran kreatora importowania tekstu dla plików o stałej szerokości pól
6. W razie potrzeby dostosuj szerokości pól. Access automatycznie rozpoznaje najlepszy podział danych na kolumny na podstawie najbardziej spójnego podziału danych w różnych wierszach. W tym przypadku podział danych na kolumny jest bardzo klarowny. W razie potrzeby można przeciągnąć linie podziału w lewo lub prawo, aby zmienić szerokość pól w pliku. 7. Kliknij przycisk Zaawansowane w dolnej części kreatora. Pojawi się ekran Specyfikacja importu (zobacz rysunek 6.15). W oknie dialogowym Specyfikacja importu można określić format daty i godziny, nazwy pól, indeksowanie i typy danych. Ponadto możesz tu wykluczyć pola, których nie chcesz importować. Szczegółowe informacje na temat tego okna znajdziesz w następnej ramce. 8. Sprawdź, czy w polu Kolejność dat ustawiona jest opcja MDR oraz czy zaznaczono pole wyboru Rok czterocyfrowy. 9. Kliknij pole wyboru Wiodące zera w datach. 10. Kliknij przycisk OK, aby zamknąć okno dialogowe Specyfikacja importu. 11. Przejdź przez pozostałe ekrany Kreatora importu tekstu.
208
Część II Tabele Accessa
Rysunek 6.15. Ekran specyfikacji importu podczas importowania pliku tekstowego o stałej szerokości pól
Importowanie i eksportowanie dokumentów XML Importowanie dokumentów XML w Accessie jest łatwe. Ten format danych można wykorzystać do przesyłania informacji pomiędzy różnymi platformami, bazami danych, systemami operacyjnymi, aplikacjami, firmami, planetami, galaktykami — i czym tam jeszcze. XML jest standardem dla danych, metadanych (czyli opisów danych), a nawet sposobu przetwarzania tych danych. Większość programistów Accessa w pewnym momencie importuje lub eksportuje dane w formacie XML. Prezentację obsługi XML-a w Accessie przedstawimy w niestandardowy sposób. Do bazy danych Accessa można z łatwością zaimportować prosty dokument XML. Jednak najlepszym sposobem pokazania dobrej obsługi XML-a w Accessie jest rozpoczęcie prezentacji od wyeksportowania jakiegoś obiektu do formatu XML. Aby wyeksportować dane z Accessa do dokumentu XML, wykonaj następujące czynności: 1. Otwórz bazę danych Rozdział06_1.accdb. 2. Otwórz tabelę tblDepartments w widoku arkusza danych. 3. W zakładce DANE ZEWNĘTRZNE, w sekcji Eksportowanie, kliknij polecenie Plik XML. 4. Nazwij plik XML tblDepartments.xml i kliknij przycisk OK. Pojawi się okno dialogowe Eksportowanie pliku XML przedstawione na rysunku 6.16. Rysunek 6.16. Okno dialogowe Eksportowanie pliku XML
Rozdział 6. Importowanie i eksportowanie danych
209
Korzystanie z okna Specyfikacja importu Jedną z zalet tego okna dialogowego jest możliwość określenia typu pliku, z którego importujemy lub do którego eksportujemy dane. Pola Język i Strona kodowa określają typ formatu. Pole kombi Strona kodowa wyświetla opcje kodowania znaków dostępne dla wybranego języka. W przypadku plików z ogranicznikami można też określić znak oddzielający pola. W polu kombi dostępne są cztery wbudowane opcje (średnik, znak tabulacji, spacja i przecinek). W tym polu można również podać własny separator pól. W przypadku plików z ogranicznikami można także określić kwalifikator tekstu. Zwykle pola tekstowe w pliku z ogranicznikami są umieszczone między kwalifikatorami (takimi jak znaki cudzysłowu). Przydaje się to, kiedy chcemy traktować dane liczbowe (np. NIP lub numer telefonu) jako tekst, a nie jako liczbę. Lista rozwijana z kwalifikatorami jest w rzeczywistości polem kombi — można w nim wpisać własny ogranicznik. Kiedy Access importuje lub eksportuje dane, przekształca dane na określony format, taki jak RRMMDD. Możesz określić sposób konwersji pól daty, wybierając jedną z sześciu opcji w polu kombi Kolejność dat:
DMR,
DRM,
MDR,
MRD,
RDM,
RMD.
Te opcje pozwalają określić kolejność części dat. D to dzień miesiąca (od 1 do 31), M to numer miesiąca (od 1 do 12), a R to rok. Domyślnie stosowany jest amerykański format dat (miesiąc, dzień, rok). W Europie kolejność części dat to zwykle dzień, miesiąc, rok. Opcja Ogranicznik daty określa znak używany pomiędzy poszczególnymi częściami daty. Domyślnie jest to ukośnik (/), ale można określić inny ogranicznik. W Europie części daty często oddziela się kropką (.), np. 22.10.12. Podczas importowania plików tekstowych zawierających daty, między rokiem, miesiącem i dniem musi znajdować się separator. W przeciwnym razie Access zgłosi błąd, jeśli określimy typ pola jako Data/Godzina. W przypadku eksportowania pola daty separator nie jest potrzebny. Za pomocą pola Ogranicznik czasu można określić stosowany w pliku tekstowym separator między godzinami, minutami i sekundami (zwykle jest to dwukropek). Aby zmienić separator, po prostu wpisz inny znak w polu Ogranicznik czasu. Pola wyboru Rok czterocyfrowy używa się wtedy, jeśli rok w polach daty ma być sformatowany jako wartość czterocyfrowa. W przypadku zaznaczenia tego pola, można eksportować daty zawierające stulecie (takie jak 1981 lub 2001). Jest to ustawienie domyślne. Pole wyboru Wiodące zera w datach pozwala określić, że części daty mają być poprzedzone zerem. Oznacza to, że w danych w razie potrzeby dodane zostaną wiodące zera (np. 02/04/03).
210
Część II Tabele Accessa
Kreator eksportowania pliku XML umożliwia ustawienie zaawansowanych opcji procesu eksportowania do pliku XML. Jeśli klikniesz przycisk Więcej opcji, wyświetli się okno dialogowe (zobacz rysunek 6.17), w którym znajduje się kilka ważnych ustawień plików XML. Rysunek 6.17. Zaawansowane opcje eksportowania do pliku XML
Dane w pliku XML mogą mieć strukturę relacyjną lub hierarchiczną. Jeden plik XML może obejmować informacje na temat kategorii produktów, a także samych produktów. Aby inne aplikacje mogły zrozumieć skomplikowany plik XML, trzeba udostępnić plik schematu. Access automatycznie generuje takie pliki (o rozszerzeniu .xsd) dla danych eksportowanych do formatu XML. Na rysunku 6.18 pokazano zakładkę Schemat w oknie dialogowym Eksportowanie pliku XML. Rysunek 6.18. Eksportowanie informacji o schemacie pliku XML
Schemat pliku XML obejmuje m.in. informacje o typach danych poszczególnych pól, a także o kluczu głównym i indeksach źródłowej tabeli. Dodatkowym usprawnieniem procesu eksportowania do pliku XML jest możliwość określenia, jak dane w formacie XML mają być prezentowane w aplikacji używającej eksportowanych danych. Sposób prezentacji określa się za pomocą konwencji języka HTML. Zwykle plik prezentacji danych w formacie XML (ma on rozszerzenie .xsl) nie
Rozdział 6. Importowanie i eksportowanie danych
211
jest potrzebny, ponieważ aplikacje wyświetlają dane tak, jak wymagają tego użytkownicy. Na rysunku 6.19 pokazano zakładkę Prezentacja w oknie dialogowym Eksportowanie pliku XML. Zauważ, że domyślnie nie jest zaznaczona żadna opcja w tej zakładce. Rysunek 6.19. Opcje prezentacji danych w formacie XML
Otwórz plik tblDepartments.xml w edytorze tekstu, np. w Notatniku. Zobaczysz zawartość pliku XML przedstawioną na rysunku 6.20. Rysunek 6.20. Wyeksportowany plik XML zawiera zwykły tekst
W dwóch pierwszych wierszach otwartego pliku tekstowego określone są używana wersja XML-a i schemat. Eksportowane dane i ich struktura zaczynają się od trzeciego wiersza. Plik XML zawiera hierarchicznie uporządkowane znaczniki, które wyznaczają strukturę danych. Każdy element danych znajduje się między otwierającym a zamykającym znacznikiem. Rekordy zaczynają się od znacznika z nazwą tabeli. Tu do definiowania tabeli służy znacznik . Kilka wierszy dalej znajduje się znacznik zamykający, , który wyznacza koniec rekordu.
212
Część II Tabele Accessa W XML-u (podobnie jak w HTML-u) znaczniki służą do określania kontekstu dla danych. Znaczniki otwierające wyznaczają początek struktury i składają się z tekstu pomiędzy znakami mniejszości (<) i większości (>). Znaczniki zamykające określają koniec struktury. Wyglądają podobnie jak znaczniki otwierające, jednak po znaku mniejszości (<) zawierają ukośnik (/).
Pomiędzy dwoma wspomnianymi znacznikami znajdują się pola i dane rekordu. Pierwsze pole pierwszego rekordu jest zapisane jako 1000. Aplikacja, która obsługuje dane w XML-u, potraktuje ten wiersz jak pole o nazwie DeptNumber o wartości 1000. Tego rodzaju hierarchia znaczników i danych obejmuje wszystkie pola każdego rekordu tabeli. Access pozwala eksportować dane do formatu XML, a także importować je z plików XML. Aby zaimportować wyeksportowany wcześniej plik tblDepartments.xml, wykonaj następujące kroki: 1. Kliknij przycisk Plik XML w grupie Importowanie i łączenie w zakładce DANE ZEWNĘTRZNE. 2. Przejdź do pliku tblDepartments.xml i kliknij przycisk OK. W oknie dialogowym Importowanie plików XML (zobacz rysunek 6.21) zobaczysz, w jaki sposób Access interpretuje dane w formacie XML. Rysunek 6.21. Access potrafi zinterpretować dane w formacie XML
3. Kliknij przycisk OK. Access przekształca poprawne dane w formacie XML na tabelę. Znacznik określa nazwę zaimportowanej tabeli, a znaczniki między i odpowiadającym mu znacznikiem zamykającym wyznaczają pola. Dane pomiędzy znacznikami pól stają się danymi w nowej tabeli.
Importowanie i eksportowanie dokumentów HTML Access umożliwia importowanie tabel HTML równie łatwo, jak tabel pochodzących z innych baz danych, arkuszy Excela czy też plików tekstowych. Wystarczy wybrać plik HTML do zaimportowania i skorzystać z Kreatora importu HTML. Kreator ten działa identycznie, jak inne kreatory importowania opisane we wcześniejszej części tego rozdziału.
Rozdział 6. Importowanie i eksportowanie danych
213
Podobnie jak w przypadku importowania dokumentów XML pokazanego w poprzednim punkcie, proces importowania dokumentów HTML prezentujemy w odwróconej kolejności. Najpierw wyeksportujemy tabelę do postaci HTML. Następnie zaimportujemy utworzony dokument HTML w celu utworzenia nowej tabeli w Accessie. 1. Otwórz bazę danych Rozdział06_1.accdb. 2. W zakładce DANE ZEWNĘTRZNE, w sekcji Eksportowanie, kliknij przycisk Więcej, a następnie kliknij polecenie Dokument HTML. 3. W oknie dialogowym Eksportowanie — Dokument HTML wskaż docelowy dokument HTML (zobacz rysunek 6.22).
Rysunek 6.22. Okno dialogowe Eksportowanie — Dokument HTML
4. Ustaw opcje dla docelowego dokumentu HTML i kliknij przycisk OK. Eksportowanie dokumentu HTML kończy się po kliknięciu przycisku OK. Jeśli nie zaznaczyłeś pola Eksportuj dane z formatowaniem i układem, wszystkie opcje dostępne w trakcie eksportowania takich dokumentów są widoczne na rysunku 6.22. Przy eksportowaniu danych z formatowaniem i układem (ustawienie to można wybrać w oknie dialogowym Eksportowanie — Dokument HTML) dostępne są dodatkowe opcje. Najważniejsza z nich wymaga określenia używanego w trakcie eksportowania szablonu HTML-a. Szablon HTML-a to zwykły plik HTML, który jednak zawiera specjalne znaczniki rozpoznawalne w Accessie. Znaczniki te informują Accessa, gdzie ma umieścić określone dane w trakcie eksportowania. Można dzięki temu zdefiniować pewne aspekty dokumentu HTML, np. styl i logo.
214
Część II Tabele Accessa
W procesie importowania dokumentów HTML dane są przekazywane do Accessa w sposób podobny jak dane z pliku tekstowego. Kreator importu HTML udostępnia niemal te same ekrany i opcje co kreator importu tekstu. Pozwala na przykład zdefiniować typy danych pól i określić klucz główny.
Importowanie obiektów Accessa innych niż tabele Oprócz tabel z innej bazy danych Accessa można importować również inne obiekty. Tak więc z innej bazy danych Accessa można zaimportować tabelę, kwerendę, formularz, raport, makro lub moduł. Można również zaimportować własne paski narzędzi i menu. Aby obejrzeć te możliwości, wykonaj następujące operacje: 1. Otwórz bazę danych Rozdział06_1.accdb. 2. W zakładce DANE ZEWNĘTRZNE, w sekcji Importowanie, kliknij opcję Access, aby importować obiekty z innej bazy danych Accessa. Pojawi się ekran widoczny na rysunku 6.23. Zauważ, że w oknie tym można wybrać importowanie obiektów bazy danych i dołączanie tabel z zewnętrznej bazy Accessa.
Rysunek 6.23. Ten sam kreator służy do importowania obiektów i dołączania zewnętrznych tabel Accessa
3. Wskaż bazę danych Rozdział06_2.accdb, a następnie kliknij OK. Na rysunku 6.24 widać, że można importować wszystkie typy obiektów Accessa.
Rozdział 6. Importowanie i eksportowanie danych
215
Rysunek 6.24. Importowanie obiektów Accessa
W przypadku importowania tabel, kwerend, formularzy, raportów, makr i modułów w jednej operacji można wybrać obiekty z każdej grupy, a następnie zaimportować wszystkie naraz. Na rysunku 6.24 widoczne jest okno dialogowe Importowanie obiektów, w którym kliknięto przycisk Opcje. Dostępne tu opcje umożliwiają importowanie relacji, menu, pasków narzędzi i innych obiektów baz danych Accessa. Importowanie (jak również eksportowanie) to doskonały sposób, by utworzyć kopię zapasową obiektów przed wprowadzeniem w nich zmian.
Importowanie folderu Outlooka Ciekawą funkcją Accessa w zakresie importowania jest możliwość pobierania danych bezpośrednio z aplikacji Microsoft Outlook. Choć większość osób uważa Outlooka za klienta poczty elektronicznej, aplikacja ta obsługuje liczne ważne zadania biznesowe, takie jak planowane wykonywanie operacji i zarządzanie kontaktami. W trakcie pracy z danymi z Outlooka w Accessie nie ma znaczenia, czy importowany obiekt to wiadomość czy dane kontaktowe. Access bez problemów obsługuje wszystkie rodzaje obiektów Outlooka. Wybierz opcję Folder programu Outlook z listy rozwijanej Więcej w grupie Importowanie i łączenie. Pojawi się okno dialogowe Folder programu Outlook (zobacz rysunek 6.25). Access umożliwia zaimportowanie danych z Outlooka, dodanie ich do istniejącej tabeli Accessa oraz dołączenie do bieżącej bazy. Jeśli wybierzesz opcję importowania, pojawi się Kreator importu z programów Exchange/ Outlook (zobacz rysunek 6.26). Jak pokazano w poniższym oknie dialogowym, Access potrafi importować wiadomości, dane kontaktowe, kalendarze, dzienniki i inne foldery.
216
Część II Tabele Accessa
Rysunek 6.25. Początkowe opcje importowania danych z Outlooka
Rysunek 6.26. Importowanie obiektów Outlooka do Accessa
Rozdział 6. Importowanie i eksportowanie danych
217
Dalsze ekrany kreatora pozwalają przejść przez proces przenoszenia danych z Outlooka do Accessa i zależą od obiektów wybranych w kreatorze. Dane z Outlooka można zaimportować do nowej lub istniejącej tabeli. Można też dodać klucz główny, określić typy danych, a także zapisać proces importowania w celu jego późniejszego uruchomienia.
Eksportowanie do formatów zewnętrznych W wyniku operacji eksportowania dane są kopiowane z tabeli Accessa do formatu innego programu lub źródła danych, na przykład dokumentu XML. Wyeksportowane dane mają format innego źródła danych, a nie bazy danych Accessa. Dane z tabeli lub kwerendy Accessa można skopiować do zewnętrznego pliku. Istnieje możliwość eksportowania tabel do kilku zewnętrznych formatów. Ogólnie rzecz biorąc, wszystko co zostało zaimportowane, można również wyeksportować, o ile nie występują inne przesłanki wskazane w tym rozdziale.
Eksportowanie obiektów do innych baz danych Accessa Można wyeksportować obiekty z bieżącej bazy danych do innej bazy danych Accessa. Możesz eksportować tabele, kwerendy, formularze, raporty itd. Wprawdzie zaimportować można jednocześnie wiele obiektów, ale wyeksportować można tylko jeden obiekt. Aby wyeksportować obiekt do innej bazy danych Accessa, wykonaj poniższe czynności: 4. Otwórz źródłową bazę danych i wybierz obiekt, który chcesz wyeksportować. 5. Kliknij przycisk Access z grupy Eksportowanie w zakładce DANE ZEWNĘTRZNE. Pojawi się okno dialogowe Eksportowanie — Baza danych programu Access. 6. Należy posłużyć się przyciskiem Przeglądaj, aby wskazać docelową bazę danych Accessa. Docelowa baza danych nie może być otwarta przy próbie eksportu. Gdyby tak było, wystąpiłby konflikt blokowania dostępu.
7. Kliknij przycisk OK. Rozpocznie się proces eksportowania. Tabele można eksportować jako wyłącznie dane lub jako dane i metadane.
Jeśli obiekt istniał wcześniej w docelowej bazie danych, wyświetli się pytanie o to, czy należy go zastąpić. Jeżeli nie chcesz go zastępować, utwórz nowy obiekt w docelowej bazie danych.
218
Część II Tabele Accessa
8. Ostatni krok umożliwia zapisanie konfiguracji eksportu do późniejszego wykorzystania. Opcja ta może się przydać, jeśli często wykonujemy tę samą operację eksportu. Przy próbie wyeksportowania obiektu do innej bazy danych Accessa, w której wcześniej znajdował się obiekt tego samego typu i o tej samej nazwie, Access przed skopiowaniem wyświetli ostrzeżenie. Użytkownik może anulować operację lub nadpisać istniejący obiekt.
Eksportowanie do programu Word Access udostępnia dwa sposoby przesyłania danych do Worda — eksportowanie do formatu RTF i korespondencję seryjną w programie Word. Plik RTF to plik ze zwykłym tekstem zawierającym znaki specjalne, które określają formatowanie. Eksportowanie do formatu RTF prowadzi do powstania pliku o rozszerzeniu .rtf, a nie standardowego dokumentu Worda. Jednak Word (podobnie jak WordPad i wiele innych edytorów tekstu) potrafi wczytywać pliki RTF. Korespondencja seryjna w programie Word Prawdziwa wartość eksportowania do Worda związana jest z korespondencją seryjną w tym programie. Mechanizm ten pozwala kontrolować, w którym miejscu w dokumencie Worda znajdą się dane z bazy. Jest to przydatne przy wysyłaniu listów, adresowaniu kopert, generowaniu raportów i tworzeniu etykiet na teczki. Aby utworzyć etykiety dla każdego działu z tabeli tblDepartments, wykonaj następujące czynności: 1. Otwórz tabelę tblDepartments w widoku arkusza danych. 2. Kliknij przycisk Korespondencja seryjna w programie Word w grupie Eksportowanie w zakładce DANE ZEWNĘTRZNE. 3. Na pierwszym ekranie kreatora korespondencji seryjnej w programie Word (zobacz rysunek 6.27) wybierz opcję Chcę, aby utworzył nowy dokument i połączył z nim dane, a następnie kliknij przycisk OK. W Wordzie otworzy się nowy dokument, a w prawym panelu pojawi się okienko zadań związanych z korespondencją seryjną. Rysunek 6.27. Kreator korespondencji seryjnej Microsoft Word umożliwia eksportowanie danych do istniejących lub nowych dokumentów
Rozdział 6. Importowanie i eksportowanie danych
219
4. W kreatorze korespondencji seryjnej wybierz etykiety jako typ dokumentu. Na trzecim etapie pracy kreatora Word domyślnie wybiera tblDepartments jako źródło danych. 5. Rozmieść pola DeptNumber i DeptDescription na szablonie etykiety, a następnie zakończ pracę kreatora. Na rysunku 6.28 widoczne są wyniki działania kreatora. Numery i opisy działów są tu rozdzielone myślnikiem. Rysunek 6.28. Gotowy szablon korespondencji seryjnej w programie Word
Aby zaimportować dane z Worda do Accessa, najpierw należy przekształcić dokument Worda na plik tekstowy. Można też zastosować Worda w połączeniu z Excelem, aby uzyskać plik tekstowy z ogranicznikami.
Publikowanie w formacie PDF lub XPS Formaty PDF i XPS opracowano z myślą o wyświetlaniu danych w postaci, w jakiej pojawią się na wydrukowanej stronie. Danych wyświetlanych w tych formatach zwykle nie można edytować. Publikowanie w formacie PDF lub XPS prowadzi do powstania stosunkowo niewielkich plików. Technika ta jest przydatna, gdy programista chce udostępniać dane, ale nie chce umożliwiać innym ich edycji. Aby wyeksportować tabelę tblEmployees w formacie PDF, wykonaj następujące czynności: 1. Zaznacz tabelę tblEmployees w okienku nawigacji. 2. Wybierz opcję PDF lub XPS w grupie Eksportowanie w zakładce DANE ZEWNĘTRZNE na wstążce. Pojawi się okno dialogowe Publikowanie jako pliku PDF lub XPS. 3. Na liście rozwijanej Zapisz jako typ wybierz opcję Plik PDF (zobacz rysunek 6.29). 4. Kliknij przycisk Publikuj. Efekt przedstawiono na rysunku 6.30. Widoczny jest tu plik PDF, który można otworzyć w różnych czytnikach plików w tym formacie. Takie czytniki są zainstalowane w większości komputerów, dlatego PDF to doskonały format do udostępniania danych, które nie mają być modyfikowane.
220
Część II Tabele Accessa
Rysunek 6.29. Wybierz PDF lub XPS jako format pliku
Rysunek 6.30. Tabela opublikowana w formacie PDF
Rozdział 7.
Dołączanie danych zewnętrznych W tym rozdziale:
Przegląd typów danych zewnętrznych i metod pracy z nimi
Łączenie baz Accessa z danymi zewnętrznymi
Używanie połączonych tabel
Rozdzielanie baz danych Accessa
W rozdziale 6. poznałeś typy danych zewnętrznych, które można importować do Accessa i eksportować z tego programu. Dowiedziałeś się też, kiedy należy importować i eksportować dane, a kiedy lepiej się z nimi łączyć. W tym rozdziale poznasz techniki używania danych zewnętrznych Accessa za pomocą aktywnego połączenia z danymi. W tym rozdziale będziemy korzystać z bazy danych o nazwie Rozdział16.accdb, a także kilku innych plików, które posłużą do łączenia. Jeżeli ktoś jeszcze nie skopiował ich do swojego komputera, powinien zrobić to teraz.
Ponieważ w rozdziale tym pokazujemy, jak Access obsługuje dane zewnętrzne, wykorzystujemy tu przykładowe dane tego rodzaju, które należy skopiować do komputera. Niestety, w trakcie korzystania z danych zewnętrznych w Accessie trzeba podać dokładną ścieżkę do każdego pliku. Ścieżki względne nie są obsługiwane. Oznacza to, że skopiowany do komputera plik Rozdział07.accdb nie będzie działał dopóty, dopóki nie połączysz z nim różnych plików zewnętrznych. Z rozdziału tego dowiesz się, jak to zrobić. Poniżej opisano, z którymi plikami połączone są poszczególne tabele. Tabela ContactsFixed Customers CustomerTypes Products tblSales tblSalesLineItems tblSalesPayments
Typ zewnętrznego pliku Plik tekstowy Excel HTML Excel 8.0 Access Excel 8.0 Access
Nazwy plików ContactsFixed.txt CollectibleMiniCars.xls CustomerTypes.html CollectibleMiniCars.xls Rozdział07_łącze.accdb tblSalesLineItems.xls Rozdział07_łącze.accdb
222
Część II Tabele Accessa
Naprawianie łączy Szczegółowe omówienie menedżera łączenia tabel znajdziesz w dalszej części rozdziału. Na razie zapoznaj się z sześcioma poniższymi krokami, które pozwolą naprawić połączone tabele z bazy Rozdział07.accdb: 1. Skopiuj katalog Rozdział07 do komputera i zapamiętaj ścieżkę do tego katalogu. 2. Otwórz plik Rozdział07.accdb. 3. Kliknij przycisk Menedżer tabel połączonych w grupie Importowanie i łączenie w zakładce DANE ZEWNĘTRZNE na wstążce. Otworzy się menedżer tabel połączonych. 4. Kliknij przycisk Zaznacz wszystkie, a następnie kliknij OK. Access wyświetli pytanie o nową lokalizację każdej z tabel połączonych. 5. Na podstawie tabeli z nazwami przedstawionej we wcześniejszej części rozdziału przejdź do odpowiednich plików. Menedżer tabel połączonych wyświetli komunikat, że wszystkie tabele zostały poprawnie odświeżone. Teraz możesz swobodnie wykonywać przykłady z tego rozdziału.
Dane dołączone do aplikacji Accessa lub do nich zaimportowane mogą mieć różne formaty. Praktycznie nie ma sposobu, aby w jednym rozdziale udokumentować wszystkie możliwe typy operacji łączenia. Z tego względu w tym rozdziale zamiast zapełniać wiele stron przykładami, które niekoniecznie mogą być przydatne do pracy, opisano najważniejsze czynności wymagane do łączenia danych zewnętrznych i poparto je kilkoma przykładami pokazującymi sposoby wykonywania tych procesów w Accessie. Jak się wkrótce przekonasz, wiedza na temat zewnętrznych formatów danych ma kluczowe znaczenie do skutecznego wykonywania operacji łączenia. Skuteczne importowanie danych do aplikacji Accessa lub korzystanie z danych za pomocą łączenia wymaga posiadania pewnej wiedzy na temat zewnętrznych formatów danych. W tym rozdziale zwrócono uwagę na wiele spraw dotyczących łączenia zewnętrznych danych. Ma to być przewodnik dotyczący wykonywania tych operacji w aplikacjach Accessa.
Dołączanie danych zewnętrznych W miarę rozwoju rynku baz danych potrzeba uzyskiwania informacji z różnorodnych źródeł będzie stale rosła. Jeśli mamy informacje zapisane w tabeli serwera SQL Server albo w starym arkuszu Excela, przepisywanie ich do Accessa mijałoby się z celem. Byłoby najlepiej, gdyby można było otworzyć tabelę Accessa i używać informacji w ich rodzimym formacie, bez przepisywania ich albo pisania programu tłumaczącego. W wielu współczesnych firmach możliwość dostępu do informacji z jednej bazy danych podczas pracy z drugą ma kluczowe znaczenie dla wielu projektów. Kopiowanie lub tłumaczenie danych z formatu jednej aplikacji na format drugiej za pomocą kodu jest czasochłonne i kosztowne. Ilość poświęconego na to czasu może stanowić o sukcesie lub porażce. Potrzebna jest więc platforma wymiany danych pomiędzy różnymi źródłami danych w środowisku.
Rozdział 7. Dołączanie danych zewnętrznych
223
Access potrafi jednocześnie połączyć się z wieloma tabelami zapisanymi w innych systemach baz danych. Po dołączeniu zewnętrznego pliku Access zachowuje parametry łącza i korzysta z danych zewnętrznych tak, jakby były zapisane w lokalnej tabeli. Access z łatwością może łączyć się z tabelami innych baz Accessa, a także z tabelami innych baz danych takich jak dBASE i FoxPro. Powszechną praktyką jest również rozdzielenie bazy danych Accessa na oddzielne bazy, w celu ułatwienia używania jej w środowisku wielodostępnym albo typu klient-serwer.
Identyfikowanie tabel połączonych W punkcie „Metody pracy z danymi zewnętrznymi” w rozdziale 6. podaliśmy listę tabel baz danych oraz innych typów plików, z którymi Access może się łączyć. Access wyświetla nazwy tabel połączonych na liście obiektów, ale wykorzystuje specjalną ikonę, która oznacza, że określona tabela jest połączona, a nie lokalna. Strzałka skierowana na ikonę wskazuje na to, że nazwa tabeli reprezentuje dołączone źródło danych. Na rysunku 7.1 pokazano listę zawierającą kilka tabel połączonych. Ikona oznacza, że plik jest dołączony. Określa też typ pliku dołączonego do bieżącej bazy danych Accessa. Na przykład X wskazuje na plik Excela, a symbol kuli ziemskiej — na tabelę z dokumentu HTML. Rysunek 7.1. Tabele połączone w bazie danych Accessa. Warto zwrócić uwagę, że każdej tabeli połączonej towarzyszy ikona określająca jej status jako tabeli połączonej
Po dołączeniu tabeli z zewnątrznej bazy danych do bazy Accessa, można traktować ją tak jak każdą inną tabelę. Na przykład na rysunku 7.2 pokazano kwerendę zaprojektowaną z wykorzystaniem kilku tabel połączonych: tblCustomers (lokalna tabela Accessa), tblSales (tabela połączona Accessa), tblSalesLineItems (z pliku Excela) oraz xlsProducts (inny plik Excela). Jak widać, tabele ze źródeł zewnętrznych niczym się nie wyróżniają. Access traktuje je tak jak zwykłe tabele. Kwerenda ta pokazuje potencjalne korzyści z dołączania źródeł danych różnego typu oraz bezproblemowe wyświetlanie danych zarówno z tabel wewnętrznych, jak i połączonych. Arkusz danych zwrócony przez pokazaną kwerendę można zobaczyć na rysunku 7.3. Każda kolumna w tym arkuszu danych pochodzi z innego dołączonego źródła danych.
224
Część II Tabele Accessa
Rysunek 7.2. Kwerenda zaprojektowana z wykorzystaniem zewnętrznych tabel połączonych
Rysunek 7.3. Dołączone dane zewnętrzne w widoku arkusza danych
Na rysunku 7.3 pokazano ważne zagadnienie dotyczące używania dołączonych danych w Accessie. Użytkownicy nie wiedzą, gdzie znajdują się dane, i w większości przypadków ich to nie interesuje. Chcą jedynie móc przeglądać dane w formacie, jakiego się spodziewają. Tylko programista musi brać pod uwagę problemy związane z dostarczeniem danych do interfejsu użytkownika. Z dołączonymi danymi wiążą się pewne ograniczenia (omówiono je w dalszym punkcie). Jednak ogólnie rzecz biorąc użytkownicy nie będą w stanie odróżnić danych rodzimych od dołączonych.
Rozdział 7. Dołączanie danych zewnętrznych
225
Tabeli zewnętrznej dołączonej do bazy danych Accessa nie można przenieść na inny dysk lub do innego katalogu. Access w rzeczywistości nie dołącza zewnętrznej tabeli do pliku .accdb, lecz zapisuje informacje o łączu w postaci nazwy pliku i ścieżki do niego. Po przeniesieniu zewnętrznej tabeli trzeba zaktualizować łącze za pomocą Menedżera tabel połączonych, o którym będzie mowa w punkcie „Przeglądanie lub zmienianie informacji o tabelach połączonych” w dalszej części tego rozdziału.
Ograniczenia dotyczące dołączonych danych Chociaż w tym rozdziale opisano używanie dołączonych danych w taki sposób, jakby były rodzimymi tabelami Accessa, dołączone dane nie pozwalają na wykonywanie pewnych operacji. Co więcej, niedozwolone operacje w pewnym stopniu zależą od typu danych dołączonych do Accessa. Ograniczenia te są dość zrozumiałe. Dołączone dane nigdy nie są „własnością” Accessa. Pliki zewnętrzne dołączone do Accessa są zarządzane przez ich macierzyste aplikacje. Na przykład arkuszami Excela zarządza Microsoft Excel. Dowolne modyfikowanie danych w arkuszu Excela przez Access byłoby niebezpieczne. Jak wiadomo, wiele operacji Excela bazuje na relatywnym położeniu względem siebie wierszy i kolumn. W związku z tym wstawienie wiersza do arkusza mogłoby przyczynić się do wypaczenia wyników obliczeń oraz innych operacji na danych wykonywanych w Excelu. Usunięcie wiersza może naruszyć granice zakresu komórek zdefiniowanego w arkuszu Excela i spowodować podobne problemy. Ponieważ nie ma możliwości, aby Access potrafił wykonać wszystkie operacje na zewnętrznych danych w sposób identyczny do stosowanego w ich rodzimych aplikacjach, firma Microsoft przyjęła bardzo konserwatywny kierunek i nie zezwala na modyfikowanie w Accessie danych zewnętrznych, jeśli taka operacja może powodować problemy w ich rodzimych aplikacjach. Ograniczenia dotyczące dołączonych danych opisano na poniższej liście:
Dane Accessa — nie ma ograniczeń dotyczących operacji na danych z tabel połączonych. Nie można jednak usunąć źródłowej tabeli ani zmienić jej nazwy. Niedozwolone jest też modyfikowanie pól i typów danych w źródłowej tabeli.
Dane Excela — nie można modyfikować istniejących danych w arkuszach Excela. Nie można również usuwać wierszy ani dodawać nowych wierszy do arkusza. Dane Excela użyte w Accessie do dowolnych celów są interpretowane jako informacje tylko do odczytu.
Pliki tekstowe — we wszystkich praktycznych zastosowaniach dane powiązane z plikami tekstowymi w Accessie są interpretowane jako dane tylko do odczytu. Chociaż można użyć tych danych w formularzach i raportach, nie można w prosty i łatwy sposób aktualizować wierszy w dołączonym pliku tekstowym. Nie można również usuwać wierszy z takich plików. O dziwo, można jednak wprowadzać nowe wiersze. Najprawdopodobniej przyczyną tego jest fakt, iż wprowadzanie nowych wierszy nie narusza istniejących operacji w sposób, w jaki jest to możliwe w przypadku usunięcia wiersza lub modyfikacji jego zawartości.
HTML — są traktowane dokładnie tak jak dane Excela. Nie można modyfikować, usuwać lub wprowadzać nowych wierszy do tabeli HTML.
226
Część II Tabele Accessa
Kontakty w Outlooku — można je wyświetlać w formularzach i raportach Accessa, jednak danych tego rodzaju nie można dodawać, usuwać ani modyfikować.
ODBC — jest to technologia dostępu do danych, w której wykorzystuje się sterownik pomiędzy bazą danych Accessa a zewnętrznym plikiem bazy danych, np. Microsoft SQL Server lub Oracle. W tym przypadku dołączone źródło danych również jest tabelą bazy danych, zatem można w niej wykonywać operacje typowe dla bazy danych (modyfikowanie, usuwanie, dodawanie), podobnie jak dla rodzimych tabel Accessa, przy czym w tabeli Accessa zdefiniowany musi być indeks. Tabele baz danych ODBC opisujemy szczegółowo w punkcie „Łączenie ze źródłami danych ODBC” w dalszej części tego rozdziału.
Dołączanie tabel z innych baz danych Accessa Za pomocą techniki dołączania w Accessie można z łatwością wykorzystać dane umieszczone w innych plikach Accessa. Dzięki temu dane Accessa można bez trudu współdzielić pomiędzy aplikacjami Accessa w sieci lub komputerze lokalnym. Informacje zaprezentowane w tym punkcie dotyczą niemal każdego dołączanego pliku danych w bazie danych Accessa. W dalszej części tego rozdziału znajdują się krótkie punkty objaśniające różnice pomiędzy łączeniem tabel Accessa a łączeniem z innymi typami plików danych rozpoznawanych przez Accessa. Bardzo powszechną praktyką wśród programistów Accessa jest podział bazy danych Accessa na dwie części. Jedna część zawiera formularze, raporty i inne komponenty interfejsu użytkownika aplikacji, natomiast druga zawiera tabele, kwerendy i inne elementy danych. Podział baz danych Accessa ma wiele zalet. Pozwala na poprawę wydajności, a także zapewnia łatwiejsze utrzymanie. O podziale baz danych Accessa można przeczytać w dalszej części rozdziału. Proces łączenia z zewnętrznymi tabelami Accessa opisany w tym punkcie stanowi istotną część operacji podziału bazy danych.
Po dołączeniu tabeli z innego pliku Accessa można się nią posługiwać niemal tak samo jak innymi tabelami w otwartej bazie danych (różnica polega na tym, że tabel połączonych nie można używać w relacjach z tabelami, które nie występują w źródłowej bazie danych). Aby dołączyć tabelę tblSalesPayments z bazy danych Rozdział07_Łącze.accdb do bazy danych Rozdział07.accdb, wykonaj następujące czynności: 1. Otwórz bazę danych Rozdział07.accdb. 2. Zaznacz zakładkę DANE ZEWNĘTRZNE na wstążce. Następnie wybierz Accessa jako typ dołączanych danych. Pojawi się okno dialogowe Pobieranie danych zewnętrznych, które pokazano na rysunku 7.4. 3. Kliknij przycisk Przeglądaj. Otworzy się windowsowe okno dialogowe Otwieranie pliku. 4. Znajdź plik Rozdział07_Łącze i kliknij przycisk Otwórz. Okno Otwieranie pliku zamknie się i powrócisz do okna dialogowego Pobieranie danych zewnętrznych. 5. Zaznacz przycisk opcji związany z łączeniem i kliknij przycisk OK. Okno dialogowe Łączenie tabel pozwala na wybór jednej lub kilku tabel z wybranej bazy danych (w tym przypadku Rozdział07_Łącze). Otwarte okno dialogowe Łączenie tabel dla bazy danych Rozdział07_Łącze.accdb pokazano na rysunku 7.5.
Rozdział 7. Dołączanie danych zewnętrznych
227
Rysunek 7.4. W oknie dialogowym Pobieranie danych zewnętrznych można wybrać typ operacji wykonywanych na zewnętrznych źródłach danych Rysunek 7.5. Okno dialogowe Łączenie tabel umożliwia wybór tabel Accessa, które mają być połączone
6. Zaznacz tabelę tblSalesPayments i kliknij OK. Dwukrotne kliknięcie nazwy tabeli nie powoduje jej wybrania — trzeba zaznaczyć tabelę, a następnie kliknąć OK.
228
Część II Tabele Accessa
Po dołączeniu tabeli tblSalesPayments, Access powraca do listy obiektów i wyświetla na niej połączoną przed chwilą tabelę. Na rysunku 7.6 pokazano tabelę tblSalesPayments dołączoną do bieżącej bazy danych. Zwróćmy uwagę na specjalną ikonę obok tabeli tblSalesPayments. Ikona ta wskazuje, że tabela jest połączona z zewnętrznym źródłem danych. Wskazanie tabeli połączonej myszą powoduje wyświetlenie zewnętrznego źródła danych tabeli. Rysunek 7.6. Okienko nawigacji po dodaniu tabeli tblSalesPayments. Zwróćmy uwagę na ikonę, która wskazuje na to, że jest to tabela połączona
W jednej operacji można dołączyć więcej niż jedną tabelę. W tym celu, przed kliknięciem przycisku OK, należy zaznaczyć wiele tabel w oknie dialogowym Łączenie tabel. Kliknięcie przycisku Zaznacz wszystkie powoduje zaznaczenie wszystkich tabel. Po wybraniu wszystkich tabel można kliknąć dowolną z nich, aby ją wykluczyć.
Łączenie ze źródłami danych ODBC Jednym z elementów, które spowodowały znaczny postęp w zakresie współdzielenia danych, było stworzenie interfejsu ODBC (ang. Open Database Connectivity) przez firmę Microsoft i innych dostawców baz danych. ODBC jest specyfikacją używaną przez producentów oprogramowania do tworzenia sterowników dla baz danych. Specyfikacja ta umożliwia działanie aplikacji Accessa w standardowy sposób dla różnych platform baz danych. Aplikacja napisana zgodnie ze specyfikacją ODBC może korzystać na zapleczu z dowolnej bazy danych zgodnej z ODBC. Załóżmy na przykład, że tworzymy aplikację Accessa, która na zapleczu ma wykorzystywać bazę danych systemu SQL Server. Najczęściej stosowanym sposobem tworzenia takich rozwiązań jest wykorzystanie sterownika ODBC systemu SQL Server. Po stworzeniu aplikacji dowiadujemy się, że jedna z filii naszej firmy chce korzystać z aplikacji, ale z wykorzystaniem Oracle jako serwera bazy danych. Jeśli w aplikacji ściśle stosowaliśmy się do składni ODBC, wykorzystanie naszej aplikacji z bazą danych Oracle
Rozdział 7. Dołączanie danych zewnętrznych
229
wymaga jedynie zakupu sterownika ODBC do bazy danych Oracle. Sterowniki te są dostarczane nie tylko przez producentów baz danych dla ich własnych produktów. Są również firmy, które specjalizują się wyłącznie w tworzeniu sterowników ODBC. Łączenie się ze źródłami danych przez interfejs ODBC opisano szczegółowo w rozdziale 29. Dowiesz się z niego, jak konfigurować źródła danych zgodne z tym interfejsem i jak je dołączać. Choć w rozdziale 29. jako przykład wykorzystano bazę SQL Server, te same reguły dotyczą wszystkich źródeł danych zgodnych z ODBC.
Dołączanie danych, które nie są bazami Można również dołączać dane które nie są bazami, takie jak arkusze Excela, tabele HTML i pliki tekstowe. Kiedy wybierzemy jeden spośród tych typów jako źródło danych, Access uruchomi kreator łączenia, który pomoże w wykonaniu tego zadania. Dołączanie plików Excela Podczas dołączania danych Excela należy zwrócić uwagę na kilka elementów:
Skoroszyt .xls Excela może zawierać wiele arkuszy. W obrębie skoroszytu należy wskazać arkusz, który ma być dołączony (można też wykorzystać zakresy ze zdefiniowaną nazwą).
W obrębie arkusza Excela można dołączać indywidualne zakresy ze zdefiniowaną nazwą. Każdy zakres odpowiada odrębnej tabeli połączonej w Accessie.
W kolumnach Excela mogą być zapisane dane dowolnego typu. Fakt pomyślnego dołączenia arkusza Excela nie oznacza, że aplikacja może korzystać ze wszystkich danych zapisanych w arkuszu Excela. Ponieważ Excel nie wprowadza ograniczeń co do typu danych zapisanych w skoroszycie, może się zdarzyć, że aplikacja napotka na wiele typów danych w pojedynczej kolumnie dołączonego arkusza Excela. Oznacza to, że czasami trzeba zdefiniować kod lub zastosować inne sposoby obejścia problemu różnych typów danych w arkuszu Excela. W plikach dołączonych do tej książki znajduje się arkusz Excela utworzony poprzez wyeksportowanie tabeli tblProducts z aplikacji MiniAuta dla Kolekcjonerów. Plik ten można wykorzystać do ćwiczeń w importowaniu danych Excela. Należy pamiętać, że dane, jakie można spotkać w arkuszach Excela, mogą być znacznie bardziej złożone i gorzej uporządkowane niż te zapisane w pliku Products.xls.
Aby dołączyć arkusz kalkulacyjny Excela o nazwie Products.xls, wykonaj następujące czynności: 1. W bazie danych Rozdział07.accdb wybierz przycisk Excel w zakładce DANE ZEWNĘTRZNE. Pojawi się okno dialogowe Pobieranie danych zewnętrznych (zobacz rysunek 7.7). 2. Zaznacz opcję Połącz ze źródłem danych, tworząc tabelę połączoną i kliknij przycisk Przeglądaj. To samo okno dialogowe Pobieranie danych zewnętrznych wykorzystuje się zarówno do operacji importowania, jak i dołączania. Z tego powodu, przed przejściem do dalszych działań, należy się upewnić, czy wybrano właściwą operację.
230
Część II Tabele Accessa
Rysunek 7.7. Pierwszy ekran w oknie dialogowym Pobieranie danych zewnętrznych — Arkusz kalkulacyjny programu Excel Importowanie danych do Accessa omówiono w rozdziale 17.
3. Kliknij przycisk Przeglądaj widoczny na prawo od pola z nazwą pliku. Pojawi się okno dialogowe Otwieranie pliku. 4. Odszukaj i otwórz plik Excela. Po wybraniu pliku powracamy do Kreatora łączenia arkuszy (zobacz rysunek 7.8). Zwróć uwagę, że okno dialogowe Kreator łączenia arkuszy zawiera opcje umożliwiające wybór z pliku skoroszytu arkuszy lub zakresów identyfikowanych przez nazwę. W tym przykładzie w pliku skoroszytu są trzy różne arkusze (o nazwach Produkty, Transakcje i Klienci). 5. Dla potrzeb tego przykładu wybierz arkusz Produkty. Kreator łączenia arkuszy przeprowadzi Cię przez kilka ekranów, na których należy określić różne informacje, na przykład zaznaczyć opcję Pierwszy wiersz zawiera nagłówki kolumn oraz określić typ danych używany dla poszczególnych kolumn arkusza Excela. Na ostatnim ekranie Kreatora łączenia arkuszy wyświetla się nazwa nowo dołączonej tabeli. 6. Kliknij przycisk Zakończ. Tabela połączona tworzy się po powrocie do środowiska Accessa. Tak jak w przypadku licznych innych elementów dotyczących projektowania baz danych wiele decyzji związanych z dołączaniem zewnętrznych źródeł danych wynika ze sposobu korzystania z danych w aplikacji. Bezpośredni wpływ na aplikację mają również nazwy wykorzystywane dla pól oraz inne szczegóły.
Rozdział 7. Dołączanie danych zewnętrznych
231
Rysunek 7.8. Główny ekran kreatora łączenia arkuszy
Dołączanie plików HTML Dołączanie danych zapisanych w dokumentach HTML nie zostało szczegółowo opisane w tej książce z powodu poważnych ograniczeń nakładanych na ten proces przez Accessa. Na przykład Access nie potrafi pobierać danych z plików HTML o dowolnej strukturze. Dane muszą być zaprezentowane w postaci tabeli HTML w formacie wierszy i kolumn, a ponadto muszą być stosunkowo jednorodne (pozbawione niestandardowych danych lub ich kombinacji, takich jak tekst, grafika i dane numeryczne w jednej tabeli HTML). Jeśli na stronie występuje więcej niż jedna tabela lub jeśli dane są zaprezentowane w sposób hierarchiczny (dane nadrzędne i podrzędne), mogą wystąpić problemy z importem. Biorąc pod uwagę wszystkie te elementy, dołączanie tabel HTML o dowolnej strukturze jest, w najlepszym przypadku, działaniem o niepewnym skutku. Znacznie łatwiej dołączyć dokument HTML specjalnie przygotowany jako źródło danych dla aplikacji Accessa, niż próbować pracy z dowolnymi plikami HTML.
Co więcej, jeśli ktoś może zadać sobie trud związany z przygotowaniem specjalizowanych dokumentów HTML do wykorzystania w roli źródeł danych Accessa, równie dobrze może przygotować wygodniejsze w użyciu pliki z wartościami rozdzielanymi przecinkami (ang. Comma Separated Values — CSV) lub pliki zawierające dane tekstowe o stałej szerokości. Pliki w formacie CSV, w których pola w każdym wierszu są rozdzielane przecinkami, są bardzo popularnym sposobem przenoszenia danych pomiędzy aplikacjami. Pliki CSV oraz pliki tekstowe o polach stałej długości omówiono w następnym podrozdziale. Jeśli pominąć wspomniane uwagi, proces dołączania danych HTML jest bardzo podobny do dołączania arkuszy Excela.
232
Część II Tabele Accessa
1. Należy wybrać przycisk rozwijanej listy Więcej na zakładce DANE ZEWNĘTRZNE i wybrać z listy pozycję Dokument HTML. Spowoduje to otwarcie okna dialogowego Pobieranie danych zewnętrznych — Dokument HTML. 2. Zaznacz opcję Połącz ze źródłem danych, tworząc tabelę połączoną i kliknij przycisk Przeglądaj. Wyświetli się okno dialogowe Otwieranie pliku, w którym można wyszukać dokument HTML do połączenia. Od tego miejsca proces dołączania danych w formacie HTML przebiega podobnie jak dołączanie innych plików z danymi. Należy podać m.in. nazwy pól i inne informacje na temat dołączanych danych. Na rysunku 7.9 pokazano pierwszy ekran kreatora importowania plików HTML. Kliknij przycisk Zaawansowane w lewym dolnym rogu, aby przejść do ekranu Specyfikacja łącza (zobacz rysunek 7.10), gdzie można podać nazwy pól i inne szczegółowe dane.
Rysunek 7.9. Kreator importu HTML wyświetla dane z pliku HTML W plikach dołączonych do tej książki znajduje się bardzo prosty dokument HTML o nazwie CustomerTypes.html. Dane w tym pliku są być może przesadnie uproszczone, ale korzystając z niego, można przećwiczyć dołączanie dokumentów HTML. Ze względu na różnorodny sposób zapisywania danych w dokumentach HTML nie ma możliwości uogólnienia sposobu dołączania danych HTML. Wystarczy jednak nabrać wprawy w dołączaniu zewnętrznych źródeł danych, aby dołączanie dokumentów HTML stało się cennym uzupełnieniem umiejętności programowania w Accessie.
Dołączanie plików tekstowych Znacznie częstszą sytuacją (w porównaniu z dołączaniem plików HTML) jest dołączanie danych zapisanych w zwykłych plikach tekstowych. Większość aplikacji, łącznie z Wordem i Excelem, pozwala na publikowanie danych w różnych formatach tekstowych. Najczęściej spotykanymi formatami są:
Rozdział 7. Dołączanie danych zewnętrznych
233
Rysunek 7.10. Ekran kreatora importu HTML umożliwiający nadanie nazw nagłówkom kolumn (nazw pól) w tabeli połączonej
Pliki z wierszami o stałej szerokości — w takich plikach każdy wiersz reprezentuje jeden wiersz w tabeli bazy danych. Każde pole w wierszu zajmuje dokładnie tyle samo znaków co odpowiadające mu pole w wierszu powyżej i poniżej wiersza bieżącego. Na przykład pole z nazwiskiem w pliku tekstowym z polami o stałej szerokości wierszy może zajmować 20 znaków, natomiast pole z numerem telefonu — 10 lub 15 znaków. Każde pole danych jest uzupełniane spacjami do prawej w celu wypełnienia szerokości przydzielonej dla pola. Typowy plik z wierszami o stałej szerokości otwarty w Notatniku systemu Windows pokazano na rysunku 7.11.
Rysunek 7.11. Typowy plik tekstowy o stałej szerokości pól
234
Część II Tabele Accessa
Pliki CSV — mają nieco bardziej skomplikowany format. Poszczególne pola są oddzielone od siebie przecinkami (,), a każde z pól zajmuje tyle miejsca, ile potrzeba, by pomieścić dane. Pomiędzy polami w pliku CSV jest niewiele miejsca. Zaletą plików CSV jest możliwość zapisania znacznie większej ilości danych w pliku o tym samym rozmiarze, ponieważ każde pole zajmuje tylko tyle miejsca na dysku, ile potrzeba. Pliki CSV trudno się czyta po otwarciu w Notatniku systemu Windows. Typowy plik CSV pokazano na rysunku 7.12.
Rysunek 7.12. Dane CSV są bardziej zwięzłe od plików tekstowych o stałej szerokości, ale mniej czytelne
Pliki tekstowe często wykorzystuje się jako pośredni mechanizm transmisji danych pomiędzy różnymi aplikacjami. Załóżmy, że w środowisku wykorzystywany jest przestarzały system zarządzania danymi, który jest niezgodny z formatami dołączanych lub importowanych danych w Accessie. Przy odrobinie szczęścia przestarzały system może być wyposażony w mechanizm eksportu danych do formatu pliku tekstowego o wierszach stałej szerokości lub formatu CSV. Dołączenie lub zaimportowanie danych tekstowych w formacie plików z wierszami stałej szerokości lub w formacie CSV może być najlepszą opcją umożliwiającą współdzielenie danych ze starym systemem. W najgorszym przypadku dołączenie lub zaimportowanie danych ze starego systemu powinno zająć znacznie mniej czasu od ponownego wprowadzenia wszystkich informacji z przestarzałego systemu do Accessa. W celu dołączenia pliku tekstowego Contacts_FixedWidth.txt lub Contacts_CSV.txt wykonaj następujące czynności: 1. Otwórz bazę danych Rozdział07.accdb i wybierz zakładkę DANE ZEWNĘTRZNE na wstążce.
Rozdział 7. Dołączanie danych zewnętrznych
235
2. Kliknij przycisk Plik tekstowy. Pojawi się okno dialogowe Pobieranie danych zewnętrznych — Plik tekstowy. 3. Upewnij się, że zaznaczona jest opcja Połącz ze źródłem danych, tworząc tabelę połączoną, a następnie kliknij przycisk Przeglądaj. Wyświetli się okno Otwieranie pliku. 4. Znajdź plik tekstowy (Contacts_FixedWidth.txt lub Contacts_CSV.txt) i kliknij przycisk Otwórz. 5. Kliknij przycisk OK, aby przejść do okna dialogowego Pobieranie danych zewnętrznych — Plik tekstowy. Wyświetli się okno dialogowe Kreator łączenia tekstu. Access zwykle dość dobrze rozpoznaje sposób rozdziału danych w plikach. Dołączanie danych tekstowych sprowadza się do kliknięcia przycisku Dalej i zweryfikowania, czy Access poprawnie zidentyfikował dane w pliku. W tym rozdziale zrezygnujemy z przedstawiania i omawiania wszystkich okien dialogowych Kreatora dołączania tekstu. Zachęcamy natomiast do samodzielnego dołączenia plików Contacts_CSV.txt i Contacts_FixedWidth.txt — oba znajdują się na płycie w plikach dołączonych do tej książki. Jak się przekonamy przy okazji dołączania tych plików, w zasadzie jedyną informacją wymaganą od użytkownika podczas tego procesu jest podanie nazwy dla każdego z pól zamieszczonych w pliku tekstowym. Przy odrobinie szczęścia w pierwszym wierszu pliku tekstowego są zapisane nazwy pól. W przeciwnym razie dołączenie pliku tekstowego będzie wymagało określenia nazwy każdego pola.
Praca z tabelami połączonymi Po dołączeniu zewnętrznej tabeli z innej bazy danych, można używać jej tak jak zwykłej tabeli Accessa. Można wykorzystywać ją w formularzach, raportach i kwerendach tak, jak rodzimą tabelę Accessa. Pracując z zewnętrznymi tabelami, można modyfikować wiele ich właściwości, na przykład ustawiać właściwości widoku i relacje, określać w kwerendach łącza między tabelami albo zmieniać nazwę tabeli. Przy zmianie nazwy połączonych tabel należy zwrócić uwagę na pewną kwestię. Zdefiniowanie innej nazwy dla tabeli wewnątrz Accessa nie zmienia nazwy pliku połączonego z aplikacją. Nazwa, jaką Access posługuje się w odniesieniu do połączonej tabeli, jest utrzymywana wewnątrz aplikacji Accessa i nie ma wpływu na połączoną fizyczną tabelę.
Ustawianie właściwości widoku Choć zewnętrznej tabeli można używać tak jak tabeli Accessa, nie da się zmieniać jej struktury (usuwać, dodawać lub przestawiać pól). Można jednak ustawić kilka właściwości pól w tabeli połączonej. Oto one:
format,
miejsca dziesiętne,
podpis,
236
Część II Tabele Accessa
maska wprowadzania,
kompresje Unicode,
tryb IME,
sterowanie wyświetlaniem.
Aby zmienić te właściwości, otwórz tabelę połączoną w widoku projektu. Access wyświetli wtedy ostrzeżenie, że nie można zmodyfikować projektu tabeli. Na rysunku 7.13 widoczne jest ostrzeżenie wyświetlane przy próbie otwarcia tabeli produktów w widoku projektu. Mimo ostrzeżenia można zmienić wymienione wcześniej właściwości.
Rysunek 7.13. Przy otwieraniu tabeli połączonej w widoku projektu pojawia się ostrzeżenie
Ustawianie relacji Access pozwala ustawić trwałe relacje na poziomie tabeli między zewnętrznymi tabelami, które nie zostały utworzone przez Accessa, a tabelami Accessa. Służy do tego narzędzie Relacje. Access nie umożliwia jednak wymuszenia więzów integralności między tabelami połączonymi a lokalnymi. W Accessie można tworzyć formularze i raporty na podstawie relacji określonych w narzędziu Relacje. Możesz np. utworzyć instrukcję SQL-a zapisywaną we właściwości Źródło rekordu formularza lub raportu.
Przy dołączaniu zewnętrznych tabel Accessa zachowywane są relacje, które mogą występować pomiędzy zewnętrznymi tabelami. W związku z tym w przypadku dołączania bazy zaplecza relacje w niej zdefiniowane są rozpoznawane i uwzględniane przez bazę frontonu. Jest to korzystne, ponieważ zdefiniowane reguły są wymuszane niezależnie od tego, w ilu frontonach używane są dane tabele. Szczegółowe omówienie relacji znajdziesz w rozdziale 4.
Optymalizowanie tabel połączonych Kiedy Access pracuje z tabelami połączonymi, musi pobierać rekordy z innego pliku. Ten proces zajmuje czas, zwłaszcza jeśli tabela znajduje się w sieci lub SQL-owej bazie danych. W przypadku korzystania z danych zewnętrznych można zoptymalizować wydajność, stosując się do poniższych wskazówek:
Unikaj używania funkcji w kryteriach kwerendy. Dotyczy to zwłaszcza funkcji sumujących, takich jak DTotal lub DCount, które automatycznie pobierają wszystkie rekordy z tabeli połączonej, a następnie wykonują kwerendę.
Rozdział 7. Dołączanie danych zewnętrznych
237
Ogranicz liczbę wyświetlanych rekordów zewnętrznych. Utwórz kwerendę z kryterium, które ogranicza liczbę rekordów z tabeli zewnętrznej. Kwerendy tej można używać w innych kwerendach, formularzach lub raportach.
Unikaj nadmiernego poruszania się po arkuszu danych. Oglądaj na arkuszu tylko te dane, których potrzebujesz. Unikaj przewijania danych w górę i w dół i nie skacz do pierwszego albo ostatniego rekordu w bardzo dużych tabelach (wyjątkiem jest dodawanie rekordów do tabeli zewnętrznej).
Jeśli dodajesz rekordy do tabel zewnętrznych, utwórz przeznaczony do tego formularz i ustaw jego właściwość Wprowadzanie danych na Tak. Dzięki temu formularz będzie zaczynał się od pustego rekordu za każdym razem, kiedy zostanie otwarty. Formularze do wprowadzania danych nie są wstępnie zapełniane danymi z powiązanej tabeli. Wykorzystanie specjalnego formularza do wprowadzania danych jest znacznie wydajniejsze od stosowania zwykłego formularza, zapełniania go danymi z połączonego źródła i przechodzenia na koniec danych w celu dodania nowego rekordu.
Usuwanie odwołania do tabeli połączonej Usunięcie tabeli połączonej z listy obiektów to kwestia trzech prostych czynności: 1. Na liście obiektów zaznacz tabelę połączoną, którą chcesz usunąć. 2. Naciśnij klawisz Delete albo kliknij prawym przyciskiem myszy tabelę połączoną i wybierz polecenie Usuń z menu podręcznego. 3. Kliknij przycisk OK w oknie dialogowym Accessa, aby usunąć plik. Usunięcie zewnętrznej tabeli usuwa tylko jej nazwę z listy obiektów bazy danych. Dane nie są usuwane ze źródłowej lokalizacji.
Przeglądanie lub zmienianie informacji o tabelach połączonych W przypadku przeniesienia, zmiany nazwy lub modyfikacji tabel bądź indeksów powiązanych z tabelą połączoną należy skorzystać z Menedżera tabel połączonych w celu zaktualizowania łączy. W innym przypadku Access nie będzie w stanie znaleźć danych, do których odwołuje się plik. 1. Kliknij zakładkę NARZĘDZIA BAZY DANYCH, a następnie przycisk Menedżer tabel połączonych. Wyświetli się okno dialogowe Menedżer tabel połączonych (zobacz rysunek 7.14), które umożliwia wyszukiwanie plików danych powiązanych z tabelami połączonymi w bazie danych. 2. Zaznacz na nim pole wyboru obok tabeli połączonej, a następnie kliknij OK. 3. Należy odszukać brakujący plik i odtworzyć łącze. Jeśli do wszystkich plików prowadzą prawidłowe łącza, wystarczy kliknąć OK. Spowoduje to, że Access zweryfikuje wszystkie łącza prowadzące do wszystkich zaznaczonych tabel.
238
Część II Tabele Accessa
Rysunek 7.14. Menedżer tabel połączonych umożliwia odszukanie tabel zewnętrznych, które zostały przeniesione
4. Jeśli wiemy, że wszystkie połączone źródła danych przeniesiono, należy zaznaczyć pole wyboru Zawsze monituj o nową lokalizację i kliknąć przycisk OK. Po zaznaczeniu tej opcji Access będzie monitował o nową lokalizację i odtwarzał łącza do wszystkich tabel w trybie wsadowym. Operacja ta przebiega znacznie szybciej w porównaniu z łączeniem tabel pojedynczo. Jeśli instalacja Accessa nie zawiera Menedżera tabel połączonych, Access automatycznie wyświetla prośbę o włożenie do napędu oryginalnej płyty instalacyjnej z pakietem Office, tak by można było zainstalować ten kreator. Taka sytuacja może się zdarzyć, jeśli w czasie pierwotnej instalacji nie zaznaczono opcji instalacji dodatkowych kreatorów.
Odświeżanie zawartości tabel połączonych Access automatycznie synchronizuje tabele połączone ze źródłowymi danymi. Użytkownik nie musi podejmować żadnych działań, aby zaktualizować dane. Gdy tabela połączona jest otwarta w widoku arkusza danych lub używana w inny sposób, Access próbuje ograniczyć dostęp do źródłowych danych w sposób zależny od rodzaju danych. Blokuje na przykład używane połączone pliki tekstowe, aby nie można było otworzyć ich w edytorze tekstu. W celu przyjrzenia się automatycznemu aktualizowaniu dołączonych danych utwórz tabelę połączoną z plikiem tekstowym, a następnie spróbuj zmodyfikować ten plik. Wykonaj następujące czynności: 1. Kliknij przycisk Plik tekstowy w grupie Importowanie i łączenie w zakładce DANE ZEWNĘTRZNE na wstążce. 2. Dołącz plik tekstowy ContactsFixed.txt (jest to plik tekstowy o stałej szerokości pól). Plik ten jest poprawnie sformatowany, dzięki czemu Access potrafi poprawnie wykryć początki pól. W tym ćwiczeniu nazwy pól nie mają znaczenia. 3. Otwórz tabelę połączoną ContactsFixed. Zauważ, że zawiera ona 12 rekordów. Jeśli spróbujesz otworzyć plik ContactsFixed.txt w edytorze tekstu, Windows poinformuje, że plik jest używany przez inny proces i że nie można go otworzyć.
Rozdział 7. Dołączanie danych zewnętrznych
239
4. Zamknij tabelę ContactsFixed. 5. Dodaj nowy wiersz do pliku tekstowego w wybranym prostym edytorze tekstu (np. w Notatniku). Nie używaj Worda, ponieważ może zapisać dane w formacie innym niż zwykły tekst. Nowy plik ContactsFixed.txt przedstawiono na rysunku 7.15.
Rysunek 7.15. Tabele połączone są synchronizowane automatycznie
6. Zapisz plik i zamknij edytor tekstu. 7. Otwórz w Accessie tabelę połączoną ContactsFixed. W tabeli znajdować się teraz będzie trzynasty wiersz.
Dzielenie baz danych dla dostępu sieciowego Jest wiele dobrych powodów dołączania tabel z różnych baz danych Accessa. Jeden z najlepszych i najważniejszych związany jest z dzieleniem bazy danych. Proces ten polega na utworzeniu dwóch plików .accdb na podstawie jednego. Jeden z tych plików, nazywany zapleczem (ang. back-end), zawiera tylko tabele. Drugi, tak zwany fronton (ang. front-end), obejmuje kwerendy, makra, kod i elementy interfejsu użytkownika, np. formularze i raporty. Fronton zawiera też łącza do wszystkich tabel używanych na zapleczu.
Zalety dzielenia baz danych Przynajmniej jeden bardzo dobry powód przemawia za tym, by zainteresować się dzieleniem baz danych Accessa. Wprawdzie możemy udostępnić pojedynczą kopię pliku .accdb lub .mdb w komputerze współużytkowanym w sieci, lecz takie rozwiązanie znacznie pogarsza wydajność. Korzystanie z bazy danych Accessa przechowywanej w komputerze zdalnym wiąże się nie tylko z prostym przenoszeniem danych z komputera zdalnego do lokalnego. Wszystkie definicje formularzy, menu i wstążek muszą zostać przeniesione do komputera lokalnego, by system Windows mógł odtworzyć interfejs użytkownika na ekranie. System Windows w komputerze lokalnym musi przechwytywać i przesyłać do zdalnego komputera wszystkie
240
Część II Tabele Accessa
zdarzenia klawiatury i myszy, aby w odpowiedzi na te zdarzenia mógł zostać wykonany właściwy kod. Poza tym pojedyncza kopia Accessa w zdalnym komputerze musi obsłużyć wszystkie żądania danych, nawet najbardziej trywialne lub wymagające. Skutki wszystkich tych akcji pogarszają się wraz ze wzrostem liczby użytkowników pracujących z tą samą zdalną kopią bazy danych. Na szczęście większość z tych problemów znika, gdy baza danych jest podzielona na składniki frontonu i zaplecza. Lokalny system Windows obsługuje interfejs użytkownika, wykorzystując informacje zawarte we frontonie. Cały kod jest wykonywany w komputerze osobistym użytkownika, a nie w zdalnym serwerze. Oprócz tego lokalna kopia Accessa może obsługiwać wszystkie żądania danych przechowywanych lokalnie, a jedynie żądania danych przechowywanych zdalnie są przekazywane do bazy danych zaplecza. Zanim zajmiemy się szczegółami, rozważmy kilka problemów związanych z bazami danych przechowywanymi w pojedynczych plikach. Zacznijmy od tego, że w przeciwieństwie do innych systemów konstruowania aplikacji wszystkie obiekty aplikacji bazodanowej Accessa są przechowywane w pojedynczym pliku — dobrze nam znanym .accdb lub .mdb, z którym mamy do czynienia na co dzień. Inne bazy danych, takie jak FoxPro for Windows, dla każdej aplikacji utrzymują szereg różnych plików, zwykle po jednym pliku na obiekt (formularz, tabela i tak dalej). Wprawdzie konieczność pracy z większą liczbą plików komplikuje nieco rozwój i utrzymanie bazy danych, lecz aktualizacja pojedynczego formularza lub kwerendy wymaga jedynie zastąpienia odpowiedniego pliku nową wersją. Aktualizowanie obiektów baz danych Accessa jest nieco bardziej skomplikowane. Jak już zapewne zauważyłeś, zastąpienie formularza lub kwerendy w bazie danych Accessa, z której korzysta wielu użytkowników, może stanowić poważny problem. Zastąpienie formularza lub innego obiektu bazy danych często wymaga całych godzin pracy poświęconych na importowanie obiektu do każdej kopii bazy danych indywidualnego użytkownika. Drugim problemem jest ruch sieciowy nieunikniony w przypadku baz danych Accessa zawartych w pojedynczych plikach. Rysunek 7.16 przedstawia ten problem w przypadku typowej metody współużytkowania bazy danych Accessa. Komputer w lewym górnym rogu jest serwerem plików, w którym znajduje się plik bazy danych. Załóżmy na moment, że cała baza danych mieści się w jednym pliku .accdb w serwerze plików i że została udostępniona na potrzeby wspólnego dostępu do danych. Każda ze stacji roboczych na rysunku 7.16 ma zainstalowaną pełną kopię Accessa (lub środowisko runtime Accessa). Co się stanie, gdy użytkownik stacji roboczej C otworzy bazę danych? Access zainstalowany w tym komputerze musi znaleźć plik .accdb w serwerze plików, otworzyć go i uruchomić aplikację. Oznacza to, że wszelkie formularze powitalne, kwerendy i inne czynności związane z uruchamianiem aplikacji muszą odbyć się przez sieć, zanim użytkownik będzie mógł rozpocząć pracę z bazą danych. Za każdym razem, gdy otwierany jest formularz lub wykonywana kwerenda, niezbędne informacje muszą zostać przesłane siecią, co spowalnia działanie aplikacji. Na rysunku 7.16 obciążenie sieci jest oznaczone linią przerywaną.
Rozdział 7. Dołączanie danych zewnętrznych
241
Rysunek 7.16. Baza danych przechowywana w serwerze może generować duży ruch w sieci
Sytuacja na rysunku 7.16 staje się jeszcze gorsza, gdy więcej niż jeden użytkownik korzysta z tej samej bazy danych. W takim przypadku ruch w sieci jest zwiększany o kwerendy, otwieranie formularzy i inne operacje wykonywane przez kopię Accessa każdego z użytkowników. Wyobraźmy sobie, że linia przerywana staje się grubsza z każdą operacją wykonywaną przez sieć. Model z podzieloną bazą danych został przedstawiony na rysunku 7.17. Proszę zwrócić uwagę, że baza danych zaplecza mieści się w serwerze, natomiast w każdej stacji roboczej jest zainstalowana kopia frontonu. Każda z tych kopii zawiera łącza do tabel przechowywanych w pliku .accdb zaplecza. Frontonowe bazy danych zawierają też formularze, raporty, kwerendy i inne składniki interfejsu użytkownika aplikacji. Rysunek 7.17. Podział i rozproszenie bazy danych pozwala zredukować ruch w sieci
W rozwiązaniu z rysunku 21.3 ruch sieciowy został zredukowany, ponieważ przez sieć przesyłane są tylko informacje o łączach i dane zwracane przez kwerendy. Użytkownik korzystający z aplikacji bazy danych używa formularzy, kwerend, raportów, kodu i makr
242
Część II Tabele Accessa
przechowywanych w lokalnym pliku .accdb we frontonie. Ze stacji roboczej (frontonu) korzysta tylko jeden użytkownik, więc czas odpowiedzi lokalnego systemu jest znacznie krótszy, ponieważ lokalna kopia Accessa może natychmiast otworzyć bazę danych i zacząć operacje uruchamiania aplikacji. Ruch w sieci rośnie tylko podczas wykonywania faktycznych kwerend. Drugą ważną zaletą struktury podzielonej bazy danych jest to, że aktualizowanie formularzy, raportów i innych komponentów aplikacji wymaga jedynie zastąpienia zewnętrznej bazy danych w komputerze każdego z użytkowników i ponownego nawiązania połączeń z tabelami w bazie wewnętrznej. Projekt z rysunku 7.17 pozwala na dostosowywanie frontonów do potrzeb indywidualnych użytkowników poszczególnych stacji roboczych. Na przykład menedżer używający stacji roboczej A może potrzebować dostępu do danych pracowników, niedostępnych dla użytkowników stacji roboczych B i C. W takim przypadku zewnętrzna baza danych w stacji roboczej A będzie zawierać formularze, kwerendy i inne obiekty bazy danych niezbędne do wyświetlania danych pracowników.
Jak podzielić obiekty? Lokalny plik .accdb powinien zawierać wszystkie obiekty interfejsu użytkownika, w tym formularze, raporty, kwerendy, makra i moduły. Składowanie tych elementów interfejsu użytkownika w komputerze lokalnym znacznie poprawia wydajność. Nie ma powodów, by przesyłać przez sieć formularze, kwerendy czy też raporty. Obiektami tymi można o wiele łatwiej manipulować, gdy znajdują się w komputerze lokalnym. Wszystkie współużytkowane tabele powinny być przechowywane w wewnętrznej bazie danych w serwerze. Ta baza danych jest otwarta w trybie udostępnionym, przez co wszystkie jej obiekty są dostępne dla wielu użytkowników. Tabele w serwerowej bazie danych są powiązane z frontonowym plikiem .accdb w komputerach osobistych użytkowników (jednoczesne łączenie tej samej tabeli z większą liczbą baz danych nie sprawia problemu). Oczywiście gdy więcej niż jedna osoba używa danych z tabeli, istnieje możliwość, że kilku użytkowników będzie modyfikować ten sam rekord. Silnik bazodanowy Accessa rozwiązuje ten problem, blokując rekord edytowany przez użytkownika. Konflikt blokad występuje, gdy więcej niż jeden użytkownik próbuje zaktualizować ten sam rekord. Tylko jeden użytkownik ma pełny dostęp do rekordu — reszta użytkowników będzie zablokowana lub ich zmiany zostaną wstrzymane, dopóki bieżący właściciel rekordu nie ukończy wprowadzania zmian.
Korzystanie z dodatku Rozdzielacz bazy danych Rozdzielacz bazy danych pomaga dzielić aplikację na bazy danych frontonu i zaplecza. Kreator ten pozwala dowolnie budować i testować bazę danych, po czym automatycznie przygotowuje aplikację do wielodostępu. W ramach eksperymentu spróbujmy podzielić bazę danych firmy Northwind Traders na pliki .accdb frontonu i zaplecza. Aby uruchomić rozdzielacz bazy danych, należy na wstążce wybrać zakładkę NARZĘDZIA BAZY DANYCH, a następnie w grupie Przenoszenie danych kliknąć Baza danych programu Access. Początkowy ekran kreatora (zobacz rysunek 7.18) objaśnia działanie narzędzia i sugeruje, aby przed kontynuacją działania wykonać kopię zapasową bazy danych.
Rozdział 7. Dołączanie danych zewnętrznych
243
Rysunek 7.18. Rozdzielacz bazy danych jest bardzo prostym kreatorem
Jedyną dodatkową informacją, której wymaga Rozdzielacz bazy danych, jest określenie miejsca, w którym ma zapisać bazę danych zaplecza. Rysunek 7.19 przedstawia znajomo wyglądające okno dialogowe w stylu Eksploratora Windows, pozwalające wskazać lokalizację pliku .accdb zaplecza. Domyślnie baza danych zaplecza ma taką samą nazwę jak oryginał, z dodatkowym przyrostkiem _wb (np. MyDB_wb.accdb).
Rysunek 7.19. W oknie dialogowym Utwórz wewnętrzną bazę danych należy wskazać ostateczną lokalizację bazy danych zaplecza Dostęp do lokalizacji sieciowej można uzyskać za pomocą ścieżki UNC (ang. Universal Naming Convention) lub przy użyciu zmapowanego napędu. Ścieżki UNC rozpoczynają się od dwóch lewych ukośników, po których następuje nazwa serwera i ścieżka do lokalizacji sieciowej. Oto przykładowa ścieżka UNC: \\Serwer\UdziałSieciowy\Katalog\. W zmapowanym napędzie ścieżkom UNC przypisywane są litery (np. S:). Zmapowany napęd jest niepowtarzalny dla każdego komputera, dlatego nie ma gwarancji, że takie
244
Część II Tabele Accessa napędy będą identyczne na różnych komputerach. W trakcie tworzenia bazy danych zaplecza zawsze stosuj ścieżki UNC do dołączania tabel, ponieważ są one takie same dla wszystkich komputerów z danej sieci. Aby zastosować ścieżkę UNC, przejdź do lokalizacji sieciowej za pomocą skrótu Sieć (w starszych wersjach systemu Windows nosił on nazwę Moje miejsca sieciowe). Plik należy zapisać dokładnie tam, gdzie będzie mieścić się w środowisku produkcyjnym. Frontonowa baza danych zawiera łącza do bazy danych zaplecza, a łącza obejmują ścieżkę do pliku, więc gdybyśmy po użyciu rozdzielacza przenieśli plik zaplecza, łącza trzeba by było odświeżyć.
Po kliknięciu przycisku Podziel (zobacz rysunek 7.19) narzędzie tworzy bazę danych zaplecza, eksportuje do niej wszystkie tabele, usuwa tabele z lokalnej bazy danych i tworzy łącza do tabel zaplecza. Inaczej mówiąc, wykonuje dokładnie te same czynności, które musielibyśmy w przeciwnym razie wykonać ręcznie. Proces może potrwać dość długo, zwłaszcza w przypadku dużych baz danych. Access musi utworzyć nową bazę danych, przenieść do niej tabele i utworzyć łącza do oryginalnej bazy danych, więc proces podziału może wymagać więcej niż kilka minut. Nie ma się czym przejmować, jeśli potrwa to dłużej, niż się spodziewaliśmy — zdecydowanie opłaci się poczekać! Warto też pamiętać, że rozdzielacz bazy danych to stosunkowo proste narzędzie, które ignoruje kwestie systemowe (np. ilość pamięci dostępnej na dysku). Sprawdź, czy na docelowej maszynie dostępne jest miejsce na bazę danych zaplecza.
Rysunek 7.20 przedstawia okienko nawigacji Accessa po podzieleniu bazy danych Northwind Traders. Baza danych zaplecza zawiera tylko tabele wyeksportowane z pliku Northwind.accdb. Warto zwrócić uwagę, że ikony powiązane z wszystkimi tabelami z Northwind.accdb zmieniły się, co wskazuje na to, że tabele te zostały przeniesione do bazy danych zaplecza. Zanim udostępnisz fronton użytkownikom, musisz zaimportować z bazy zaplecza wszystkie tabele lokalne. Rysunek 7.20. Rozdzielacz bazy danych tworzy łącza do wszystkich tabel w bazie danych
Część III
Kwerendy Accessa W tej części:
Rozdział 8. Pobieranie danych za pomocą kwerend
Rozdział 9. Stosowanie operatorów i wyrażeń
Rozdział 10. Poza kwerendy pobierające
Rozdziały z części III to wprowadzenie do wybranych podstawowych narzędzi i technik analitycznych dostępnych w Accessie. Dzięki nim zdobędziesz solidne podstawy z zakresu tworzenia kwerend Accessa. Kwerendy pozwalają pobierać dane z różnych źródeł i przedstawiać połączone informacje w przydatnych widokach. Umożliwiają przekształcenie surowych danych z tabel Accessa na sensowne informacje analityczne. Część ta rozpoczyna się od rozdziału 8., w którym opisaliśmy konstruktor kwerend i techniki przeprowadzania prostych analiz tabel Accessa. W rozdziale 9. przedstawiamy różne operatory i wyrażenia, które pozwalają wzbogacić analizy danych w Accessie. Rozdział 10. zawiera zaawansowane zagadnienia dotyczące kwerend. Dowiesz się z niego, jak wyjść poza proste pobieranie danych z tabel. Zobaczysz, jak agregować dane w kwerendach, uruchamiać kwerendy funkcyjne i tworzyć dające dużo możliwości kwerendy krzyżowe.
246
Część III Kwerendy Accessa
Rozdział 8.
Pobieranie danych za pomocą kwerend W tym rozdziale:
Czym są kwerendy i do jakich zadań mogą służyć?
Tworzenie kwerendy
Definiowanie pól w kwerendzie
Wyświetlanie wyników kwerendy
Dodawanie i usuwanie kwerend z projektu kwerendy
Sortowanie wyników kwerendy
Filtrowanie rekordów zwracanych przez kwerendę
Drukowanie rekordów zwracanych przez kwerendę
Zapisywanie kwerendy
Uwzględnianie w kwerendzie więcej niż jednej tabeli
Dodawanie, usuwanie i przenoszenie tabel w kwerendzie
Łączenie tabel w projekcie kwerendy
Opcje łączenia tabel w kwerendzie
Kwerendy są istotną częścią każdej aplikacji bazy danych. Są to narzędzia, które umożliwiają użytkownikom uzyskanie danych z wielu tabel, łączenie ich na różne użyteczne sposoby oraz prezentowanie ich w formie arkusza danych, w formularzu lub drukowanym raporcie. Być może słyszałeś stary frazes, że kwerendy przekształcają dane na informacje. Do pewnego stopnia to zdanie jest prawdziwe (dlatego właśnie jest frazesem). Dane zapisane w tabelach nie są szczególnie przydatne, ponieważ dane zwykle nie występują w jakimś konkretnym porządku. Ponadto w prawidłowo znormalizowanej bazie danych ważne
248
Część III Kwerendy Accessa
informacje są rozproszone w wielu różnych tabelach. Kwerendy są mechanizmem, który łączy ze sobą różne źródła danych i prezentuje połączone informacje w taki sposób, że użytkownicy mogą rozpocząć pracę z danymi. Wyjściową bazę danych do tego rodziału (Rozdział08.accdb) możesz pobrać z witryny poświęconej książce.
Wprowadzenie w tematykę kwerend Głównym zastosowaniem bazy danych jest przechowywanie informacji i umożliwienie ich pobierania. Dane mogą być pobierane natychmiast po ich wprowadzeniu albo kilka dni, tygodni lub nawet lat później. Oczywiście pobieranie informacji z tabel bazy danych wymaga posiadania wiedzy na temat tego, jak baza jest zbudowana. Na przykład raporty można ręcznie umieszczać w szafkach, posortowane według roku i numeru porządkowego wskazującego na datę utworzenia. Aby znaleźć określony raport, trzeba znać rok jego powstania i numer. W dobrze prowadzonych biurach powinien istnieć spis ułatwiający odszukanie określonego raportu. Spis mógłby zawierać wszystkie raporty posortowane alfabetycznie według typu i na przykład według daty. Byłby bardzo przydatny, ale znając tylko temat raportu i przybliżoną datę jego powstania, i tak trzeba by w celu zlokalizowania raportu przeszukać cały dokument. W przeciwieństwie do fizycznych kartotek komputerowe bazy danych takie jak Microsoft Access umożliwiają łatwe uzyskiwanie informacji spełniających dowolnie zdefiniowane kryteria. Na tym polega prawdziwa wartość baz danych — na możliwości przeglądania i analizowania danych w dowolny sposób. Kwerendy (zwane też zapytaniami) służą do zadawania bazie danych pytań dotyczących przechowywanych w niej danych. W większości kwerendy wykorzystuje się jako źródło danych dla formularzy, raportów oraz graficznych wykresów reprezentujących dane zapisane w bazie.
Czym są kwerendy? Zacznijmy od podstaw. Słowo kwerenda pochodzi od łacińskiego quaerere, co oznacza „pytać, wyszukiwać”. Kwerenda w programie Microsoft Access jest pytaniem dotyczącym informacji zapisanych w tabelach Accessa. Tworzy się ją za pomocą odpowiednich narzędzi dostępnych w Accessie, a następnie zapisuje jako oddzielny obiekt w bazie danych. Kwerenda może być prosta i pobierać dane umieszczone w pojedynczej tabeli lub może mieć formę złożonego zapytania dotyczącego informacji przechowywanych w kilku tabelach. Używając kwerend w ten sposób, można na przykład zapytać bazę o ciężarówki sprzedane w 2012 roku. Po zadaniu pytania Access zwraca jedynie żądane informacje.
Rozdział 8. Pobieranie danych za pomocą kwerend
249
Co można robić za pomocą kwerend? Kwerendy są bardzo elastyczne. Umożliwiają przeglądanie danych w praktycznie każdy sposób, jaki można sobie wyobrazić. Większość systemów baz danych ciągle się rozwija i zmienia. Bardzo często zmianie ulega nawet pierwotne przeznaczenie, dla którego powstał system. Oto próbka tego, co można osiągnąć za pomocą kwerend Accessa:
Wybieranie tabel. Można pobierać informacje zarówno z jednej tabeli, jak i z kilku tabel powiązanych ze sobą za pomocą określonych wspólnych danych. Przypuśćmy, że chcemy zobaczyć nazwiska klientów wraz z produktami zakupionymi przez klientów poszczególnych typów. W przypadku skorzystania z wielu tabel Access łączy dane w jeden zestaw rekordów.
Wybieranie pól. Można ustalić, które pola z każdej tabeli mają się pojawić w zbiorze wynikowym. Na przykład spośród wszystkich pól tabel tblCustomers i tblSales można wybrać tylko nazwiska, kody pocztowe, daty sprzedaży i numery faktur.
Definiowanie kryteriów. Wybieranie rekordów odbywa się na podstawie kryteriów. Na przykład możemy zażądać wyświetlenia tylko tych rekordów, które dotyczą określonej kategorii produktów.
Sortowanie rekordów. Rekordy można sortować w określonym porządku. Na przykład klientów można posortować według nazwisk i imion.
Wykonywanie obliczeń. Kwerendy można wykorzystać do wykonywania obliczeń, na przykład średniej lub sumy. Można też zliczać rekordy spełniające określone kryteria.
Tworzenie tabel. Można utworzyć nową tabelę na podstawie danych zwracanych przez zapytanie.
Wyświetlanie danych zwróconych przez kwerendy w formularzach i raportach. Zestaw rekordów tworzony na podstawie kwerendy może zawierać pola i dane nadające się do wykorzystania w raporcie bądź formularzu. Tworzenie raportu lub formularza opartego na kwerendzie oznacza, że przy każdym drukowaniu raportu czy otwarciu formularza kwerenda najpierw pobiera z tabel najbardziej aktualne informacje.
Używanie kwerend jako źródeł danych dla innych kwerend (podzapytań). Można tworzyć kwerendy, które bazują na zbiorze rekordów zwróconych przez inne kwerendy. Jest to bardzo wygodny sposób wykonywania kwerend ad hoc, gdzie może występować konieczność wielokrotnego wprowadzania niewielkich zmian w kryteriach. W takim przypadku druga kwerenda służy do odfiltrowania wyników pierwszej kwerendy.
Wprowadzanie zmian w tabelach. Kwerendy funkcyjne modyfikują wiele wierszy w różnych tabelach za pomocą pojedynczej operacji. W związku z tym kwerendy funkcyjne są często wykorzystywane do konserwowania danych, na przykład archiwizowania danych historycznych lub usuwania danych, które się zdezaktualizowały.
250
Część III Kwerendy Accessa
Co zwracają kwerendy? Access łączy rekordy zwracane przez kwerendę, a następnie prezentuje je w arkuszu danych. Zbiór wyników zwracany przez kwerendę jest powszechnie nazywany zestawem rekordów (ang. recordset). W rzeczywistości jest to dynamiczny (wirtualny) zbiór rekordów. Zbiór rekordów zwracany przez kwerendę nie jest zapisywany w bazie danych, chyba że poinstruujemy Accessa, aby utworzył tabelę na podstawie zwracanych rekordów. Więcej informacji na temat arkuszy danych można znaleźć w rozdziale 5.
Gdy zapisujemy kwerendę, zapisywana jest tylko jej struktura, a nie zwracane przez nią rekordy. Oznacza to, że zachowywany jest tylko kod w SQL-u użyty do utworzenia kwerendy. Omówienie składni SQL-a używanej w kwerendach znajdziesz w rozdziale 14.
Niezapisywanie zestawu rekordów w fizycznej tabeli ma następujące zalety:
Potrzebna jest mniejsza ilość miejsca do przechowywania danych (zwykle przestrzeni na twardym dysku).
Kwerenda wykorzystuje zawsze aktualną wersję rekordów.
Przy każdym uruchomieniu kwerenda przegląda używane tabele oraz tworzy od nowa wynikowy zbiór rekordów. Ponieważ zawartości zbiorów wynikowych nie są przechowywane, kwerenda automatycznie odzwierciedla wszystkie zmiany dokonane w tabelach bazowych od czasu ostatniego jej uruchomienia — nawet w wielodostępnych środowiskach czasu rzeczywistego. W zależności od potrzeb zestaw rekordów kwerendy może być wyświetlany w arkuszu danych albo w formularzu lub raporcie. Kiedy formularz lub raport bazuje na kwerendzie, zestaw rekordów kwerendy jest tworzony i wiązany z formularzem lub raportem przy każdym ich otwieraniu. Zestaw rekordów kwerendy można też wykorzystać w makrach i procedurach w języku VBA przy wykonywaniu różnych zautomatyzowanych zadań.
Tworzenie kwerendy Po utworzeniu tabel i umieszczeniu w nich danych można rozpocząć pracę z kwerendami. Aby utworzyć kwerendę, należy wybrać grupę Tworzenie na wstążce Accessa, a następnie kliknąć przycisk Projekt kwerendy w grupie Inne. W efekcie Access otworzy okno projektu kwerendy widoczne na rysunku 8.1. Na rysunku 8.1 pokazano dwa okna. To pod spodem to okno widoku projektu kwerendy. Na pierwszym planie wyświetla się okno dialogowe Pokazywanie tabeli. Okno Pokazywanie tabeli jest modalne, co oznacza, że aby przejść do pracy nad kwerendą, trzeba
Rozdział 8. Pobieranie danych za pomocą kwerend
251
Rysunek 8.1. Okno dialogowe Pokazywanie tabeli oraz widok projektu kwerendy
najpierw wykonać w nim jakieś czynności. W naszym przypadku trzeba dodać do kwerendy tabele, na których będzie ona wykonywać operacje. Na rysunku zaznaczona i gotowa do dodania jest tabela tblProducts. Okno dialogowe Pokazywanie tabeli pokazane na rysunku 8.1 wyświetla wszystkie tabele i kwerendy istniejące w bazie danych. Aby dodać do struktury kwerendy tabelę tblProducts, należy dwukrotnie kliknąć jej nazwę albo wybrać tabelę tblProducts na liście i kliknąć przycisk Dodaj. Po dodaniu tabeli tblProducts można zamknąć okno dialogowe Pokazywanie tabeli. Tabelę tblProducts dodaną do kwerendy pokazano na rysunku 8.2. Rysunek 8.2. Okno projektu kwerendy po dodaniu tabeli tblProducts
Aby dołączyć do kwerendy dodatkowe tabele, należy kliknąć prawym przyciskiem myszy w dowolnym miejscu górnej części okna widoku projektu kwerendy, a następnie wybrać z menu podręcznego polecenie Pokaż tabelę. Można też przeciągnąć tabele z okienka nawigacji do górnej części okna projektu kwerendy. Przycisk Pokaż tabelę jest także dostępny na wstążce, w zakładce PROJEKTOWANIE.
252
Część III Kwerendy Accessa
Usunięcie tabeli z projektu kwerendy jest łatwe. Wystarczy kliknąć ją prawym przyciskiem myszy w widoku projektu kwerendy, a następnie wybrać z menu podręcznego polecenie Usuń tabelę. Okno kwerendy ma trzy główne widoki:
Widok projektu — tworzymy w nim kwerendy.
Widok arkusza danych — wyświetla rekordy zwracane przez kwerendę.
SQL — wyświetla instrukcję SQL, która definiuje kwerendę.
Okno widoku projektu kwerendy składa się z dwóch części:
Obszar wprowadzania tabel i kwerend (w górnej części) — w tym obszarze dodajemy do projektu kwerendy tabele, kwerendy oraz listy pól. Dostępne jest odrębne okno z listą pól dla każdego dodawanego obiektu. Okno z listą pól zawiera nazwy wszystkich pól z wybranej tabeli bądź kwerendy. Rozmiar okna z listą pól można zmieniać, klikając którąś z jego krawędzi i przeciągając ją w odpowiednią stronę. Czasami trzeba zmienić rozmiar okna z listą pól po to, aby były widoczne wszystkie pola tabeli.
Siatki QBE (ang. Query by Example — zapytanie przez przykład) (w dolnej części) — zawierają nazwy pól wykorzystywanych w kwerendzie oraz kryteria stosowane do wybierania rekordów. Każda kolumna siatki QBE zawiera informacje na temat jednego pola z tabeli lub kwerendy znajdującej się w górnym obszarze.
Poszczególne obszary (panele) okna są od siebie oddzielone poziomym paskiem mogącym służyć do zmiany ich rozmiaru (zobacz rysunek 8.2). Aby zmienić rozmiar górnego lub dolnego panelu, wystarczy przeciągnąć pasek w górę lub w dół za pomocą myszy. Między górnym a dolnym obszarem można się przełączać, klikając wybrany z nich lub naciskając klawisz F6. Każdy z obszarów ma pionowy i poziomy pasek przewijania, które ułatwiają poruszanie się wewnątrz obszaru. Kwerendę tworzy się poprzez przeciąganie pól z górnego do siatki QBE. Na rysunku 8.2 pokazano pustą siatkę QBE w dolnej części widoku projektu kwerendy. Siatka QBE składa się z sześciu wierszy oznaczonych następującymi etykietami:
Pole — w tym wierszu wpisuje się lub dodaje nazwy pól.
Tabela — w tym wierszu wyświetla się nazwa tabeli, z której pochodzi pole. Przydaje się on w kwerendach wykorzystujących wiele tabel.
Sortuj — ten wiersz umożliwia zdefiniowanie sposobu sortowania dla kwerendy.
Pokaż — wiersz ten decyduje o tym, czy określone pole ma się wyświetlić w zestawie rekordów zwracanych przez kwerendę.
Kryteria — jest to wiersz zawierający kryteria filtrowania zwracanych rekordów.
lub — ten wiersz jest pierwszym z grupy wierszy, za pomocą których można zdefiniować złożone kryteria kwerendy
Rozdział 8. Pobieranie danych za pomocą kwerend
253
Więcej informacji na temat tych wierszy znajduje się w opisie procesu tworzenia kwerend w dalszej części tego rozdziału. Wstążka Projektowanie kwerendy (pokazana na rysunku 8.3) zawiera wiele różnych przycisków służących do tworzenia kwerend i wykonywania operacji na kwerendach. Przyciski te zostały opisane przy okazji ich używania w różnych rozdziałach książki. A oto najważniejsze przyciski:
Widok — służy do przełączania między widokami arkusza danych i projektu kwerendy. Rozwijana lista Widok umożliwia także wyświetlanie instrukcji w SQL-u, na której bazuje kwerenda.
Uruchom — uruchamia kwerendę. Dla kwerend wybierających wyświetla arkusz danych — pełni taką samą funkcję jak wybranie polecenia Arkusz danych z rozwijanej listy Widok. W przypadku kwerend funkcyjnych powoduje wykonanie serii operacji określonych w kwerendzie (dołączanie rekordów, tworzenie tabeli itp.).
Wybierz — kliknięcie przycisku Wybierz otwiera nową kwerendę wybierającą w widoku projektu kwerendy.
Utwórz tabelę, Dołącz, Aktualizuj, Krzyżowa i Usuń — każdy z tych przycisków określa typ tworzonej kwerendy. W większości przypadków za pomocą jednego z tych przycisków przekształca się kwerendę wybierającą w funkcyjną.
Pozostałe przyciski są wykorzystywane przy bardziej zaawansowanych kwerendach i służą do drukowania zawartości kwerendy oraz wyświetlania arkusza właściwości kwerendy.
Dodawanie pól Istnieje kilka metod dodawania pól do kwerendy. Pola można dodawać pojedynczo, można zaznaczyć oraz dodać kilka pól lub wszystkie pola na liście. Dodawanie pojedynczego pola Pojedyncze pola można dodawać do kwerendy na kilka sposobów. Jedną z metod jest dwukrotne kliknięcie nazwy pola w górnej części widoku projektu kwerendy. Nazwa pola natychmiast wyświetli się w pierwszej wolnej kolumnie siatki QBE. Innym sposobem jest przeciągnięcie pola z tabeli w górnej części okna projektu kwerendy i upuszczenie go na siatce QBE. Upuszczenie pola pomiędzy dwoma innymi polami na siatce QBE powoduje przesunięcie pozostałych pól w prawo. Na rysunku 8.4 pokazano dodawanie do listy pola Cost. Po dodaniu pola można przejść do kolejnej komórki i określić następne pole, jakie ma być uwzględnione w kwerendzie.
254
Część III Kwerendy Accessa
Rysunek 8.4. Dodawanie pól tabeli do siatki QBE. Wystarczy dwukrotnie kliknąć pole lub je przeciągnąć
Każda komórka w wierszu Tabela siatki QBE zawiera rozwijaną listę tabel dodanych w górnej części widoku projektu kwerendy. Dodawanie wielu pól Do siatki QBE można dodać równocześnie więcej niż jedno pole. W tym celu należy zaznaczyć wybrane pola na liście, a następnie przeciągnąć je do obszaru QBE. Wybrane pola nie muszą ze sobą sąsiadować (jedno pod drugim). Aby wybrać więcej niż jedno pole, należy podczas ich zaznaczania przytrzymać klawisz Ctrl. Proces dodawania wielu pól pokazano na rysunku 8.5. Rysunek 8.5. Dodawanie wielu pól w obszarze siatki QBE
Pola są dodawane do siatki QBE w porządku, w jakim występują w tabeli. Można również dodać wszystkie pola tabeli poprzez kliknięcie nagłówka listy pól (tam, gdzie na rysunku 8.6 wyświetla się nazwa tblProducts). Spowoduje to zaznaczenie wszystkich pól w tabeli. Następnie można przeciągnąć wyróżnione pola do siatki QBE.
Rozdział 8. Pobieranie danych za pomocą kwerend
255
Rysunek 8.6. Dodanie gwiazdki do siatki QBE powoduje wybranie wszystkich pól tabeli
Można również kliknąć na liście pól gwiazdkę (*)i przeciągnąć ją do siatki QBE (albo dwukrotnie kliknąć gwiazdkę w celu dodania jej do siatki QBE). Chociaż czynność ta nie powoduje dodania wszystkich pól do siatki QBE, gwiazdka informuje Accessa, że w kwerendzie mają być uwzględnione wszystkie pola tabeli. W odróżnieniu od zaznaczenia wszystkich pól użycie symbolu gwiazdki powoduje umieszczenie odwołania do wszystkich pól w pojedynczej kolumnie. Przeciąganie wszystkich pól pierwszym z prezentowanych sposobów dodaje do siatki QBE rzeczywiste nazwy pól. W przypadku późniejszej modyfikacji struktury tabeli trzeba także zmodyfikować projekt kwerendy. Używanie gwiazdki do wybierania wszystkich pól ma tę zaletę, że modyfikacja tabel biorących udział w kwerendzie nie wymaga wprowadzania zmian w samej kwerendzie. Gwiazdka oznacza wybór wszystkich pól w tabeli, niezależnie od nazw pól bądź zmiany liczby pól w tabeli. Wada stosowania gwiazdki do wybierania wszystkich pól w tabeli polega na tym, że kwerenda, zgodnie z instrukcją, zwraca wszystkie pola tabeli, niezależnie od tego, czy wszystkie są używane w formularzu bądź raporcie. Pobieranie niepotrzebnych danych może być bardzo kosztownym procesem. Przyczyną niskiej wydajności często jest zastosowanie gwiazdki, która powoduje zwrócenie do formularza bądź raportu znacznie większej liczby pól niż potrzeba.
Uruchamianie kwerend Po wybraniu pól możesz uruchomić kwerendę. W tym celu kliknij przycisk Uruchom w zakładce NARZĘDZIA KWEREND PROJEKTOWANIE (zobacz rysunek 8.7).
Rysunek 8.7. Kliknij przycisk Uruchom, aby wyświetlić wyniki zwrócone przez kwerendę
256
Część III Kwerendy Accessa
Aby powrócić do siatki QBE, możesz wybrać opcję Widok/Widok projektu w zakładce NARZĘDZIA GŁÓWNE. Możesz też kliknąć prawym przyciskiem myszy nagłówek zakładki kwerendy i wybrać opcję Widok projektu (zobacz rysunek 8.8). Rysunek 8.8. Kliknij prawym przyciskiem myszy nagłówek zakładki kwerendy i wybierz opcję Widok projektu, aby wrócić do siatki QBE
Praca z polami W pewnych sytuacjach występuje potrzeba przeorganizowania wybranych dla kwerendy pól — zmiany ich kolejności, wstawienia nowego pola czy usunięcia istniejącego. Można nawet dodać pole do obszaru QBE bez wyświetlania go w arkuszu danych. Dodawanie pól bez ich wyświetlania umożliwia przeprowadzenie sortowania według ukrytego pola lub użycie ukrytego pola jako kryterium.
Zaznaczanie pola w obszarze siatki QBE Zmiana pozycji pola wymaga wcześniej jego zaznaczenia. W tym celu należy wykorzystać wiersz selektorów pól. Wiersz selektorów pól to wąski szary pasek znajdujący się nad każdą z kolumn siatki QBE w dolnej części okna projektu kwerendy. Każda kolumna reprezentuje pole. Aby zaznaczyć pole Category, należy przesunąć kursor myszy nad wiersz selektorów kolumn (aż przyjmie on postać małej, czarnej strzałki skierowanej w dół), a następnie kliknąć selektor wybranej kolumny. Następnie można przeciągnąć kolumnę. Na rysunku 8.9 pokazano strzałkę nad kolumną Category tuż przed zaznaczeniem kolumny.
Rysunek 8.9. Zaznaczanie kolumny w obszarze siatki QBE. Po przesunięciu wskaźnika myszy na wiersz selektorów przyjmuje on postać strzałki skierowanej w dół Aby zaznaczyć kilka sąsiadujących ze sobą pól, należy kliknąć selektor pierwszego z nich, a następnie przeciągnąć wskaźnik myszy na ostatnie, które chcemy zaznaczyć.
Rozdział 8. Pobieranie danych za pomocą kwerend
257
Zmiana kolejności pól Kolejność od lewej do prawej, w jakiej pola wyświetlają się w obszarze siatki QBE, określa kolejność, w jakiej występują one w widoku arkusza danych. Aby pola wyświetliły się w innej kolejności w wynikach kwerendy, można je przemieszczać w obszarze siatki QBE. Po zaznaczeniu pól można je przemieszczać w obszarze QBE poprzez przeciąganie ich do nowych pozycji. Wystarczy kliknąć lewym przyciskiem myszy pasek selektora pola i trzymając tenże przycisk wciśnięty, przeciągnąć pole na nową pozycję w obrębie siatki QBE. Na rysunku 8.10 pokazano wyróżnione pole Category. W miarę przesuwania selektora pola w lewo separator kolumn pomiędzy polami ProductID i Description zmieni się (stanie się szerszy) i będzie wskazywał nowe miejsce pola Category.
Rysunek 8.10. Przemieszczanie pola Category w miejsce pomiędzy polami ProductID i Description. Zwróć uwagę na ikonę pola QBE poniżej strzałki obok kolumny Opis Kolejność pól w kwerendzie nie ma wpływu na sposób wyświetlania danych w formularzach i raportach. Formanty w formularzach i raportach zazwyczaj są rozmieszczane zgodnie z życzeniami użytkowników.
Zmiana rozmiaru kolumn w obszarze siatki QBE Obszar QBE domyślnie wyświetla w widocznym obszarze pięć lub sześć pól. Pozostałe pola można zobaczyć, przesuwając belkę poziomego paska przewijania wyświetlającego się w dolnej części okna. Czasami występuje potrzeba zwężenia niektórych pól w celu wyświetlenia większej liczby kolumn w obszarze siatki QBE. Aby dostosować szerokość kolumn (zwiększyć lub zmniejszyć), należy przesunąć wskaźnik myszy na krawędź pomiędzy polami i przeciągnąć belkę zmiany rozmiaru kolumn w lewo lub w prawo (zobacz rysunek 8.11).
Rysunek 8.11. Zmiana rozmiaru kolumn w obszarze siatki QBE Łatwiejszym sposobem zmiany rozmiaru kolumn wewnątrz siatki QBE jest dwukrotne kliknięcie linii dzielącej dwie kolumny wewnątrz siatki. Kiedy się to zrobi, Access automatycznie dostosuje szerokość kolumny do wyświetlających się w niej danych.
258
Część III Kwerendy Accessa
Szerokość kolumn na siatce QBE nie ma wpływu na sposób wyświetlania danych w arkuszach danych, a także w formularzach lub raportach. Szerokość kolumn na siatce QBE ma znaczenie wyłącznie dla wygody programisty. Podczas zapisywania lub zamykania kwerendy Access nie zapisuje szerokości kolumn na siatce QBE.
Usuwanie pól Aby usunąć pole (pola) z obszaru QBE, należy je zaznaczyć, a następnie nacisnąć klawisz Delete. Można również kliknąć prawym przyciskiem myszy selektor pola i z menu podręcznego wybrać polecenie Wytnij.
Wstawianie pól Aby wstawić nowe pole do obszaru siatki QBE, należy przeciągnąć je z okna listy pól powyżej siatki QBE i upuścić w odpowiedniej kolumnie siatki QBE. Nowa kolumna zostanie wstawiona z lewej strony kolumny, w której upuściliśmy pole. Dwukrotne kliknięcie pola na liście pól dodaje nową kolumnę na skrajnej prawej pozycji siatki QBE.
Ukrywanie pól Możesz chcieć, aby w trakcie wykonywania kwerend widoczne były tylko niektóre pola w siatce QBE. Załóżmy, że dodałeś do siatki pola FirstName, LastName, Address, City i State. Następnie zdecydowałeś, że chcesz przyjrzeć się wybranym danym z pominięciem pola State. Zamiast usuwać to pole, możesz je ukryć. W tym celu wystarczy usunąć zaznaczenie pola Pokaż w kolumnie State (zobacz rysunek 8.12). Rysunek 8.12. Pole wyboru Pokaż przy polu State nie jest zaznaczone, dlatego pole State nie pojawia się w wynikach
Pola kwerendy często ukrywa się dlatego, że służą do sortowania lub określania kryteriów, natomiast ich wartość nie jest później potrzebna. Pomyśl na przykład o kwerendach dotyczących faktur. Użytkownicy z różnych przyczyn mogą chcieć sortować faktury według daty złożenia zamówienia, nawet jeśli daty te nie są potrzebne. Można wtedy umieścić pole z datą zamówienia w siatce QBE, posortować dane według tego pola i usunąć zaznaczenie w polu wyboru Pokaż. Access posortuje dane według pola z datą zamówienia nawet wtedy, gdy pole to nie będzie widoczne w wynikach zwróconych przez kwerendę.
Rozdział 8. Pobieranie danych za pomocą kwerend
259
Jeżeli zapiszemy kwerendę zawierającą nieużywane pole (anulowano zaznaczenie pola Pokaż i nie zdefiniowano dla niego kryteriów lub porządku sortowania), Access automatycznie usunie je ze struktury kwerendy w ramach jej optymalizowania. Przy następnym otwarciu kwerendy pole nie będzie uwzględnione w projekcie kwerendy.
Zmiana kolejności sortowania Podczas przeglądania zestawu rekordów często trzeba je wyświetlić w określonym porządku. Sortowanie zestawu rekordów ułatwia analizę danych (np. umożliwia przeglądanie zawartości tabeli tblProducts uporządkowanej według kategorii). Sortowanie polega na ustawieniu rekordów w kolejności alfabetycznej lub numerycznej. Sposób sortowania może być rosnący lub malejący. Sortować można według jednego lub kilku pól. Dyrektywy sortowania wprowadza się w wierszu Sortuj siatki QBE. Aby określić porządek sortowania dla określonego pola (np. LastName), wykonaj następujące czynności: 1. Umieść kursor w komórce Sortuj w kolumnie LastName. 2. Kliknij listę rozwijaną w komórce i wybierz porządek sortowania (Rosnąco lub Malejąco). Na rysunku 8.13 pokazano siatkę QBE z rosnącym sortowaniem określonym dla pól LastName i FirstName. Zwróćmy uwagę, że dla pola LastName wyświetlają się dozwolone opcje sortowania. Zauważmy też, że w komórce Sortuj pola wyświetla się słowo Rosnąco. Rysunek 8.13. Dla pól LastName i FirstName określono rosnący porządek sortowania
Nie można sortować według pól typu Długi tekst lub Obiekt OLE.
Kolejność od lewej do prawej, w jakiej pola występują w obszarze siatki QBE, jest istotna w przypadku sortowania według więcej niż jednego pola. Pola nie tylko wyświetlają się w arkuszu danych w porządku od lewej do prawej, ale także są sortowane w tym samym porządku (nazywa się to hierarchią sortowania). Najpierw stosowane są kryteria sortowania dla pola występującego najbardziej z lewej strony, następnie kryteria najbliższego sąsiada z prawej itd. W przykładzie pokazanym na rysunku 8.13 Access najpierw zastosuje kryteria dla pola LastName, a potem dla pola FirstName.
260
Część III Kwerendy Accessa
Wynikowy arkusz danych kwerendy z rysunku 8.13 pokazano na rysunku 8.14. Zwróćmy uwagę, że dane są posortowane najpierw według pola LastName, a następnie według pola FirstName. Dlatego właśnie w wynikach kwerendy Arkadiusz Bondek wyświetla się przed Karoliną Bondek. Rysunek 8.14. Kolejność pól w obszarze siatki QBE ma kluczowe znaczenie w przypadku sortowania według wielu pól
Dodawanie kryteriów do kwerend Użytkownicy najczęściej pracują tylko z rekordami spełniającymi określone kryteria. W innym przypadku kwerenda mogłaby zwrócić zbyt wiele rekordów, powodując poważne problemy z wydajnością. Na przykład możemy poszukiwać danych tylko tych klientów, którzy nie kupili żadnego towaru w ciągu ostatnich sześciu miesięcy. Określanie kryteriów wyboru rekordów w Accessie jest łatwe.
Kryteria wyboru rekordów Kryteria wyboru są po prostu regułami filtrowania stosowanymi w odniesieniu do danych pobieranych z bazy. Mówią one Accessowi, jakie rekordy chcemy przeglądać w zestawie rekordów. Typowe kryteria mogą mieć na przykład postać: „wszyscy sprzedawcy”, „tylko samochody, które nie są ciężarówkami” lub „towary, których cena detaliczna jest większa niż 130 zł”. Kryteria wyboru ograniczają zbiór rekordów zwracanych przez kwerendę. Pomagają użytkownikom dzięki wybieraniu tylko tych rekordów, które chcą oni przeglądać, i ignorowaniu wszystkich pozostałych. Kryteria definiuje się w wierszu Kryteria siatki QBE. Określa się je w postaci wyrażeń. Wyrażenie może być proste (np. "Ciężarowe" lub Not "Ciężarowe"). Dzięki użyciu wbudowanych funkcji Accessa może ono również przyjąć bardziej złożoną postać. Umiejętność określania kryteriów ma kluczowe znaczenie przy projektowaniu dobrych baz danych Accessa. W większości przypadków użytkownicy nie mają pojęcia, jakie dane są przechowywane w tabelach bazy danych, i akceptują to, co widzą w formularzach i raportach, jako wiarygodne dane reprezentujące aktualny stan bazy danych. Źle
Rozdział 8. Pobieranie danych za pomocą kwerend
261
dobrane kryteria mogą się przyczynić do ukrycia istotnych informacji przed użytkownikami aplikacji, a to może później doprowadzić do błędnych decyzji biznesowych lub innych poważnych problemów.
Definiowanie prostych kryteriów tekstowych Kryteria typu znakowego można określać dla pól typu tekstowego. Najczęściej wpisuje się przykład tekstu, który chce się wyodrębnić z bazy danych. Oto prosty przykład zwracający rekordy tylko tych produktów, dla których kategoria produktu to "Osobowe". 1. Dodaj tabelę tblProducts i wybierz pola Description, Category oraz Cost. 2. Wpisz Osobowe w komórce Kryteria kolumny Category (zobacz rysunek 8.15). Zwróćmy uwagę, że Access dodał cudzysłów wokół wartości. Access, w przeciwieństwie do wielu innych systemów baz danych, automatycznie stosuje założenia dotyczące zamiarów użytkownika. Rysunek 8.15. Wpisywanie tekstu "Osobowe" jako kryteriów kwerendy
3. Uruchom kwerendę. Wyświetlą się tylko samochody osobowe. Patrząc na wyniki kwerendy, można stwierdzić, że nie ma sensu wyświetlanie słowa „Osobowe” we wszystkich wierszach w trzeciej kolumnie. Ponieważ ta kwerenda wyświetla wyłącznie informacje dotyczące samochodów osobowych, użytkownik może z powodzeniem założyć, że każdy rekord dotyczy samochodu. W związku z tym nie ma potrzeby wyświetlania kategorii produktu w wynikach kwerendy. Anulowanie zaznaczenie pola wyboru Pokaż w widoku projektu kwerendy spowoduje usunięcie kolumny Category z arkusza danych, przez co dane staną się bardziej zrozumiałe, Wyrażenie opisujące kryteria można wpisać na dowolny z poniższych sposobów: OSOBOWE = OSOBOWE "OSOBOWE" = "Osobowe"
Domyślnie Access nie rozróżnia dużych i małych liter, stąd w celu zdefiniowania kryteriów wyszukiwania można zapisać słowo osobowe w dowolnej postaci.
262
Część III Kwerendy Accessa
Rysunek 8.15 jest doskonałym przykładem ilustrującym różne typy prostych kryteriów tekstowych. Równie dobrze można w polu kryteriów kolumny wpisać Not Osobowe, aby uzyskać listę wszystkich produktów, które nie są samochodami osobowymi (ciężarowe, minivany itp.). Ogólnie w przypadku danych tekstowych kryteria określa się jako równość, nierówność lub w postaci listy dopuszczalnych wartości. Ten mechanizm daje użytkownikom bardzo duże możliwości. Wystarczy jedynie podać przykład, a Access nie tylko go zinterpretuje, ale utworzy także na jego podstawie zbiór wynikowy. Tłumaczy to nazwę Zapytanie przez przykład (ang. QBE) — wpisujemy przykład, a baza danych tworzy na tej podstawie zapytanie. Aby usunąć kryterium z komórki, należy zaznaczyć jej zawartość, a następnie nacisnąć klawisz Delete. Można też wybrać polecenie Wytnij z menu podręcznego dostępnego po kliknięciu prawym przyciskiem myszy.
Definiowanie prostych kryteriów innych typów Kryteria można również określać dla pól typu Liczba, Data/Godzina oraz Tak/Nie. W tym celu należy wpisać odpowiedni przykład w polu kryterium, identycznie jak w przypadku pól tekstowych. Niemal zawsze Access potrafi właściwie zinterpretować wprowadzone kryteria i odpowiednio je dostosować, aby można było użyć ich w odniesieniu do pól kwerendy. Możliwe jest również określenie więcej niż jednego kryterium dla kwerendy. Przypuśćmy na przykład, że chcemy przejrzeć jedynie rekordy klientów, którzy mieszkają w województwie pomorskim i którzy zostali klientami po 1 stycznia 2012 roku (wartość w polu OrigCustDate większa lub równa 1 stycznia 2012). Wymaga to wprowadzenia przykładowych danych w dwóch polach — State oraz OrigCustDate. W tym celu należy pamiętać, aby wpisy występowały w tej samej linii (w wierszu Kryteria). Aby utworzyć taką kwerendę, wykonaj następujące czynności: 1. Utwórz nową kwerendę bazującą na tabeli tblCustomers. 2. Dodaj do siatki QBE pola ContactType, FirstName, LastName, State oraz OrigCustDate. 3. Wpisz "mazowieckie" lub "MAZOWIECKIE" w komórce Kryteria dla kolumny State. 4. Wpisz >= 01/01/12 w komórce Kryteria dla kolumny OrigCustDate. Zwróćmy uwagę, że Access automatycznie otacza wartości dat znakami #. 5. Uruchom kwerendę. Wygląd kwerendy pokazano na rysunku 8.16. Access wyświetli rekordy klientów mieszkających w województwie mazowieckim, którzy zostali klientami przed 1 stycznia 2012 roku. Do porównywania pól typu Data z określonymi wartościami Access wykorzystuje operatory porównania. Są to znak mniejszości (<), znak większości (>), znak równości (=) oraz różne ich kombinacje.
Rozdział 8. Pobieranie danych za pomocą kwerend
263
Rysunek 8.16. Definiowanie kryteriów dla pól tekstowych i daty w tej samej kwerendzie
Zwróć uwagę, że Access automatycznie otacza wartości dat znakami #. Dzięki temu może odróżnić pola typu Data/Godzina od pól tekstowych. Znaków #, podobnie jak cudzysłowów w przypadku pól tekstowych, nie trzeba wprowadzać samemu. Ponieważ pole OrigCustDate jest typu Data/Godzina, Access zrozumie zamiary użytkownika i wstawi odpowiednie ograniczniki. Należy pamiętać, że Access interpretuje daty zgodnie z ustawieniami regionalnymi i językowymi systemu Windows dostępnymi w panelu sterowania. Na przykład w większości krajów europejskich i azjatyckich zapis #5/6/2012# zostanie zinterpretowany jako 5 czerwca 2012 roku, podczas gdy w Stanach Zjednoczonych ten sam zapis oznacza datę 6 maja 2012 roku. Bardzo łatwo można skonstruować kwerendę, która świetnie działa, ale zwraca nieprawidłowe dane ze względu na subtelne różnice ustawień regionalnych. Operatory i ich priorytety omówiono szczegółowo w rozdziale 9.
Drukowanie zbiorów wynikowych kwerend Po utworzeniu kwerendy można z łatwością wydrukować wszystkie rekordy ze zbioru wynikowego. Chociaż nie da się określić typu raportu, można wydrukować prosty raport w postaci tabeli (wierszy i kolumn) zawierającej rekordy utworzone przez kwerendę. Podczas drukowania zbioru wynikowego dostępnych jest jednak kilka możliwości. Jeśli mamy pewność, że arkusz danych został skonfigurowany w postaci, jaka nam odpowiada, możemy ustawić kilka opcji, postępując zgodnie z poniższą instrukcją: 1. Wykorzystaj utworzoną przed chwilą kwerendę zwracającą klientów z województwa pomorskiego, którzy byli aktywni po 1 stycznia 2012 roku. 2. Jeżeli nie jesteś w widoku arkusza danych, uruchom kwerendę poprzez kliknięcie przycisku Uruchom w grupie Wyniki na wstążce. 3. Wybierz opcję Drukuj z menu Plik, będąc w oknie arkusza danych kwerendy. 4. Określ wybrane opcje w oknie dialogowym Drukowanie i kliknij OK.
264
Część III Kwerendy Accessa
Wydruk będzie odzwierciedlał wszelkie właściwości i rozmieszczenie elementów arkusza danych. Ukryte kolumny nie będą drukowane, a linie siatki będą drukowane tylko wtedy, gdy zostanie zaznaczona odpowiednia opcja. W wydruku będą także uwzględnione szerokości kolumn oraz wysokości wierszy.
Zapisywanie kwerendy Aby zapisać kwerendę, należy kliknąć przycisk Zapisz na pasku szybkiego dostępu w górnej części okna Accessa. Jeśli zapisujemy kwerendę po raz pierwszy, Access wyświetli pytanie o jej nazwę. Po zapisaniu kwerendy Access powróci do poprzedniego trybu pracy. Czasami występuje potrzeba zapisania kwerendy i zakończenia jej projektowania w pojedynczej operacji. W tym celu należy kliknąć przycisk Zamknij okno w prawym górnym rogu okna widoku projektu kwerendy. Przed właściwym zapisaniem kwerendy Access zawsze wyświetla prośbę o potwierdzenie zamiaru zapisania zmian.
Tworzenie kwerend bazujących na wielu tabelach Używanie kwerend do pobierania informacji z pojedynczej tabeli jest dość popularne, często jednak potrzebne są informacje z kilku powiązanych ze sobą tabel. Na przykład mogą być potrzebne nazwiska klientów (nabywców) wraz z zakupionymi towarami. Zdefiniowanie takiej kwerendy wymaga użycia czterech tabel: tblCustomers, tblSales, tblSalesLineItems i tblProducts. W rozdziale 3. poznałeś klucze główne i obce oraz ich znaczenie dla łączenia ze sobą dwóch tabel. Nauczyłeś się, jak tworzyć relacje między tabelami, korzystając z okna Relacje. Na końcu dowiedziałeś się, co to są więzy integralności i w jaki sposób oddziałują na dane w tabelach.
Po utworzeniu tabel bazy danych i zdecydowaniu, w jaki sposób mają być ze sobą powiązane, można tworzyć kwerendy bazujące na wielu tabelach, umożliwiające pobieranie informacji z kilku tabel naraz. Kwerenda wyświetla dane z wielu tabel i prezentuje je w taki sposób, jakby dane pochodziły z jednej rozbudowanej tabeli. Pierwszym krokiem procesu tworzenia kwerendy bazującej na wielu tabelach jest dodanie każdej z nich do okna projektu kwerendy. 1. Utwórz nową kwerendę poprzez kliknięcie przycisku Projekt kwerendy w grupie Tworzenie na wstążce. 2. Wybierz tabele tblCustomers, tblSales, tblSalesLineItems i tblProducts poprzez dwukrotne kliknięcie nazwy każdej z tabel w oknie dialogowym Pokazywanie tabeli. 3. Kliknij przycisk Zamknij.
Rozdział 8. Pobieranie danych za pomocą kwerend
265
Tabele możesz dodawać także osobno, zaznaczając je po kolei i klikając przycisk Dodaj.
Na rysunku 8.17 pokazano górny obszar okna projektu kwerendy zawierający cztery dodane przed chwilą tabele. W kwerendzie automatycznie pojawiły się linie łączące tabele, ponieważ relacje zdefiniowano na poziomie tabel.
Rysunek 8.17. Okno projektu kwerendy po dodaniu czterech tabel. Zwróćmy uwagę na widoczne linie łączące tabele W dowolnym momencie można dodać do kwerendy więcej tabel. W tym celu należy wybrać polecenie Pokaż tabelę znajdujące się na wstążce Projekt kwerendy. Można też kliknąć prawym przyciskiem myszy okno projektowe i wybrać opcję Pokaż tabelę z menu kontekstowego.
Pola z więcej niż jednej tabeli dodaje się do kwerendy dokładnie w taki sposób, w jaki robi się to w przypadku pojedynczej tabeli. Można dodać jedno pole, kilka pól zgrupowanych razem lub wszystkie pola z tabeli. Jeżeli wybierzesz pole, które występuje w kilku tabelach, Access przed nazwą pola doda nazwę tabeli, z której ono pochodzi, oraz kropkę. Na przykład pole ProductID znajduje się w kilku tabelach używanych w oknie projektowym kwerendy (w tabelach tblProducts i tblSalesLineItems). Gdy dodasz to pole z tabeli tblSalesLineItems, pojawi się ono w siatce jako tblSalesLineItems.ProductID. Pomaga to określić właściwą nazwę pola. Za pomocą tej techniki można wskazać nazwę pola z konkretnej tabeli. Najłatwiejszym sposobem wyboru pól jest dwukrotne kliknięcie ich nazw w górnej części okna projektu kwerendy. W tym celu czasami trzeba powiększyć okno listy pól tak, aby potrzebne pola były widoczne.
Przeglądanie nazw tabel W trakcie pracy z kilkoma tabelami nazwy pól w siatce QBE mogą być niejednoznaczne. Czasami zadajemy sobie pytanie w rodzaju: „z której tabeli pochodzi pole Description?”.
266
Część III Kwerendy Accessa
Access automatycznie przypisuje nazwę tabeli każdemu polu wyświetlanemu w obszarze siatki QBE. Na rysunku 8.18 pokazano okno projektu kwerendy z nazwami poszczególnych tabel wyświetlającymi się pod nazwami pól w obszarze siatki QBE. Rysunek 8.18. Obszar siatki QBE z wyświetlonymi nazwami pól. Zwróćmy uwagę, że wyświetlają się nazwy wszystkich czterech tabel
Dodawanie wielu pól Proces dodawania kilku pól naraz w kwerendzie bazującej na wielu tabelach jest dokładnie taki sam jak w przypadku kwerendy wykorzystującej pojedynczą tabelę. Aby dodać kilka pól z wielu tabel, w jednej operacji można dodać pola tylko z jednej tabeli. Najłatwiejszym sposobem wykonania tej operacji jest zaznaczenie wybranych pól i przeciągnięcie ich do obszaru QBE. Kilka sąsiadujących ze sobą pól można zaznaczyć, klikając pierwsze z nich, a następnie — przy wciśniętym klawiszu Shift — klikając ostatnie. Pola, które ze sobą nie sąsiadują, można zaznaczać, klikając je kolejno przy wciśniętym klawiszu Ctrl. Wybranie gwiazdki (*) ma jeden minus: dla kolumny tego typu nie można określić kryteriów. Aby uzyskać taką możliwość, trzeba dodać osobno wybrane pola i w ich kolumnach zdefiniować kryteria. W przypadku dodania pola w celu określenia kryterium (gdy jednocześnie wybrano gwiazdkę) kwerenda wyświetli pole dwukrotnie — ze względu na gwiazdkę i wskutek działania kolumny z kryterium. Aby tego uniknąć, można anulować zaznaczenie komórki Pokaż w kolumnie zawierającej kryterium.
Ograniczenia dla kwerend bazujących na wielu tabelach W przypadku kwerend utworzonych na podstawie wielu tabel istnieją ograniczenia dotyczące tego, które pola można edytować. Generalnie dane występujące w zbiorze wynikowym można modyfikować, a wprowadzane zmiany są uwzględniane także w tabelach bazowych. Najważniejszym wyjątkiem jest klucz główny tabeli — nie można edytować jego wartości, jeśli zaznaczono opcję wymuszania więzów integralności i jeśli pole wchodzi w skład relacji. Czasem programista chce ręcznie modyfikować wynikowy zbiór rekordów zwrócony przez kwerendę. Rekordy zawarte w tabelach Accessa nie zawsze można modyfikować. W tabeli 8.1 przedstawiono, w jakich okolicznościach pole w tabeli można modyfikować. Jak widać, kwerendy bazujące na relacji typu jeden do wielu są modyfikowalne w zakresie obydwu tabel (w zależności od sposobu zaprojektowania kwerendy).
Rozdział 8. Pobieranie danych za pomocą kwerend
267
Tabela 8.1. Zasady modyfikowalności kwerend Typ kwerendy lub pola
Modyfikowalna
Pojedyncza tabela
Tak
Relacja typu jeden do jednego
Tak
Wynik zawiera pole typu Długi tekst
Tak
Modyfikowalne pole typu Długi tekst
Wynik zawiera hiperłącze
Tak
Modyfikowalne hiperłącze
Wynik zawiera obiekt OLE
Tak
Modyfikowalny obiekt OLE
Relacje jeden do wielu
Zazwyczaj
Ograniczenia wynikające z metodyki projektowania (zobacz tekst)
Relacje wiele do jednego do wielu
Nie
Komentarz
Można modyfikować dane w formularzu lub na stronie dostępu do danych, jeżeli wartością właściwości Typ zestawu rekordów jest Dynamiczny
Dwie lub więcej tabel bez linii sprzężeń
Nie
Aby umożliwić modyfikację, trzeba utworzyć sprzężenie
Kwerenda krzyżowa
Nie
Tworzy chwilową migawkę danych
Kwerendy podsumowujące (Suma, Średnia itp.)
Nie
Operuje na pogrupowanych danych, tworząc chwilową migawkę danych
Właściwość Wartości unikatowe ma wartość Tak
Nie
Wyświetla unikatowe rekordy tylko w chwilowej migawce danych
Kwerendy z SQL-a
Nie
Kwerendy składające oraz przekazujące operują na danych poprzez ODBC
Pola obliczeniowe
Nie
Są obliczane automatycznie
Pola tylko do odczytu
Nie
Jeżeli są otwarte w trybie tylko do odczytu lub z dysku tylko do odczytu (np. CD-ROM)
Odmowa dostępu
Nie
Brak uprawnień do wstawiania, zmiany i usuwania rekordów
Tabele ODBC bez klucza głównego
Nie
Musi istnieć unikatowy identyfikator
Tabele Paradox bez klucza głównego
Nie
Musi istnieć klucz główny
Zablokowane przez innego użytkownika
Nie
Nie można wprowadzić modyfikacji, jeżeli pole jest zablokowane przez kogoś innego
Obchodzenie ograniczeń dotyczących kwerend Z tabeli 8.1 wynika, że istnieją sytuacje, w których kwerendy oraz pola w nich zawarte nie są modyfikowalne. Ogólna zasada jest taka, że żadna kwerenda wykonująca obliczenia podsumowujące lub bazująca na źródle danych ODBC (ang. Open DataBase Connectivity) nie jest modyfikowalna. Większość innych kwerend umożliwia wprowadzanie modyfikacji. Jeżeli kwerenda zawiera więcej niż jedną tabelę i niektóre z nich są połączone relacją typu jeden do wielu, mogą istnieć w niej pola, których zawartości nie można modyfikować (w zależności od struktury kwerendy).
268
Część III Kwerendy Accessa
Modyfikowanie unikatowych indeksów (kluczy głównych) Jeżeli kwerenda używa dwóch tabel połączonych relacją typu jeden do wielu, kwerenda musi zawierać klucz główny z tabeli po stronie „jeden”. Access potrzebuje wartości klucza po to, by mógł znaleźć powiązane ze sobą rekordy w obu tabelach. Zastępowanie istniejących danych w wynikach kwerendy bazującej na tabelach powiązanych relacjami typu jeden do wielu Normalnie w kwerendach typu jeden do wielu wszystkie pola w tabeli ze strony „wiele” (np. tabeli tblSales) relacji są modyfikowalne. Po stronie „jeden” relacji (tblCustomers) można modyfikować wszystkie pola z wyjątkiem pola klucza głównego. W większości baz danych jest to wystarczające. Pole klucza głównego w tabeli ze strony „jeden” relacji jest rzadko modyfikowane, ponieważ służy ono do łączenia z rekordami w powiązanych tabelach. Aktualizacja pól w kwerendach Aby można było dodawać rekordy do obydwu tabel relacji typu jeden do wielu, należy uwzględnić w kwerendzie klucz obcy ze strony „wiele” relacji i wyświetlić go w arkuszu danych. Dzięki temu będzie można dodawać rekordy, rozpoczynając od dowolnej tabeli. Pole klucza głównego ze strony „jeden” relacji będzie automatycznie kopiowane do pola sprzęgającego ze strony „wiele”. Aby dodawać rekordy do wielu tabel za pomocą formularza (opisano to w rozdziałach 17. i 18.), należy pamiętać o umieszczeniu na formularzu wszystkich (lub większości) pól z obu tabel. W przeciwnym razie formularz nie będzie zawierał kompletnych danych rekordu.
Obszar tabel Górna część okna projektu kwerendy (obszar tabel) zawiera ważne informacje dla działania kwerendy. Umiejętność posługiwania się obszarem tabel i sposobami wykonywania działań z listą pól ma kluczowe znaczenie dla budowania złożonych kwerend. Linie widoczne w tym obszarze są już gotowe, ponieważ między tabelami utworzono już relacje opisane w rozdziale 4.
Linie sprzężeń Tabele w oknie projektu kwerendy są połączone liniami sprzężeń (zobacz rysunek 8.17). Każda linia łączy pole klucza głównego z jednej tabeli z polem klucza obcego w innej tabeli. Linia sprzężenia reprezentuje relację istniejącą między dwiema tabelami w bazie danych Accessa. W naszym przykładzie jedna z linii sprzężeń łączy pole ContactID z tabeli tblCustomers z polem Buyer z tabeli tblSales. Linie zostały utworzone automatycznie, ponieważ wcześniej dla tabel zdefiniowano relacje. Jeżeli dla relacji zdefiniowano opcję wymuszania więzów integralności, Access wyświetli skrajne odcinki linii jako pogrubione. Jeżeli relacja jest typu jeden do wielu, to tabela ze strony „wiele” relacji jest oznaczona symbolem nieskończoności (∞).
Rozdział 8. Pobieranie danych za pomocą kwerend
269
Access automatycznie utworzy sprzężenie między tabelami, jeśli będą spełnione następujące warunki:
W obydwu tabelach istnieje pole o tej samej nazwie.
Pola o tej samej nazwie w obydwu tabelach są tego samego typu (tekstowe, liczbowe itp.). Warto zauważyć, że typ danych Autonumerowanie jest traktowany tak jak typy liczbowe (jako długa liczba całkowita).
W jednej z tabel wybrane pole jest kluczem głównym. Po zdefiniowaniu relacji między tabelami wyświetlają się linie sprzężeń łączące dwa pola. W czasie przewijania zawartości listy pól położenie linii zmienia się wraz ze względnym położeniem odpowiednich pól. Na przykład jeżeli przesunie się w dół belkę przewijania okna tblCustomers, linia sprzężenia przemieści się w górę wraz z polem numeru klienta, zatrzymując się dopiero na górnej krawędzi okna.
W czasie pracy z wieloma tabelami linie sprzężeń mogą sprawiać wrażenie zagmatwanych — często nakładają się i przecinają. Jeżeli przewiniemy zawartość okna listy, linie, których przeznaczenie dotąd nie było jasne, będą widoczne i stanie się oczywiste, których pól dotyczą.
Przesuwanie tabel Listy pól można przesuwać w obrębie obszaru tabel, umieszczając wskaźnik myszy nad paskiem tytułowym okna (na którym wyświetla się nazwa tabeli), a następnie przeciągając listę w nowe miejsce. Listy pól można przesuwać w celu uporządkowania zagmatwanego widoku schematu bazy danych i tym samym ułatwienia sobie pracy. Listy pól można umieszczać w dowolnym miejscu górnego obszaru okna. Można je rozciągać i zmieniać ich kolejność. Podczas zapisywania lub zamykania kwerendy Access zapisuje rozmieszczenie list pól. Przy następnym otwarciu kwerendy okna z listami pól wyświetlą się w takiej samej konfiguracji, w jakiej je pozostawiliśmy.
Usuwanie tabel Istnieją sytuacje, w których trzeba usunąć tabele z kwerendy. Aby usunąć tabelę, należy za pomocą myszy zaznaczyć ją w górnej części okna projektu kwerendy, a następnie wcisnąć klawisz Delete. Można też kliknąć prawym przyciskiem myszy wybraną listę pól, a następnie z menu podręcznego wybrać polecenie Usuń tabelę. Oczywiście usunięcie tabeli z projektu kwerendy nie usuwa tabeli z bazy danych. Po usunięciu tabeli z projektu kwerendy usuwane są także wszystkie związane z nią linie sprzężeń. Przed usunięciem nie wyświetla się żadne ostrzeżenie ani prośba o potwierdzenie zamiaru usunięcia. Tabela jest po prostu usuwana z ekranu razem z wszystkimi jej polami dodanymi do siatki QBE. Należy jednak pamiętać, że odwołania do usuniętych tabel w polach obliczeniowych nie zostaną usunięte. Odwołania „fantomowe” mogą powodować problemy podczas prób uruchomienia kwerendy. Szczegółowe omówienie pól obliczeniowych znajdziesz w rozdziale 12.
270
Część III Kwerendy Accessa
Dodawanie kolejnych tabel Do kwerendy można dodawać kolejne tabele. Można też przywrócić tabelę usuniętą przez pomyłkę. Aby przeprowadzić te operacje, należy kliknąć przycisk Pokaż tabelę w grupie Konfiguracja kwerendy w zakładce PROJEKTOWANIE. Wówczas na ekranie wyświetli się okno dialogowe Pokazywanie tabeli.
Tworzenie sprzężeń w kwerendach i ich obsługa Często trzeba utworzyć kwerendę, w której uzyskanie pożądanych wyników wymaga złączenia dwóch lub więcej powiązanych tabel. Możliwe, że chcesz złączyć tabelę pracowników z tabelą transakcji, aby utworzyć raport z informacjami o transakcjach oraz o pracownikach, którzy je obsługiwali. Od rodzaju sprzężenia zależy, które rekordy zostaną zwrócone.
Wprowadzenie do sprzężeń Istnieją trzy podstawowe rodzaje sprzężeń (inaczej złączeń): wewnętrzne, zewnętrzne lewostronne i zewnętrzne prawostronne.
Sprzężenia wewnętrzne — operacja ta nakazuje Accessowi pobranie z obu tabel tylko tych rekordów, które zawierają pasujące do siebie wartości. Wyniki zwracane przez kwerendę obejmują tylko te rekordy, w których w polach uwzględnianych w sprzężeniu w obu tabelach występuje ta sama wartość. Na rysunku 8.19 przedstawiamy sprzężenie wewnętrzne w formie graficznej.
Rysunek 8.19. Sprzężenie zewnętrzne powoduje pobranie tylko tych rekordów, które w obu tabelach mają pasujące do siebie wartości. Strzałka pokazuje, które rekordy znajdą się w wynikach
Lewostronne sprzężenie zewnętrzne — operacja ta nakazuje Accessowi pobranie wszystkich rekordów z pierwszej tabeli oraz tych rekordów z drugiej tabeli, które w polu uwzględnianym w sprzężeniu mają wartości pasujące do rekordów z pierwszej tabeli. Na rysunku 8.20 przedstawiamy lewostronne sprzężenie zewnętrzne w formie graficznej.
Rozdział 8. Pobieranie danych za pomocą kwerend
271
Rysunek 8.20. Lewostronne sprzężenie zewnętrzne powoduje pobranie wszystkich rekordów z pierwszej tabeli i tych rekordów z drugiej tabeli, które mają pasujące wartości. Strzałki pokazują, które rekordy znajdą się w wynikach
Prawostronne sprzężenie zewnętrzne — operacja ta nakazuje Accessowi pobranie wszystkich rekordów z drugiej tabeli oraz tych rekordów z pierwszej tabeli, które w polu uwzględnianym w sprzężeniu mają wartości pasujące do rekordów z drugiej tabeli (zobacz rysunek 8.21).
Rysunek 8.21. Prawostronne sprzężenie zewnętrzne powoduje pobranie wszystkich rekordów z drugiej tabeli i tylko tych rekordów z pierwszej tabeli, które mają pasujące wartości. Strzałki pokazują, które rekordy znajdą się w wynikach
Kwerenda Accessa domyślnie zwraca tylko te wiersze, w których dane występują po obu stronach relacji. Oznacza to na przykład, że kwerenda pobierająca dane z tabel klientów i transakcji zwraca rekordy tylko wtedy, gdy klienci dokonali jakichś transakcji. W związku z tym w wynikach kwerendy nie pojawią się dane klientów, którzy jeszcze nie brali udziału w żadnej z transakcji. Jeśli rekordowi klienta nie odpowiada co najmniej jeden rekord transakcji, taki rekord nie znajdzie się w wynikach kwerendy. Oznacza to, że czasami kwerenda nie zwróci wszystkich rekordów, jakich można by się spodziewać. Chociaż jest to najpopularniejszy typ sprzężenia między tabelami w kwerendzie, czasami użytkownicy chcą zobaczyć wszystkie dane z tabeli (np. tabeli tblCustomers w poprzednim przykładzie), niezależnie od tego, czy odpowiadają im rekordy w powiązanej tabeli. Niekiedy użytkownicy są specjalnie zainteresowani rekordami, które nie mają odpowiedników po przeciwnej stronie sprzężenia. Pomyśl np. o pracownikach działu handlowego zainteresowanych listą wszystkich klientów, którzy niczego nie kupili w poprzednim roku. Aby uruchomić taką kwerendę, trzeba zmodyfikować domyślne działanie sprzężenia.
272
Część III Kwerendy Accessa
Sprzężenie między tabelami można utworzyć za pomocą trzech metod:
Tworząc relację między tabelami na etapie projektowania bazy danych.
Poprzez wybranie do kwerendy dwóch tabel zawierających pole o takiej samej nazwie i takim samym typie danych, które w jednej z tabel jest kluczem głównym.
Poprzez modyfikację domyślnego działania sprzężenia.
Pierwsze dwie metody działają w oknie kwerendy automatycznie. W przypadku dodania powiązanych ze sobą tabel do kwerendy Access automatycznie wyświetli relacje zachodzące między nimi w oknie projektu kwerendy. Również automatycznie utworzy sprzężenie między dwiema tabelami zawierającymi takie same pole, pod warunkiem, że pole to jest w jednej z tabel kluczem głównym oraz w oknie opcji zaznaczono pole wyboru Włącz autosprzęganie (jest to ustawienie domyślne). Jeśli relacje zostaną ustawione za pomocą kreatora relacji, linia autosprzężenia może się nie wyświetlić w następujących sytuacjach:
Dwie tabele zawierają wspólne pole, ale w każdej z nich ma ono inną nazwę.
Tabela nie jest i nie może być logicznie powiązana z inną tabelą (np. nie można tabeli tblCustomers połączyć bezpośrednio z tabelą tblSalesLineItems).
Jeżeli w kwerendzie występują tabele, które nie zostały połączone za pomocą relacji, a chcemy je ze sobą powiązać w kwerendzie, możemy to zrobić w oknie projektu kwerendy. Utworzenie sprzężenia między tabelami w oknie projektu kwerendy nie powoduje powstania między tymi tabelami stałego połączenia. Utworzone sprzężenie (relacja) obowiązuje wyłącznie na czas działania kwerendy. Tabele wykorzystywane w kwerendzie muszą być ze sobą w jakiś sposób powiązane. W przypadku dołączenia dwóch tabel, które nie mają ze sobą nic wspólnego (np. kwerenda bazująca na tabelach tblCustomers i tblProducts bez żadnej tabeli pośredniej), Access nie będzie miał sposobu na wyznaczenie rekordów z tabeli tblCustomers, które odpowiadają rekordom z tabeli tblProducts. Jeśli nie istnieje sposób powiązania tabel ze sobą, Access zwróci bezużyteczne dane.
Wykorzystywanie sprzężeń ad hoc Na rysunku 8.22 pokazano prostą kwerendę zawierającą tabele tblSales, tblSalesLineItems, tblProducts i tblCategories. Występuje tu automatyczne sprzężenie, utworzone w momencie dodania do kwerendy tabeli tblCategories. Między tabelami tblProducts i tblCategories nie istniała do tej pory żadna formalna relacja. Access znalazł jednak w obu tabelach pole Category i wykrył, że oba pola są tego samego typu i że pole Category w tabeli tblCategories jest kluczem głównym. Z tego względu dodał linię sprzężenia ad hoc między tymi tabelami. Tabele wchodzące w skład kwerendy nie są sprzęgane automatycznie, jeżeli nie istnieje wiążąca je relacja na poziomie tabel, jeżeli nie mają wspólnego pola dla klucza głównego lub jeżeli wyłączona jest opcja autosprzęgania.
Rozdział 8. Pobieranie danych za pomocą kwerend
273
Rysunek 8.22. Sprzężenie ad hoc między tabelami tblProducts i tblCategories
Gdyby Access nie ustanowił automatycznego sprzężenia między tabelami tblProducts i tblCategories (np. ze względu na różne nazwy pola Category w obu tabelach), można by z łatwością zdefiniować sprzężenie poprzez przeciągnięcie pola Category z jednej tabeli i upuszczenie go na odpowiadającym mu polu w drugiej tabeli.
Określanie typu sprzężenia Problem w przypadku większości sprzężeń polega na tym, że w czasie działania kwerendy są one interpretowane jako równozłączenia. Jeśli w kwerendzie pokazanej na rysunku 8.19 istnieje rekord produktu, któremu nie przypisano kategorii (np. nie przypisano kategorii do samochodu), kwerenda nie zwróci żadnych rekordów, jeśli rekordowi produktu nie będzie odpowiadał rekord kategorii. Problem polega tu na tym, że nie można stwierdzić, iż jakiegoś rekordu brakuje. Jedynym sposobem, by stwierdzić, że powinno być więcej rekordów, jest dokładne przeanalizowanie rekordów transakcji lub utworzenie innej kwerendy zliczającej wszystkie transakcje albo wykonującej jakąś inną operację sprawdzającą. Aby uzyskać dokładny obraz transakcji, trzeba zmodyfikować właściwości sprzężenia między tabelami tblProducts i tblCategories. Aby to zrobić, należy kliknąć prawym przyciskiem myszy cienką linię sprzężenia między tabelami tblProducts i tblCategories, a następnie z menu podręcznego wybrać polecenie Właściwości sprzężenia. W wyniku tej operacji otworzy się okno dialogowe Właściwości sprzężenia (zobacz rysunek 8.23), w którym można zdefiniować inny rodzaj sprzężenia między tabelami. W oknie na rysunku 8.23 wybrano trzecią opcję (Uwzględnia wszystkie rekordy z 'tblProducts'…) — pierwsza opcja jest domyślna. Druga i trzecia opcja są określane jako lewostronne oraz prawostronne sprzężenie zewnętrzne i instruują Accessa, aby pobierał wszystkie rekordy z lewej (lub prawej) tabeli wchodzącej w skład sprzężenia, niezależnie od tego, czy odpowiadają im rekordy po jego drugiej stronie.
274
Część III Kwerendy Accessa
Rysunek 8.23. Wybór zewnętrznego sprzężenia dla kwerendy
Wynik działania kwerendy z nowym sprzężeniem przedstawia rysunek 8.24. W prawym dolnym rogu na tym rysunku pokazano sposób zdefiniowania sprzężenia zewnętrznego w oknie projektu kwerendy. Na pozostałej części rysunku widać wynikowy zbiór rekordów zwracanych przez zapytanie.
Rysunek 8.24. Problemy brakujących produktów z rysunku 8.23 można wyeliminować dzięki zastosowaniu prawostronnego sprzężenia zewnętrznego
Oczywiście można z łatwością zdefiniować sprzężenia, które nie mają sensu, jednak w przypadku przeglądania wyników zawierających takie sprzężenia łatwo się zorientować, że zwrócone dane nie są tymi, o które nam chodziło. Jeśli dla połączonych ze sobą pól nie istnieją wspólne wartości, otrzymamy arkusz danych niezawierający żadnych rekordów. Nigdy nie należy tworzyć sprzężeń, które nie mają sensu. Na przykład nie należy tworzyć sprzężenia między polem City z tabeli tblCustomer a polem SalesDate z tabeli tblSales. Chociaż Access nie wyklucza tworzenia takich sprzężeń, w uzyskanym zbiorze wyników nie będzie żadnych rekordów.
Usuwanie sprzężeń Aby usunąć linię sprzężenia łączącego dwie tabele, należy ją zaznaczyć, a następnie nacisnąć klawisz Delete. Aby zaznaczyć linię, należy wskazać ją myszą i kliknąć w dowolnym miejscu.
Rozdział 8. Pobieranie danych za pomocą kwerend
275
Jeżeli usunie się sprzężenie między dwiema tabelami, co spowoduje, że w oknie projektu kwerendy pozostaną niepołączone ze sobą tabele, w wyniku wyświetlą się nieoczekiwane dane wykorzystujące iloczyn kartezjański utworzony przez Accessa dla tych tabel. Iloczyn kartezjański będzie obliczany tylko dla tej kwerendy. Relacja zdefiniowana na poziomie systemu pozostanie nienaruszona.
Access umożliwia tworzenie między tabelami sprzężeń wykorzystujących wiele pól (wyświetli się więcej niż jedna linia). Oba pola muszą zawierać wspólne dane, w przeciwnym razie kwerenda nie znajdzie żadnych rekordów, które mogłaby wyświetlić w arkuszu danych.
276
Część III Kwerendy Accessa
Rozdział 9.
Stosowanie operatorów i wyrażeń W tym rozdziale:
Stosowanie operatorów w wyrażeniach
Tworzenie złożonych kwerend
Tworzenie kwerend z prostymi kryteriami
Wprowadzanie wielu kryteriów w kwerendach
Tworzenie złożonych kryteriów w kwerendach
W poprzednich rozdziałach tworzyliśmy kwerendy, wykorzystując wybrane pola z jednej lub kilku tabel. Wykorzystywaliśmy również sortowanie i definiowaliśmy kryteria, które miały na celu ograniczenie listy wyników zwracanych przez kwerendę. W tym rozdziale koncentrujemy się na używaniu operatorów i wyrażeń do obliczania danych, porównywania wartości i wyświetlania danych w różnych formatach — używając kwerend do tworzenia przykładów. W tym rozdziale do zademonstrowania użycia operatorów i funkcji wykorzystano kwerendy, jednak zasady omawiane w ćwiczeniach zamieszczonych w niniejszym rozdziale mają zastosowanie wszędzie, gdzie w Accessie stosuje się operatory i wyrażenia. Wyjściową bazę danych dla tego rozdziału, Rozdział09.accdb, można pobrać z witryny poświęconej tej książce.
Wprowadzenie w tematykę operatorów Operatory pozwalają porównywać wartości, łączyć łańcuchy tekstu, formatować dane i wykonywać rozmaite inne zadania. Operatorów używamy po to, by poinstruować Accessa, aby wykonał określone działanie w odniesieniu do jednego lub większej liczby operandów. Kombinację operatorów i operandów określa się jako wyrażenie.
278
Część III Kwerendy Accessa W tym rozdziale bardzo często będziemy spotykali się z terminem wartościowanie (ang. evaluation). Kiedy Access napotyka pole, wyrażenie, zmienną itp., to określa wartość tego elementu i wewnętrznie się nią posługuje. Wyrażenia należy tworzyć w taki sposób, aby Access prawidłowo wyznaczał ich wartość. Jeśli Access nieprawidłowo obliczy wartość wyrażenia, to aplikacja nie będzie działała zgodnie z oczekiwaniami. Zrozumienie sposobu, w jaki Access określa wartości kryteriów kwerend i wyrażeń używanych w kodzie VBA, ma kluczowe znaczenie dla odniesienia sukcesu w roli programisty aplikacji Accessa.
Operatorów używa się za każdym razem, kiedy tworzy się równanie w Accessie. Operatory służą np. do sprawdzania poprawności danych we właściwościach tabeli, tworzenia pól obliczeniowych w formularzach i raportach oraz określania kryteriów w kwerendach.
Typy operatorów Operatory można pogrupować na następujące typy:
operatory matematyczne,
operatory porównań,
operatory łańcuchowe,
operatory logiczne,
operatory różne.
Operatory matematyczne Operatory matematyczne określa się również mianem „operatory arytmetyczne”, ponieważ stosowane są do wykonywania obliczeń arytmetycznych. Z definicji służą do pracy z liczbami (operandy to liczby). Działają na dowolnym liczbowym typie danych. Może to być wartość stała, wartość zmiennej albo zawartość pola. Liczb można używać pojedynczo albo łączyć je w celu utworzenia wyrażeń złożonych. Istnieje siedem podstawowych operatorów matematycznych. +
dodawanie
–
odejmowanie
*
mnożenie
/
dzielenie
\
dzielenie całkowite
^
potęgowanie
Mod
modulo
Operatory matematyczne omawiane w tym punkcie zwykle stosuje się w polach obliczeniowych. Szczegółowy opis pól tego rodzaju znajdziesz w rozdziale 12.
Rozdział 9. Stosowanie operatorów i wyrażeń
279
Operator dodawania: +
Aby utworzyć pole obliczeniowe w kwerendzie, która dodaje wartość podatku do ceny netto, można użyć wyrażenia w postaci zamieszczonej poniżej: [Podatek] + [Cena]
Operator odejmowania: –
Operator odejmowania (znak minus –) realizuje proste odejmowanie, np. przy obliczaniu ostatecznej kwoty faktury z uwzględnieniem rabatu: [Cena] - ([Cena] * [ProcentRabatu])
Choć nawiasy nie są operatorami matematycznymi, odgrywają kluczową rolę w wielu wyrażeniach. Wyjaśniono to w podrozdziale „Priorytety operatorów”.
Operator mnożenia: *
Operatora mnożenia (*) używa się na przykład po to, aby obliczyć łączną cenę w przypadku kupowania kilku sztuk tego samego towaru. Można zaprojektować kwerendę wyświetlającą liczbę kupionych sztuk i cenę za sztukę, a dalej umieścić kolumnę zawierającą wartość uzyskaną z pomnożenia liczby sztuk i ceny za sztukę. Takie wyrażenie może mieć następującą postać: [Liczba] * [Cena]
Operator dzielenia: /
Operator dzielenia (/) służy do dzielenia dwóch liczb. Przypuśćmy, że w określonym tygodniu 212 osób wygrało na loterii łączną kwotę 1 000 000 złotych. Wyrażenie, które oblicza wygraną każdej osoby (4716,98 złotych), ma następująca postać: 1000000 / 212
Zwróć uwagę, że liczba 1000000 została zapisana bez separatorów tysięcy. Access nie potrafi wykonywać działań matematycznych na wartościach liczbowych zapisanych ze znakami interpunkcyjnymi. Operator dzielenia całkowitego: \
Operator dzielenia całkowitego (\) pobiera dowolne dwie liczby (liczba1 i liczba2), zaokrągla je w górę lub w dół do liczb całkowitych, dzieli pierwszą liczbę przez drugą (liczba1 / liczba2), a następnie odcina część ułamkową wyniku, pozostawiając tylko wartość całkowitą. Oto kilka przykładów ilustrujących różnice między dzieleniem całkowitym a zwykłym dzieleniem: Zwykłe dzielenie
Dzielenie z konwersją do liczb całkowitych
100 / 6 = 16,667
100 \ 6 = 16
100,9 / 6,6 = 15,288
100,9 \ 6,6 = 14
102 / 7 = 14,571
102 \ 7 = 14
280
Część III Kwerendy Accessa Access zaokrągla liczby według zasady znanej jako „zaokrąglenie bankiera” albo „zaokrąglaj połowę do parzystej”. Zaokrąglanie zawsze wykonywane jest do najbliższej liczby parzystej. Tak więc liczba 6,5 po zaokrągleniu ma wartość 6, natomiast liczba 7,5 po zaokrągleniu ma wartość 8. Oczywiście zasada ta obowiązuje tylko wtedy, kiedy wartość zaokrąglanej liczby znajduje się dokładnie pośrodku pomiędzy dwiema liczbami całkowitymi. Jak można się spodziewać, liczba 6,51 po zaokrągleniu ma wartość 7, natomiast 6,49 ma wartość 6. Operator potęgowania: ^
Operator potęgowania (^) podnosi liczbę do potęgi określonej przez wykładnik. Podniesienie do potęgi oznacza pomnożenie liczby przez samą siebie. Na przykład mnożenie 4 × 3 4 × 4 (tzn. 4 ) odpowiada formule 4 ^ 3. Wykładnik nie musi być liczbą całkowitą. Może to być nawet liczba ujemna. Na przykład wyrażenie 2 ^ 2.1 zwraca wartość 4,28709385014517, natomiast 4 ^ –2 zwraca wartość 0,0625. Operator reszty z dzielenia: Mod
Operator modulo (Mod) pobiera dowolne dwie liczby (liczba1 i liczba2), zaokrągla je w górę lub w dół do liczb całkowitych, dzieli pierwszą liczbę przez drugą (liczba1 / liczba2) i zwraca resztę z dzielenia. Oto kilka przykładów ilustrujących różnice między dzieleniem modulo a zwykłym dzieleniem: Zwykłe dzielenie
Dzielenie modulo
Objaśnienie
10 / 5 = 2
10 Mod 5 = 0
10 dzieli się przez 5 bez reszty
10 / 4 = 2,5
10 Mod 4 = 2
10 / 4 = 2 z resztą 2
22,24 / 4 = 5,56
22,24 Mod 4 = 2
22 / 4 = 5 z resztą 2
22,52 / 4 = 5,63
22,52 Mod 4 = 3
23 / 4 = 5 z resztą 3
Wynik dzielenia modulo to reszta po całkowitoliczbowym podzieleniu operandów przez siebie. Operator Mod jest często wykorzystywany do określania, czy liczba jest parzysta, czy nieparzysta. Aby się o tym dowiedzieć, wystarczy podzielić liczbę modulo 2: 5 Mod 2 = 1 4 Mod 2 = 0
Jeśli działanie Mod zwraca 1, to dzielna jest liczbą nieparzystą. Jeśli działanie Mod zwraca 0, to dzielna jest liczbą parzystą. Operatory porównań Operatory z tej grupy porównują dwie wartości lub dwa wyrażenia za pośrednictwem równania. W Accessie dostępnych jest sześć podstawowych operatorów porównania: =
równy
<>
nierówny
<
mniejszy
<=
mniejszy lub równy
>
większy
>=
większy lub równy
Rozdział 9. Stosowanie operatorów i wyrażeń
281
Wartością wyrażeń z operatorami porównań zawsze jest True, False lub Null. Wartość Null jest zwracana w przypadku, kiedy nie można określić wartości wyrażenia. Podczas lektury poniższych objaśnień należy pamiętać, że w Accessie w większości przypadków wielkość liter nie ma znaczenia. Na przykład ciągi znaków "OSOBOWY", "Osobowy" i "osobowy" są dla Accessa identyczne. W Accessie wyrażenia z operatorami porównań w rzeczywistości zwracają wartości liczbowe. Liczba –1 reprezentuje True, natomiast 0 reprezentuje False.
Jeśli dowolna strona równania ma wartość Null, wynikiem zawsze jest Null. Operator równości: =
Operator równości (=) zwraca wartość logiczną True, jeśli porównywane wyrażenia są takie same. Oto przykład: Kategoria = "Osobowe"
Zwraca wartość True, jeśli pole Kategoria ma wartość "Osobowe". Dla innych kategorii zwraca False.
DataSprzedaży = Date()
Zwraca True, jeśli w polu DataSprzedaży jest data dzisiejsza, oraz False dla pozostałych dat.
Operator nierówności: <>
Operator nierówności (<>) to przeciwieństwo operatora równości. Oto przykład: Kategoria <> "Osobowe" Zwraca True, jeśli produkt należy do kategorii innej niż "Osobowe". Zwraca False tylko wtedy, gdy pole Kategoria ma wartość "Osobowe". Operator mniejszości: <
Operator mniejszości (<) zwraca wartość logiczną True, jeśli lewa strona równania jest mniejsza od strony prawej, jak w poniższym przykładzie: Cena < 1000
Zwraca True, jeśli pole Cena zawiera wartość mniejszą niż 1000, i False, jeśli pole Cena zawiera wartość większą niż 1000 lub jej równą.
Co ciekawe, operator mniejszości można swobodnie stosować w odniesieniu do ciągów znaków (podobnie jak większość operatorów porównań). Na przykład poniższe wyrażenie zwraca False: "Mężczyzna" < "Kobieta"
Nie ma w tym żadnej filozofii — w przypadku operandów będących ciągami znaków Access wykonuje porównywanie znak po znaku. Ponieważ litera M znajduje się w alfabecie za literą K, słowo „mężczyzna” nie jest mniejsze niż słowo „kobieta”. Możliwość porównywania ciągów znaków jest bardzo cenna podczas sortowania danych tekstowych albo porządkowania nazw w określonej kolejności. W ciągach znaków w Accessie nie ma znaczenia wielkość liter, dlatego ciąg XYZ nie jest większy od xyz.
282
Część III Kwerendy Accessa
Przy porównywaniu liczb zapisanych jako tekst wyniki mogą być niezgodne z oczekiwaniami. Na przykład wartość 9 zostanie uznana za większą niż 10, ponieważ cyfra 1 znajduje się przed cyfrą 9. Operator mniejszości lub równości: <=
Operator mniejszości lub równości (<=) zwraca wartość logiczną True, jeśli operand po lewej stronie równania jest mniejszy lub równy względem operandu po stronie prawej, tak jak w poniższym przykładzie: Cena <= 2500
Zwraca True, jeśli Cena równa się 2500 lub jest mniejsza niż 2500. Zwraca False dla dowolnej wartości Cena, która jest większa od 2500.
Operatory porównań należy odpowiednio zapisywać. Access zgłasza błąd, jeśli wpiszemy =<. Kolejność znaków w zapisie operatorów ma znaczenie, zatem trzeba najpierw wpisać znak mniejszości, a potem równości: <=. Operator większości: >
Operator większości (>) to przeciwieństwo operatora mniejszości. Operator ten zwraca True, jeśli operand po lewej stronie równania jest większy niż operand po stronie prawej. Oto przykład: StawkaPodatkowa > 3.5
Zwraca True, jeśli wartość pola StawkaPodatkowa zawiera wartość większą niż 3,5, i False, kiedy StawkaPodatkowa jest mniejsza lub równa 3,5.
Operator większości lub równości: >=
Operator większości lub równości (>=) zwraca True, jeśli lewa strona równania jest większa lub równa prawej stronie. Oto przykład: StawkaPodatkowa >= 5
Zwraca wartość True, jeśli StawkaPodatkowa ma wartość 5 bądź większą. Zwraca False, jeżeli StawkaPodatkowa ma wartość mniejszą niż 5.
Operatory łańcuchowe W Accessie są dostępne trzy operatory łańcuchowe wykorzystywane do pracy z ciągami znaków. W odróżnieniu od operatorów matematycznych i logicznych operatory łańcuchowe zostały specjalnie zaprojektowane do pracy z danymi typu tekstowego: & konkatenacja operandów Like
operandy są podobne
Not Like
operandy nie są podobne
Operator konkatenacji: &
Operator konkatenacji łączy dwa lub więcej obiektów w wynikowy łańcuch. W pewnym sensie konkatenacja przypomina dodawanie. Jednak w odróżnieniu od dodawania zawsze zwraca ciąg znaków: [Imię] & [Nazwisko]
Rozdział 9. Stosowanie operatorów i wyrażeń
283
W zwracanym ciągu znaków pomiędzy imieniem a nazwiskiem nie ma spacji. Jeśli pole [Imię] ma wartość "Jerzy", a pole [Nazwisko] wartość "Kowalski", to operacja konkatenacji zwróci łańcuch "JerzyKowalski". Aby dodać spację między imieniem a nazwiskiem, trzeba ją po prostu dodać pomiędzy operandami tak, jak pokazano poniżej: [Imię] & " " & [Nazwisko]
Operator konkatenacji może łączyć obiekt tekstowy z obiektem liczbowym albo datą. Dzięki temu nie trzeba używać specjalnych funkcji do przekształcania liczb lub dat na postać tekstową. Przypuśćmy, że mamy pole tekstowe (NazwaUlicy) oraz pole z liczbą (NumerDomu) i chcemy zbudować wyrażenie łączące zawartość obu pól: [NazwaUlicy] & " " & [NumerDomu]
Jeśli NumerDomu ma wartość 45, a NazwaUlicy to "ulica Akacjowa", ich połączenie da następujący wynik: "ulica Akacjowa 45"
Zwracany ciąg znaków został ujęty w cudzysłów dla zwiększenia czytelności.
Przypuśćmy, że chcemy umieścić w stopce raportu pole NazwiskoOperatora oraz datę i czas sporządzenia raportu. Można to zrobić za pomocą następującego wyrażenia: [NazwiskoOperatora] & " wydrukował ten raport " & Now()
Zwróćmy uwagę na spację przed słowem „wydrukował” i za słowem „raport”. Jeśli jest 21 marca 2012 roku, godzina 16.45, powyższy wiersz wyświetli tekst zbliżony do poniższego: Mariusz Kwiatkowski wydrukował ten raport 21.03.12 16:45:40
Konkatenację można także zrealizować za pomocą operatora dodawania (+). Na przykład aby połączyć pola Imię i Nazwisko z tabeli klientów tak, aby wyświetlić je jako pojedynczy ciąg znaków, można skorzystać z wyrażenia: [Imię] + [Nazwisko]
Znajomość działania operatora konkatenacji ułatwia tworzenie i modyfikowanie wyrażeń w bazie danych. Jeśli zawsze używa się operatora łączenia (&) zamiast operatora dodawania (+) do tworzenia łańcuchów tekstowych, nie trzeba się martwić typami danych łączonych obiektów. Każda formuła zawierająca operator & automatycznie przekształca wszystkie łączone obiekty w tekstowy typ danych. Stosowanie operatora dodawania (+) do łączenia ciągów znaków czasami może powodować nieprzewidziane wyniki, ponieważ Access musi stwierdzić, czy operandy są liczbami, czy ciągami znaków, i na tej podstawie wykonać właściwe działania. Operator konkatenacji wymusza interpretowanie operandów jako ciągów znaków i powoduje, że wynik zawsze jest ciągiem znaków.
284
Część III Kwerendy Accessa
Chociaż w roli operatora konkatenacji można wykorzystać zarówno znak ampersand (&), jak i znak plus (+), stosowanie plusa w niektórych sytuacjach może prowadzić do uzyskiwania nieoczekiwanych wyników. Konkatenacja dwóch wartości z zastosowaniem operatora & zawsze zwraca ciąg znaków. Operandami operatora konkatenacji mogą być ciągi znaków, liczby, daty i godziny albo odwołania do pól, ale wynik zawsze jest ciągiem znaków. Ponieważ ampersand zawsze zwraca ciąg znaków, często wykorzystuje się go w celu zabezpieczenia przed generowaniem błędów Invalid use of null powstających podczas pracy z danymi, które mogą mieć wartość null. Załóżmy na przykład, że w formularzu Accessa jest pole tekstowe, które może, lecz nie musi zawierać wartości, gdyż nie mamy pewności, czy użytkownik wprowadził w nim jakieś dane. Podczas podstawiania zawartości pola tekstowego do zmiennej (zmienne zostaną szczegółowo omówione w rozdziale 10.) niektórzy programiści wykorzystują konkatenację pustego ciągu znaków z zawartością pola tekstowego: MojaZmienna = txtNazwisko & ""
Dzięki zastosowaniu operatora & mamy pewność, że nawet jeśli pole tekstowe zawiera wartość null, to do zmiennej będzie przypisany ciąg znaków i nie powstanie błąd. Z kolei operacja konkatenacji z operatorem plus zwraca null, jeśli jeden z operandów ma wartość null: MojaZmienna = txtNazwisko + ""
W tym przypadku, jeśli pole tekstowe txtNazwisko ma wartość null, może dojść do powstania błędu Invalid use of null. Wynikiem konkatenacji jest bowiem wartość null (oczywiście przy założeniu, że pole txtNazwisko zawiera wartość null). Doświadczeni programiści Accessa rezerwują operator + dla działań arytmetycznych, natomiast do konkatenacji ciągów znaków zawsze używają operatora &. Operatory Like (podobny do) oraz Not Like
Operator Like oraz jego przeciwieństwo, operator Not Like, służą do porównywania dwóch wyrażeń tekstowych. Operatory te ustalają, czy jedno wyrażenie pasuje, czy też nie pasuje do wzorca przechowywanego w drugim wyrażeniu. Wynikiem tego porównania jest wartość True, False lub Null. W działaniach Like oraz Not Like nie ma znaczenia wielkość liter. Operator Like ma następującą składnię: wyrażenie Like wzorzec
Operator Like szuka wyrażenia wyrażenia we wzorcu. Jeśli wyrażenie występuje we wzorcu, operator zwraca wartość True. Oto przykład: [Imię] Like "Jerzy"
Zwraca True, jeśli pole Imię ma wartość "Jerzy".
[Nazwisko] Like "KOWAL*"
Zwraca True, jeśli Nazwisko to Kowal, Kowalski lub dowolne inne zaczynające się od Kowal, niezależnie od wielkości liter. (Symbole wieloznaczne, takie jak np. *, zostaną omówione w ramce „Symbole wieloznaczne”).
Rozdział 9. Stosowanie operatorów i wyrażeń [Województwo] Not Like "Mazowieckie"
285
Zwraca True dla każdego województwa z wyjątkiem mazowieckiego.
Jeśli którekolwiek wyrażenie w formule Like ma wartość Null, wynikiem jest Null.
Operatory Like i Not Like to wartościowe oraz elastyczne narzędzia do porównywania ciągów znaków. Możliwości używania operatora Like są zwiększane dzięki symbolom wieloznacznym. Symbole wieloznaczne W poniższej tabeli zaprezentowano pięć symboli wieloznacznych, które można wykorzystywać z operatorem Like. Symbol
Przeznaczenie
?
Jeden znak (0 – 9, Aa – Zz)
*
Dowolna liczba znaków (od 0 do n)
#
Jedna cyfra (0 – 9)
[lista]
Jeden dowolny znak spośród tych, które znajdują się na liście
[!lista]
Jeden dowolny znak spośród tych, które nie znajdują się na liście
W zapisie [lista] lub [!lista] można użyć myślnika między dwoma znakami, aby określić zakres. Oto kilka przykładów: [tblKlienci].[Nazwisko] Like "Ko*"
Zwraca True w przypadku każdego nazwiska, które zaczyna się od „Ko” lub „KO”. Wszystkie ciągi znaków, które nie rozpoczynają się od „Ko” lub „KO”, zwracają False.
[Odpowiedź] Like "[A-D]"
Zwraca True, jeśli odpowiedź brzmi: A, B, C, D, a, b, c lub d. Wszystkie pozostałe litery zwracają False.
"AB1989" Like "AB####"
Zwraca True, ponieważ łańcuch zaczyna się od liter „AB”, po których następują cztery cyfry.
[Nazwisko] Not Like "[A,E,I,O,U]*"
Zwraca True dla nazwisk, które nie zaczynają się na samogłoskę. Kowalski i Jankowski zwracają True, Adamski i Oleksiak zwracają False.
[Miasto] Like "?????"
Zwraca True dla nazwy każdego miasta składającej się z pięciu liter.
286
Część III Kwerendy Accessa Jeśli wzorzec, który chcemy dopasować, zawiera znak symbolu wieloznacznego, należy ująć go w nawiasy kwadratowe. W powyższym przykładzie zastosowanie zapisu [*] we wzorcu powoduje, że gwiazdka na trzeciej pozycji jest interpretowana literalnie. "AB*Co" Like "AB[*]C*"
Ponieważ gwiazdka została ujęta w nawiasy kwadratowe, Access nie pomyli jej z gwiazdką — symbolem wieloznacznym.
Operatory logiczne Operatory logiczne służą do definiowania złożonych warunków w wyrażeniach. Podobnie jak operatory porównań, zawsze zwracają wartości True, False lub Null. Oto operatory logiczne: And
Zwraca TRUE, jeśli Wyrażenie1 i Wyrażenie2 mają wartość TRUE.
Or
Zwraca TRUE, jeśli Wyrażenie1 lub Wyrażenie2 ma wartość TRUE (wartość tę mogą mieć oba wyrażenia).
Not
Zwraca TRUE, jeśli Wyrażenie ma wartość inną niż TRUE.
Xor
Zwraca TRUE, jeśli Wyrażenie1 lub Wyrażenie2 ma wartość TRUE (wartości tej nie mogą mieć oba wyrażenia).
Eqv
Zwraca TRUE, jeśli Wyrażenie1 i Wyrażenie2 mają tę samą wartość (TRUE lub FALSE).
Imp
Przeprowadza porównanie bitów z tych samych pozycji z dwóch wyrażeń liczbowych.
Operator And
Operator And służy do wykonywania logicznej koniunkcji dwóch wyrażeń. Zwraca True, gdy oba wyrażenia mają wartość True. Ogólna składnia operacji And to: wyrażenie1 And wyrażenie2
Oto przykład: [tblKlienci].[Województwo] = "Mazowieckie" And [tblKlienci].[KodPocztowy] = "00-212".
Zwraca True tylko wtedy, gdy oba wyrażenia mają wartość True.
Sposób działania operacji And zależy od tego, w jaki sposób Access określi wartość dwóch operandów. W tabeli 9.1 opisano wszystkie możliwe wyniki w przypadkach, kiedy operandy mają wartości True lub False. Zwróćmy uwagę, że operator And zwraca True tylko wtedy, gdy oba operandy mają wartość True. Operator Or
Operator Or służy do obliczania logicznej dysjunkcji dwóch wyrażeń. Zwraca wartość True, jeśli dowolny z warunków zwraca True. Ogólna składnia operacji Or to: Wyrażenie1 Or Wyrażenie2
Rozdział 9. Stosowanie operatorów i wyrażeń
287
Tabela 9.1. Wyniki działania operatora And Wyrażenie1
Wyrażenie2
Wyrażenie1 And Wyrażenie2
True
True
True
True
False
False
True
Null
Null
False
True
False
False
False
False
False
Null
False
Null
True
Null
Null
False
False
Null
Null
Null
Działanie operatora Or ilustrują poniższe przykłady: [Nazwisko] = "Janik" Or [Nazwisko] = "Górski"
Zwraca True, jeśli nazwisko brzmi „Janik” lub „Górski”.
[StrefaPodatkowa] = "Łódzkie" Or [StrefaPodatkowa] = "Warmińskie"
Zwraca True, jeśli strefa podatkowa to „Łódzkie” albo „Warmińskie”.
Operator Or (podobnie jak And) zwraca True lub False w zależności od tego, w jaki sposób Access określi wartości operandów. W tabeli 9.2 przedstawiono wszystkie możliwe kombinacje wartości dwóch operandów. Zwróćmy uwagę, że operator Or zwraca False tylko wtedy, gdy oba operandy mają wartość False. Tabela 9.2. Wyniki działania operatora Or Wyrażenie1
Wyrażenie2
Wyrażenie1 Or Wyrażenie2
True
True
True
True
False
True
True
Null
True
False
True
True
False
False
False
False
Null
Null
Null
True
True
Null
False
Null
Null
Null
Null
Operator Not
Operator Not służy do negowania wyrażenia liczbowego lub logicznego. Zwraca wartość True, jeśli wyrażenie ma wartość False, i wartość False, jeśli wyrażenie ma wartość True. Ogólna składnia operacji Not to: Not wyrażenie [liczbowe | logiczne]
288
Część III Kwerendy Accessa
Przykład użycia operatora Not zaprezentowano poniżej: Not [Cena] <= 100000
Zwraca True, jeśli cena jest większa niż 100 000.
If Not (Miasto = "Szczecin") Then
Zwraca True dla dowolnego miasta z wyjątkiem Szczecina.
Jeśli operand ma wartość Null, operator Not zwraca wartość Null. Wszystkie możliwe wyniki działania operatora Not zestawiono w tabeli 9.3. Tabela 9.3. Wyniki działania operatora Not Wyrażenie
Not Wyrażenie
True
False
False
True
Null
Null
Operatory różne Access ma trzy bardzo przydatne operatory do obsługi różnych typów danych: Between...And
zakres
In
porównanie z listą
Is
słowo zarezerwowane
Operator Between...And
Operator Between...And pozwala ustalić, czy wartość wyrażenia należy do określonego zakresu wartości. wyrażenie Between wartość1 And wartość2
Jeśli wartość wyrażenia mieści się w zakresie między wartość1 a wartość2, wynikiem jest True, a w przeciwnym razie — False. Warto zauważyć, że operator Between...And zwraca True także dla wartości równych wartościom skrajnym, czyli działa podobnie jak operatory >= i <=. Przykłady użycia operatora Between...And zaprezentowano poniżej: [ŁącznaCena] Between 10000 And 19999
Zwraca True, jeśli pole ŁącznaCena ma wartość z zakresu pomiędzy 10 000 i 19 999 lub wynosi 10 000 bądź 19 999.
[DataSprzedaży] Between #1/1/2012# and #12/31/2012#
Zwraca True, jeśli pole DataSprzedaży odpowiada dacie z 2012 roku.
Wraz z operatorem Between...And można także używać operatora Not w celu zanegowania logiki: Not [DataSprzedaży] Between #1/1/2012# and #12/31/2012#
Zwraca True, jeśli pole DataSprzedaży odpowiada dacie spoza pierwszego kwartału 2012 roku.
Rozdział 9. Stosowanie operatorów i wyrażeń
289
Operator In
Operator In pozwala ustalić, czy wyrażenie ma wartość równą którejkolwiek z wartości podanych na liście. Ogólna składnia operatora In jest następująca: wyrażenie In (wartość1; wartość2; wartość3; ...)
Jeśli wartość wyrażenia zostanie znaleziona na liście, wynikiem jest True, a w przeciwnym razie — False. W poniższym przykładzie użyto operatora In jako kryterium dla pola Kategoria w kwerendzie: In ("SUV-y"; "Ciężarówki")
Kwerenda wyświetli tylko te pojazdy, które należą do kategorii "SUV-y" lub "Ciężarówki". Z operatora In można także korzystać w języku VBA. If [tblKlienci].[Miasto] In("Szczecin", "Toruń") Then
W tym przypadku treść instrukcji If...Then...Else będzie wykonana tylko wtedy, gdy pole Miasto ma wartość "Szczecin" lub "Toruń". Wartość zwracaną przez operację In można zanegować za pomocą słowa kluczowego Not: If strMiasto Not In ("Malbork", "Sztum") Then
W tym przypadku treść instrukcji If...Then...Else będzie wykonana tylko wtedy, gdy zmienna strMiasto ma wartość inną niż "Malbork" albo "Sztum". Operator Is
Operatora Is używa się zwykle w połączeniu ze słowem kluczowym Null, aby ustalić, czy wartość wyrażenia to Null. wyrażenie Is Null
W języku VBA operator Is można wykorzystać do porównywania różnych obiektów w celu stwierdzenia, czy są identyczne. Przykład użycia operatora Is zamieszczono poniżej: [Nazwisko] Is Null
Zwraca True, jeśli pole Nazwisko ma wartość Null. Zwraca False, jeśli w polu Nazwisko znajduje się jakakolwiek inna wartość.
Warto zwrócić uwagę, że operator Is ma zastosowanie tylko do obiektów i zmiennych obiektowych, np. pól w tabelach. Operatora Is nie można wykorzystywać ze zmiennymi typów prostych, np. ciągami znaków lub liczbami.
Priorytety operatorów Podczas pracy ze skomplikowanymi wyrażeniami zawierającymi wiele operatorów Access musi ustalić, który składnik wyrażenia obliczyć jako pierwszy, który jako drugi itd. W tym celu wykonuje działania z dobrze znaną, z góry ustaloną kolejnością działań
290
Część III Kwerendy Accessa
matematycznych i logicznych. Kolejność tę określa się mianem priorytetu operatorów. Access zawsze oblicza wyrażenia w takiej kolejności, chyba że użyje się nawiasów, aby określić inną kolejność. Operacje w nawiasach są wykonywane przed wszystkimi operacjami poza nawiasami. Wewnątrz nawiasów stosuje się domyślny priorytet operatorów. Priorytet określa się najpierw według kategorii operatora. Oto ranga operatorów według malejącego priorytetu: 1. matematyczne 2. porównania 3. logiczne Każda kategoria ma wewnętrzne priorytety operatorów, co wyjaśniamy w poniższych punktach. Priorytety operatorów matematyczny W kategorii operatorów matematycznych obowiązują następujące priorytety: 1. potęgowanie 2. negacja 3. mnożenie i (lub) dzielenie (od lewej do prawej) 4. dzielenie całkowite 5. dzielenie modulo 6. dodawanie i (lub) odejmowanie (od lewej do prawej) 7. łączenie ciągów znaków Priorytety operatorów porównania Operatory porównania mają następujący priorytet: 1. równy 2. nierówny 3. mniejszy 4. większy 5. mniejszy lub równy 6. większy lub równy 7. Like
Rozdział 9. Stosowanie operatorów i wyrażeń
291
Priorytety operatorów logicznych W kategorii operatorów logicznych obowiązuje następujący priorytet: 1. Not 2. And 3. Or 4. Xor 5. Eqv 6. Imp
Stosowanie operatorów i wyrażeń w kwerendach Jednym z najbardziej powszechnych zastosowań operatorów i wyrażeń jest tworzenie kryteriów w złożonych kwerendach. Dzięki dokładnemu zrozumieniu sposobu tworzenia tych konstrukcji proces budowania skomplikowanych kwerend zwracających przydatne wyniki będzie łatwiejszy. Niniejszy podrozdział jest poświęcony tematyce tworzenia kryteriów kwerend z wykorzystaniem operatorów i wyrażeń. Niektóre informacje w pozostałej części tego rozdziału pokrywają się z zagadnieniami omawianymi wcześniej, ale w kontekście projektowania kwerend. Umiejętność określania kryteriów ma kluczowe znaczenie dla projektowania i pisania efektywnych kwerend. Choć kwerendy mogą odwoływać się do jednej tabeli i używać tylko jednego kryterium, większość kwerend wydobywa informacje z wielu tabel na podstawie bardziej złożonych kryteriów. Ze względu na tę złożoność kwerendy powinny pobierać tylko te dane, które są nam potrzebne, w określonej kolejności. Można na przykład wybrać i wyświetlić dane z bazy danych w celu uzyskania następujących informacji:
Wszyscy nabywcy samochodów Chevrolet albo ciężarówek Ford.
Wszyscy nabywcy, którzy kupili coś w ciągu ostatnich 60 dni.
Wszystkie transakcje na kwotę większą niż 90 złotych.
Liczba klientów w każdym województwie.
Klienci, którzy zgłosili uwagi lub zażalenia.
W miarę rozwoju systemu baz danych użytkownicy żądają różnych danych podobnych do tych, które wymieniliśmy powyżej. Używając operatorów i wyrażeń, tworzy się złożone kwerendy wybierające, które umożliwiają ograniczenie liczby zwracanych rekordów. W tym podrozdziale omówiono kwerendy wybierające, które wykorzystują operatory i wyrażenia. W dalszej części książki wykorzystamy tę wiedzę do pracy z formularzami, raportami i kodem VBA.
292
Część III Kwerendy Accessa
Szczegółowy opis pracy z kwerendami zamieszczamy w rozdziale 8.
Używanie operatorów porównania w kwerendach Pracując z kwerendami wybierającymi, czasem trzeba określić jedno lub więcej kryteriów, aby ograniczyć zakres wyświetlanych informacji. Kryteria określa się za pomocą operatorów porównania w równaniach i obliczeniach. Operatory dzielą się na następujące kategorie: matematyczne, relacyjne, logiczne i tekstowe. W kwerendach wybierających operatorów używa się w komórkach Pole: lub Kryteria: obszaru zapytania przez przykład (ang. Query by Example — QBE). Najpopularniejsze operatory wykorzystywane w kwerendach wybierających przedstawiono w tabeli 9.4. Tabela 9.4. Operatory często używane w kwerendach wybierających Matematyczne
Relacyjne
Logiczne
Tekstowe
Różne
* (mnożenie)
= (równy)
And
& (konkatenacja)
Between...And
/ (dzielenie)
<> (nierówny)
Or
Like
In
+ (dodawanie)
> (większy)
Not
Not Like
Is Null
– (odejmowanie)
< (mniejszy)
Is Not Null
Za pomocą tych operatorów można wyszukać między innymi następujące grupy rekordów:
Rekordy produktów zawierające zdjęcie.
Zakres rekordów, np. wszystkie transakcje od listopada do stycznia.
Rekordy spełniające kryteria And oraz Or, np. wszystkie rekordy, które są samochodami i nie są ciężarówką ani samochodem terenowym.
Wszystkie rekordy, które nie pasują do określonej wartości, np. dowolny produkt, który nie jest samochodem.
Kiedy dodajemy kryterium do kwerendy, używamy odpowiedniego operatora wraz z przykładem tego, czego szukamy. Na rysunku 9.1 przykładem są samochody Osobowe. Operator to znak równości (=). Zauważmy, że znaku równości nie pokazano na rysunku, bowiem znak ten jest domyślnym operatorem dla kwerend wybierających.
Tworzenie złożonych kryteriów Złożone kryteria kwerend można budować, wykorzystując dowolną kombinację operatorów przedstawionych w tabeli 9.4. W wielu kwerendach złożone kryteria zawierają liczne operatory And i Or, tak jak w poniższych przykładach:
Województwem musi być mazowieckie lub zachodniopomorskie.
Miastem musi być Konin i województwem musi być wielkopolskie.
Województwem musi być opolskie lub pomorskie i miastem musi być Brzeg.
Rozdział 9. Stosowanie operatorów i wyrażeń
293
Rysunek 9.1. Siatka QBE pokazuje proste kryterium, które nakazuje wybrać wszystkie modele należące do kategorii Osobowe
Przykłady te ilustrują użycie obu operatorów logicznych: And i Or. Złożone kryteria da się często utworzyć, wpisując przykładowe dane w różnych komórkach siatki QBE, tak jak pokazano na rysunku 9.2, gdzie kryteria wprowadzono zarówno w kolumnie State, jak i w kolumnie Category. W kolumnie State kryteria określają „mazowieckie lub zachodniopomorskie”, natomiast w kolumnie Category jest dodatkowe kryterium: „inne niż osobowe”. Po uwzględnieniu kryteriów w obu kolumnach kwerenda zwraca tylko rekordy odpowiadające klientom z województw mazowieckiego albo zachodniopomorskiego oraz produktom z innych kategorii niż samochody osobowe.
Rysunek 9.2. Używanie kryteriów And i Or w kwerendach
Bezpośrednie używanie operatorów logicznych nie jest jednak jedynym sposobem wybierania rekordów na podstawie wielu kryteriów. Na rysunku 9.3 zademonstrowano powszechnie stosowaną w Accessie technikę korzystania ze złożonych kryteriów całkowicie
294
Część III Kwerendy Accessa
Rysunek 9.3. Tworzenie złożonych kryteriów bez używania operatorów And i Or
bez wprowadzania słów kluczowych And i Or. W tym przykładzie kryteria zostały umieszczone jedno pod drugim w jednej kolumnie, co odpowiada użyciu operatora Or. Na przykład w kolumnie State kryteria można zinterpretować jako "Śląskie" Or "Mazowieckie". Obecność kryteriów w innej kolumnie siatki QBE implikuje użycie operatora And. Dlatego kryteria z kolumny Category zostały scalone z kryteriami w kolumnie State i zinterpretowane w następujący sposób: (State = "Śląskie" And Category <> "Osobowe") Or (State = "Mazowieckie" And Category <> "Osobowe")
Kwerendy z rysunków 9.2 i 9.3 są równoważne i zwracają takie same dane. Jednym ze skomplikowanych aspektów kwerendy z rysunku 9.3 jest konieczność dwukrotnego zdefiniowania kryterium w kolumnie Category — raz dla każdej wartości w kolumnie State. Gdyby kryterium dla kolumny Category występowało tylko raz — na przykład w tym samym wierszu co Zachodniopomorskie w kolumnie State — całe kryterium zostałoby zinterpretowane w następujący sposób: (State = "Śląskie" and Category <> "Osobowe") Or (State = "Mazowieckie")
O tym, w jaki sposób utworzyć tego typu kwerendę złożoną, dowiesz się w punkcie „Wprowadzanie kryteriów w wielu polach” w dalszej części tego rozdziału. W obszarze siatki QBE kryteria And wpisuje się w tym samym wierszu, natomiast kryteria Or wpisuje się w różnych wierszach.
Access przekształca tę graficzną kwerendę w pojedynczą instrukcję SELECT języka SQL, która pobiera informacje z tabel. Aby zmienić zawartość okna i wyświetlić instrukcję SQL-a SELECT (pokazaną na rysunku 9.4), należy kliknąć strzałkę rozwijanej listy w grupie Widok na wstążce i wybrać polecenie Widok SQL. Access tworzy instrukcję SQL-a na podstawie pól i kryteriów wprowadzonych w obszarze siatki QBE (zobacz rysunek 9.3).
Rozdział 9. Stosowanie operatorów i wyrażeń
295
Rysunek 9.4. Widok SQL odpowiadający kwerendzie z rysunku 9.3. Zwróćmy uwagę, że instrukcja SQL-a zawiera jeden operator OR oraz dwa operatory AND (wewnątrz klauzuli WHERE)
Instrukcja SQL-a z rysunku 9.4 jest podzielona na części, żeby była bardziej czytelna. Po otwarciu okna SQL-a wyświetla się jedna długa instrukcja zajmująca kilka wierszy — bez przerw pomiędzy poszczególnymi częściami. Wyrażenie określające kryterium dla tej kwerendy ma następującą postać: (tblCustomers.State = "Zachodniopomorskie" AND tblProducts.Category <> "Osobowe") OR (tblCustomers.State = "Mazowieckie" AND tblProducts.Category <> "Osobowe")
Kryterium dla kategorii (<> "Osobowe") należy wprowadzić dla każdego województwa w siatce QBE, tak jak pokazano na rysunku 9.3. Z dalszej części tego rozdziału, w punkcie „Wprowadzanie kryteriów w wielu polach”, dowiesz się, jak używać operatorów And i Or w komórce Kryteria: kwerendy, co pozwoli uniknąć wielokrotnego wypełniania tych pól. W tym przykładzie szukaliśmy wszystkich modeli, które w polu Category nie miały wartości "Osobowe". Aby znaleźć rekordy pasujące do pewnej wartości, wystarczy pominąć operator <>. Na przykład należy wpisać wyrażenie Osobowe, aby znaleźć wszystkie pojazdy będące samochodami osobowymi. Podczas tworzenia kryteriów w obszarze siatki QBE dla kwerend wybierających nie trzeba używać znaku równości (=). And i Or to najczęściej używane operatory w kryteriach złożonych. Operatory oceniają dwa różne wyrażenia (po jednym po każdej stronie operatora And lub Or) i niezależnie ustalają, czy mają one wartość True czy False. Następnie porównują ze sobą wyniki dwóch wyrażeń, aby uzyskać logiczną odpowiedź: prawda lub fałsz. Przyjrzyj się pierwszej instrukcji And z formuły z poprzedniego akapitu: (tblCustomers.State = "Zachodniopomorskie" AND tblProducts.Category <> "Osobowe")
Prawa strona wyrażenia kryterium (tblProducts.Category <> "Osobowe") przyjmuje wartość True, jeżeli pole Category ma dowolną wartość różną od "Osobowe". Operator And porównuje logiczne wartości wyrażeń z lewej i prawej strony, aby uzyskać ostateczny wynik True lub False. Pole ma wartość Null, jeśli nie ma żadnej wartości. Null oznacza, że w polu nie wprowadzono żadnych informacji. Null nie jest ani prawdą, ani fałszem, nie odpowiada też samym spacjom czy zeru — to po prostu brak wartości. Jeśli nie wpiszemy nazwy miasta w polu Miasto, Access pozostawi je puste (chyba że w projekcie tabeli zdefiniowano wartość domyślną). Tę pustkę określa się mianem Null.
Kiedy wynikiem porównania And/Or jest wartość True, cały warunek jest prawdziwy i kwerenda wyświetla rekordy spełniające kryterium.
296
Część III Kwerendy Accessa
Warto zwrócić uwagę, że operator And zwraca True tylko wtedy, gdy obie strony wyrażenia mają wartość True, natomiast operator Or zwraca wartość True wtedy, gdy którakolwiek strona ma wartość True. W rzeczywistości jedna strona może mieć wartość Null, a operator Or będzie miał wartość True, jeśli druga strona ma wartość True. Właśnie na tym polega podstawowa różnica między operatorami And i Or.
Używanie funkcji w kwerendach wybierających Podczas pracy z kwerendami można wyświetlać informacje za pomocą wbudowanych funkcji Accessa. Można na przykład wyświetlić takie elementy, jak:
Dzień tygodnia (niedziela, poniedziałek itd.) odpowiadający dacie sprzedaży.
Wszystkie nazwiska klientów wielkimi literami.
Różnica między dwoma polami daty.
Aby wyświetlić te informacje, trzeba utworzyć w kwerendzie pole obliczeniowe. Pola obliczeniowe zostały szczegółowo opisane w rozdziale 12. (a także w wielu innych miejscach w tej książce).
Odwoływanie się do pól w kwerendach wybierających Kiedy podajemy nazwę pola w kwerendzie, bardzo często należy ująć ją w nawias kwadratowy ([]). Access wymaga nawiasów dla każdej nazwy pola umieszczonej w kryterium i dla każdej nazwy pola zawierającej spacje lub znaki interpunkcyjne. Oto przykład odwołania się do pola z wykorzystaniem nawiasów kwadratowych: [tblSales].[SaleDate] + 30
W tym przykładzie dodajemy 30 dni do wartości pola SaleDate z tabeli tblSales. Jeśli pominie się nawiasy kwadratowe ([]) podczas wpisywania nazwy pola w siatce QBE, Access może umieścić ją w cudzysłowie i uznać za tekst zamiast za nazwę pola.
Wpisywanie kryteriów jednowartościowych W niektórych sytuacjach trzeba ograniczyć rekordy zwracane przez kwerendę według wartości jednego pola, jak w poniższych przykładach:
Informacje o klientach (nabywcach) mieszkających w województwie mazowieckim.
Dane o sprzedaży modeli ciężarówek.
Klienci, którzy kupili coś w styczniu.
Każda z tych kwerend wymaga kryterium jednowartościowego. Kryterium jednowartościowe polega na wprowadzeniu tylko jednego wyrażenia w siatce QBE. Wyrażeniem mogą być przykładowe dane, takie jak „Mazowieckie”, albo funkcja, taka jak DatePart("m",[Sale
Rozdział 9. Stosowanie operatorów i wyrażeń
297
Date]) = 1. Kryteria można określić dla dowolnego typu danych: Krótki tekst, Liczba, Data/Godzina itp., a nawet dla pól typu Obiekt OLE i Autonumerowanie.
Wprowadzanie kryteriów znakowych (Krótki tekst lub Długi tekst) Kryteriów znakowych używa się w polach typu Krótki tekst lub Długi tekst. Są to albo przykłady, albo informacje o zawartości pola. Na przykład aby utworzyć kwerendę zwracającą klientów mieszkających w województwie mazowieckim, wykonaj poniższe czynności: 1. Otwórz nową kwerendę bazującą na tabeli tblCustomers w widoku projektu i dodaj do siatki QBE pola FirstName, LastName i State. 2. Kliknij komórkę Kryteria: pod polem State. 3. Wpisz w komórce Mazowieckie. Kwerenda powinna mieć postać pokazaną na rysunku 9.5. Zwróć uwagę, że otwarta jest tylko jedna tabela i wybrano tylko trzy pola. Aby obejrzeć wyniki tej kwerendy, kliknij polecenie Widok arkusza danych w grupie Widok na wstążce. Rysunek 9.5. Okno projektu kwerendy z otwartą tabelą tblCustomers
Nie trzeba wpisywać znaku równości przed słowem Mazowieckie, ponieważ to jest kwerenda wybierająca. Aby zobaczyć wszystkie województwa z wyjątkiem mazowieckiego, należy wpisać znak nierówności (<>) albo operator Not przed słowem Mazowieckie. Nie trzeba również ujmować w cudzysłów słowa Mazowieckie. Access zakłada, że używamy tekstowego literału Mazowieckie, i automatycznie dodaje cudzysłów. Dane zawierające cudzysłowy i apostrofy wymagają specjalnej uwagi. Dla przykładu rozważmy kwerendę, która ma wyszukać osobę o nazwisku podanym jako Robert „Robi” Nowak. W idealnym przypadku w tabeli klientów powinno znaleźć się pole Pseudonim, gdzie można by wpisać pseudonim "Robi". Skoro jednak go nie ma, operator może wpisać imię jako Robert "Robi", używając cudzysłowu do oznaczenia pseudonimu.
298
Część III Kwerendy Accessa
W tym przypadku Access zinterpretuje znaki cudzysłowu jako dane, a w przyszłości może się pojawić potrzeba uwzględnienia znaków cudzysłowu w kryterium kwerendy. Najprostszym rozwiązaniem jest skorzystanie z wyrażenia kryterium w następującej postaci: 'Robert "Robi"'
Zwróć uwagę na apostrofy otaczające ciąg kryterium. Access prawidłowo zinterpretuje apostrofy jako ograniczniki. W tym przypadku cudzysłowy wewnątrz apostrofów będą potraktowane jako zwykłe dane. Nie należy używać wyrażeń w następującej postaci: "Robert 'Robi'"
W tym przypadku, w porównaniu z poprzednim przykładem, zamieniliśmy miejscami apostrofy z cudzysłowami. W takiej sytuacji Access oczekuje znalezienia apostrofów w polu imienia (oczekuje, że pseudonim zapisano jako 'Robi'), zatem kwerenda nie zwróci żadnych rekordów.
Operator Like i symbole wieloznaczne W poprzednich podrozdziałach pracowaliśmy z kryteriami dosłownymi. Podawaliśmy zawartość pola, którą ma znaleźć Access; w poprzednim przykładzie był to tekst Mazowieckie. Access używał literału do wyszukania odpowiednich rekordów. Czasem jednak znamy tylko część zawartości pola albo chcemy zobaczyć większy zakres rekordów w oparciu o pewien wzorzec. Na przykład mogą nas interesować informacje o wszystkich produktach, które w opisie mają słowo „kabriolet”. Taki opis może pasować do wielu marek i modeli. W bazie danych nie ma natomiast pola, w którym można by wpisać słowo „kabriolet” i użyć go jako samodzielnego kryterium kwerendy. Aby mieć pewność, że właściwie wybraliśmy wszystkie rekordy zawierające w opisie słowo „kabriolet”, trzeba skorzystać z symboli wieloznacznych. Oto inny przykład. Przypuśćmy, że jeden z klientów kupił w zeszłym roku kilka modeli czerwonych samochodów. Pamiętamy, że w polu Notes umieściliśmy odpowiednią notatkę na ten temat, ale nie pamiętamy, który to był klient. Trzeba więc przeszukać pola Notes w tabeli tblCustomersi, aby znaleźć rekordy zawierające słowo „czerwony”. Do przeszukiwania zawartości pól z wykorzystaniem symboli wieloznacznych służy operator Like w komórce Kryteria:. Access szuka wzorca w tym polu. Programista może użyć znaku zapytania (?) do reprezentowania pojedynczego znaku albo gwiazdki (*) do reprezentowania wielu znaków. Oprócz znaku zapytania i gwiazdki Access wykorzystuje trzy inne znaki do wyszukiwań wieloznacznych. W tabeli w ramce „Symbole wieloznaczne” we wcześniejszej części rozdziału zamieszczono symbole wieloznaczne, których może używać operator Like. Znak zapytania (?) symbolizuje dowolny pojedynczy znak znajdujący się w tym samym miejscu co znak zapytania we wzorcu. Gwiazdka (*) symbolizuje dowolną liczbę znaków znajdujących się w tym samym miejscu co gwiazdka. Znak krzyżyka (#) symbolizuje dowolną pojedynczą cyfrę znajdującą się w tym samym miejscu co krzyżyk. Nawiasy kwadratowe ([]) i ujęta w nie lista symbolizują dowolny pojedynczy znak spośród tych umieszczonych na liście. Wreszcie wykrzyknik (!) w nawiasie kwadratowym oznacza
Rozdział 9. Stosowanie operatorów i wyrażeń
299
negację listy (operator Not), tzn. reprezentuje dowolny pojedynczy znak, który nie pasuje do żadnego spośród znaków umieszczonych na liście. Symboli tych można używać samodzielnie albo w połączeniu z innymi. Można ich nawet użyć kilkakrotnie w jednym wyrażeniu. Aby utworzyć przykład wykorzystujący operator Like, przypuśćmy, że chcemy znaleźć klientów, którzy lubią czerwone modele samochodów. Wiemy, że słowo „czerwony” znajduje się w polu Notes w tabeli tblCustomers. Aby utworzyć kwerendę, wykonaj poniższe czynności: 1. Dodaj do kwerendy tabele tblCustomers, tblSales, tblSalesLineItems i tblProducts. 2. Wybierz pola Company i Notes z tabeli tblCustomers, pole SalesDate z tabeli tblTransakcje oraz pole Description z tabeli tblProducts i dodaj je do siatki QBE. 3. Kliknij komórkę Kryteria: pola Notes i wprowadź w nim ciąg * czerwony * jako kryterium. Pamiętaj, by umieścić spację między pierwszą gwiazdką a literą „c” oraz między ostatnią spacją a literą „y” — innymi słowy: wpisz spacje przed słowem czerwony i po nim. W powyższym przykładzie umieściliśmy spację przed słowem „czerwony” i po nim. Gdybyśmy tego nie zrobili, Access znalazłby wszystkie słowa zawierające ciąg „czerwony”, takie jak „jasnoczerwony” czy „ciemnoczerwony”. Umieszczając spacje słowem „czerwony” i po nim, nakazujemy Accessowi szukać tylko słowa „czerwony”. Możesz stwierdzić, że jeśli zawartość pola Notes zaczyna się od słowa „czerwony” (np. „Czerwony to ulubiony kolor klienta”), Access nie wykryje rekordu, ponieważ słowo to nie jest wtedy poprzedzone spacją. Rzeczywiście tak się stanie. Przy tworzeniu kryteriów należy przeprowadzić eksperymenty. Ponieważ dane w tabelach (zwłaszcza w polach tekstowych) są nieprzewidywalne, czasem trzeba utworzyć kilka kwerend, aby uwzględnić wszystkie możliwości. W omawianej sytuacji można utworzyć dodatkową kwerendę z kryterium "czerwony *" w celu wykrycia wspomnianych rekordów.
Z zaprezentowanym przykładem jest jednak pewien problem. Zwróćmy uwagę, że warunek ("* czerwony *") wymaga istnienia spacji po słowie „czerwony”. Oznacza to, że rekord zawierający poniższą uwagę nie zostanie zwrócony przez kwerendę: Klienta interesuje każdy model samochodu pod warunkiem, że samochód jest czerwony!
W tym przypadku ze względu na brak spacji bezpośrednio po słowie „czerwony” ten rekord nie zostanie zwrócony. Prawidłowy warunek powinien mieć następującą postać: Like "* czerwony[ , !?"
Nawiasy kwadratowe, w które ujęty jest warunek " ,.!?", instruują Accessa, aby wybierał rekordy w przypadku, gdy pole Notes kończy się słowem „czerwony”, o ile za nim jest spacja albo znak interpunkcyjny. Oczywiście w nawiasach kwadratowych można również wprowadzić inne znaki. W związku z tym trzeba dokładnie wiedzieć, jakie dane są zapisane w polu, w którym szukamy danych.
300
Część III Kwerendy Accessa
Po kliknięciu poza komórką Kryteria: Access automatycznie doda operator Like i umieści wyrażenie w cudzysłowie. Siatka QBE powinna teraz mieć postać pokazaną na rysunku 9.6.
Rysunek 9.6. Stosowanie operatora Like w kwerendach wybierających
Po utworzeniu tej kwerendy można kliknąć przycisk Widok arkusza danych, aby obejrzeć jej wyniki. Pokazano je na rysunku 9.7.
Rysunek 9.7. Wyniki kwerendy wybierającej korzystającej z operatora Like w polu typu Długi tekst. W tym przypadku kwerenda szuka słowa „czerwony” w polu Notes
Kiedy klikniesz przycisk Widok arkusza danych na wstążce, przekonasz się, że kilka rekordów spełnia warunki kwerendy. Zbiór rekordów zwrócony przez tę kwerendę zawiera redundantne informacje w kolumnach Company i Notes. Redundancja jest wynikiem pytania o interesujące nas informacje razem z danymi o sprzedaży i właściwościami produktu. Access automatycznie dodaje operator Like i znaki cudzysłowu, jeśli spełnione są następujące warunki:
Rozdział 9. Stosowanie operatorów i wyrażeń
Wyrażenie nie zawiera spacji.
Użyto tylko symboli wieloznacznych ?, * oraz #.
Nawiasów kwadratowych ([ ]) użyto wyłącznie w cudzysłowie (" ").
301
W przypadku użycia nawiasów kwadratowych bez cudzysłowu trzeba samodzielnie wpisać operator Like i znaki cudzysłowu. Używanie operatora Like z symbolami wieloznacznymi to najlepszy sposób wyszukiwania wzorców w polu typu Długi tekst. Przykłady zamieszczone w tabeli 9.5 demonstrują przydatność operatora Like przy wyszukiwaniu danych w polach typu Krótki tekst i Data. W tabeli tej znajdziesz przykłady, które można wykorzystać do wyszukiwania rekordów w używanej bazie danych. Tabela 9.5. Używanie symboli wieloznacznych w połączeniu z operatorem Like Wyrażenie
Używane w polu
Wynik kryterium
Like "Ja*"
tblCustomers.LastName
Znajduje wszystkie rekordy klientów, których nazwisko zaczyna się od „Ja”, np. Janik i Jankowski.
Like "* czerwony *"
tblProducts.Features
Znajduje wszystkie rekordy, które zawierają słowo „czerwony” w polu Features.
Like "K*"
tblSales.PaymentMethod
Znajduje wszystkie transakcje, które były opłacane kartą kredytową bądź debetową.
Like "Gdańska ##"
tblCustomers.Address
Znajduje rekordy dotyczące adresów z numerem domu między 10 a 99 włącznie, np. 22, 33 lub 51, na ulicy Gdańskiej.
Like "[PBK]*"
tblCustomers.City
Znajduje wszystkie rekordy klientów, którzy mieszkają w miastach o nazwach zaczynających się literami P, B lub K.
Like "[!JKC]*"
tblCustomers.City
Znajduje wszystkie rekordy klientów, którzy nie mieszkają w miastach o nazwach zaczynających się literami J, K lub C.
Określanie wartości niepasujących Aby określić wartość niepasującą, wystarczy użyć operatorów Not lub <> przed wyrażeniem, którego nie chcemy dopasować. Przypuśćmy, że chcemy zobaczyć wszystkich klientów, którzy zakupili pojazd, ale bez nabywców z województwa mazowieckiego. Wykonaj poniższe czynności, aby się dowiedzieć, jak określić wartość niepasującą: 1. Otwórz nową kwerendę w widoku projektu i dodaj tabelę tblCustomers. 2. Wybierz z tabeli tblCustomers pola Company oraz State. 3. Kliknij komórkę Kryteria: pod polem State. 4. Wpisz <> Mazowieckie w komórce. Access automatycznie ujmie tekst Mazowieckie w cudzysłów, jeśli Ty tego nie zrobisz przed opuszczeniem pola. Kwerenda powinna mieć postać pokazaną na rysunku 9.8. Kwerenda wybiera wszystkie rekordy z wyjątkiem rekordów dotyczących klientów, którzy mieszkają w województwie mazowieckim.
302
Część III Kwerendy Accessa
Rysunek 9.8. Stosowanie operatora <> w kryterium
W 4. etapie powyższej procedury można użyć operatora Not zamiast <>, aby wyłączyć województwo mazowieckie. Zbiór wynikowy będzie taki sam bez względu na użyty operator. Operatory te można stosować zamiennie wszędzie z wyjątkiem konstrukcji ze słowem kluczowym Is. Nie można napisać Is <> Null — trzeba napisać Not Is Null lub, bardziej precyzyjnie, Is Not Null.
Wprowadzanie kryteriów liczbowych Kryteriów liczbowych używa się w połączeniu z polami typów liczbowych lub walutowych. Wystarczy wpisać liczbę i przecinek dziesiętny — jeśli jest potrzebny — po operatorze matematycznym lub operatorze porównania. Przypuśćmy, że chcemy obejrzeć towary, dla których stan magazynowy jest niższy niż 10 sztuk. 1. Otwórz nową kwerendę w widoku projektu i dodaj tabelę tblProducts. 2. Dodaj do siatki QBE pola ProductID, Description, Make, Model i QtyInStock z tabeli tblProducts. 3. Kliknij komórkę Sortuj: pod polem Make i wybierz pozycję Rosnąco z menu rozwijanego. 4. Kliknij w komórce Kryteria: pole QtyInStock i wpisz w komórce <10. Kwerenda powinna mieć postać pokazaną na rysunku 9.9. Gdy pracujemy z danymi liczbowymi, Access nie ujmuje wyrażeń w cudzysłów jak w przypadku kryteriów tekstowych. Kryteria stosowane do pól liczbowych zwykle zawierają operatory porównań takie jak operator mniejszości (<), większości (>) lub równości (=). Aby określić relację inną niż równość, należy wpisać zarówno wartość, jak i operator. Należy pamiętać, że jeśli w kryterium kwerendy wybierającej nie podamy operatora, Access domyślnie zastosuje operator równości. Dlatego właśnie w przykładzie pokazanym na rysunku 9.9 musieliśmy wprowadzić <10 w kolumnie QtyInStock. Access nie ujmuje warunku w cudzysłów, ponieważ pole QtyInStock jest liczbowe i nie wymaga ogranicznika.
Rozdział 9. Stosowanie operatorów i wyrażeń
303
Rysunek 9.9. Kryteria dla kwerendy wyszukującej produkty o niskich stanach magazynowych
Wprowadzanie kryteriów logicznych (Prawda/Fałsz) Kryteriów Prawda/Fałsz używa się w połączeniu z polami typu Tak/Nie. Przykładowymi danymi, które można określić w kryterium, mogą być wyrażenia o wartości Prawda albo Fałsz. Można też używać operatorów Not oraz <>, aby wskazać wartość przeciwną, ale dane typu Tak/Nie miewają również stan Null, który czasem trzeba sprawdzać. Access rozpoznaje kilka form prawdy i fałszu. Zamiast więc wpisywać Tak, można podać w komórce Kryteria: jedną z następujących wartości: Włączony, Prawda, Not Nie, <> Nie, < Nie albo –1. Pole typu Tak/Nie może mieć tylko trzy stany: Tak, Nie i Null. Stan Null występuje jedynie wtedy, gdy w tabeli nie ustawiono wartości domyślnej, a użytkownik jeszcze nie wprowadził wartości. Kryterium Is Null wyświetla tylko rekordy bez wartości, a kryterium Is Not Null wyświetla wszystkie rekordy o wartości Tak i Nie. Po zaznaczeniu pola wyboru Tak/Nie (albo zaznaczeniu go, a następnie usunięciu zaznaczenia) pole nie może mieć wartości Null, lecz musi mieć wartość Tak albo Nie (–1 lub 0).
Wprowadzanie kryterium dla obiektu OLE Dla obiektów OLE można definiować kryteria Is Null lub Is Not Null. Przypuśćmy, że nie mamy zdjęć wszystkich produktów i chcemy obejrzeć tylko te rekordy, które zawierają zdjęcie — to znaczy te, w których zdjęcie „nie jest Null”. Wpisujemy więc kryterium Is Not Null dla pola Picture w tabeli tblProducts. Choć prawidłowa składnia to Is Not Null, wystarczy wpisać Not Null, a Access automatycznie dołączy operator Is.
304
Część III Kwerendy Accessa
Wprowadzanie wielu kryteriów w kwerendzie W poprzednich podrozdziałach pracowaliśmy z kryteriami zawierającymi jeden warunek i dotyczącymi jednego pola. Kryterium z jednym warunkiem można określić dla pola dowolnego typu. W tym podrozdziale będziemy pracować z wieloma kryteriami dotyczącymi jednego pola. Przypuśćmy, że chcemy obejrzeć wszystkie rekordy, w których nabywca pochodzi z województwa mazowieckiego, zachodniopomorskiego lub małopolskiego, albo rekordy wszystkich pojazdów, które zostały sprzedane w pierwszym kwartale 2012 roku. Siatka QBE pozwala rozwiązywać tego rodzaju problemy. W kwerendzie wyboru można określić kryterium lub kryteria dla jednego pola albo dla kilku pól. Używając wielu kryteriów, można na przykład ustalić, które pojazdy sprzedano w ciągu ostatnich 90 dni. Dla pola SaleDate można wprowadzić dowolne spośród poniższych kryteriów: Between Date() And Date() - 90 Between Date() And DateAdd("d",-90,Date())
Spośród tych wyrażeń to, które wykorzystuje funkcję DateAdd, jest mniej mylące i bardziej charakterystyczne dla wykonywanego zadania. Dokładniejsze omówienie obliczeń z wykorzystaniem dat znajdziesz w rozdziale 12.
Operacja Or Operacji Or używa się w kwerendach wtedy, gdy pole ma spełniać dowolny spośród dwóch warunków. Przypuśćmy, że chcemy obejrzeć wszystkie rekordy, gdzie klient mieszka w województwie mazowieckim albo lubuskim. Innymi słowy, chcemy obejrzeć te rekordy, gdzie klient mieszka albo w województwie mazowieckim, albo w województwie lubuskim, albo w obu. Ogólna postać operacji Or to: [State] = "Mazowieckie" Or [State] = "Lubuskie"
Jeśli którakolwiek strona tej formuły ma wartość True, cała formuła również ma wartość True. Aby to wyjaśnić, rozważmy poniższe warunki:
Klient 1 mieszka w województwie mazowieckim — formuła ma wartość True.
Klient 2 mieszka w województwie lubuskim — formuła ma wartość True.
Klient 3 mieszka w województwach mazowieckim i lubuskim — formuła ma wartość True.
Klient 4 mieszka w województwie śląskim — formuła ma wartość False.
Określanie wielu wartości pola za pomocą operatora Or Operator Or służy do określania wielu możliwych wartości pola. Można użyć go na przykład po to, aby wyświetlić wszystkie rekordy nabywców mieszkających w województwach mazowieckim, lubuskim lub śląskim. Aby to zrobić, wykonaj następujące czynności:
Rozdział 9. Stosowanie operatorów i wyrażeń
305
1. Otwórz nową kwerendę w widoku projektu i dodaj tabele tblCustomers i tblSales. 2. Dodaj pola Company i State z tabeli tblCustomers oraz pole SalesDate z tabeli tblSales. 3. Kliknij komórkę Kryteria: pod polem State. 4. Wybierz pozycję Rosnąco z menu rozwijanego. 5. Kliknij komórkę Kryteria: pod polem State. 6. Wpisz w komórce Mazowieckie Or Lubuskie Or Śląskie. Siatka QBE powinna teraz przypominać tę, którą pokazano na rysunku 9.10. W tym przykładzie Access automatycznie dodał cudzysłowy do wartości Mazowieckie, Lubuskie i Śląskie. Rysunek 9.10. Stosowanie operatora Or. Zwróć uwagę na dwa operatory Or pod polem State — Mazowieckie Or Lubuskie Or Śląskie
Używanie komórki Lub: na siatce projektu (QBE) Oprócz stosowania operatora Or w pojedynczej instrukcji w wierszu Kryteria: pod polem State można podać poszczególne kryteria w oddzielnych wierszach siatki QBE (zobacz rysunek 9.11). Rysunek 9.11. Używanie komórki Lub: na siatce QBE. Kryteria w siatce QBE można dodawać pionowo
306
Część III Kwerendy Accessa Access pozwala na wypełnienie najwyżej dziewięciu komórek Lub:. Jeśli trzeba podać więcej warunków, można użyć operatora Or między warunkami (np. Lubuskie Or Mazowieckie Or Śląskie Or Dolnośląskie).
Po zapisaniu kwerendy Access przeorganizowuje projekt pokazany na rysunku 9.11 tak, by odpowiadał kwerendzie z rysunku 9.10. Po otwarciu kwerendy qryFigure_9-11 z przykładowej bazy danych Rozdział09.accdb można zobaczyć identyczny projekt, jak w przypadku kwerendy qryFigure_9-10. Wynika to ze zreorganizowania kryteriów podczas zapisywania kwerendy qryFigure_9-11. W przypadku tworzenia kwerendy z wykorzystaniem kryteriów Or w pionie Access optymalizuje instrukcję SQL-a będącą podstawą kwerendy poprzez umieszczenie wszystkich kryteriów Or w jednym wyrażeniu.
Używanie listy wartości w połączeniu z operatorem In Istnieje jeszcze jedna metoda określania wielu wartości jednego pola. Polega ona na wykorzystaniu operatora In. Operator In znajduje dowolną wartość spośród wymienionych na liście. Na przykład można wpisać wyrażenie In(Śląskie; Mazowieckie; Lubuskie) pod polem State w kwerendzie z rysunku 9.11. Lista wartości w nawiasach staje się przykładowym kryterium. Kwerenda powinna teraz przypominać tę z rysunku 9.12. Rysunek 9.12. Stosowanie operatora In w celu znalezienia wszystkich rekordów, w których województwo nabywcy to Śląskie, Mazowieckie lub Lubuskie
W tym przykładzie Access automatycznie dodał cudzysłowy do wartości Śląskie, Mazowieckie i Lubuskie. Kiedy używamy operatora In, każda wartość (przykładowe dane) musi być oddzielona od innych przecinkiem.
Wykorzystanie operatora And do zdefiniowania zakresu Operatora And często używa się w polach typu Liczba albo Data/Godzina. Rzadko stosuje się go w polach tekstowych, choć w pewnych sytuacjach jest to możliwe. Przypuśćmy, że chcemy obejrzeć wszystkich nabywców, których nazwiska zaczynają się od liter D, E lub F. Moglibyśmy użyć operatora And (>="D" And <="G"), choć operator Like jest lepszy (Like "[DEF]*"), ponieważ jest znacznie bardziej czytelny.
Rozdział 9. Stosowanie operatorów i wyrażeń
307
Operatorów And używa się w kwerendach wtedy, kiedy pole ma spełniać wszystkie określone warunki. Przypuśćmy, że chcemy obejrzeć wszystkie rekordy nabywców, którzy zakupili samochód między 1 października 2012 roku a 31 marca 2013 roku. Innymi słowy, interesują nas transakcje zawarte w ostatnim kwartale 2012 i w pierwszym kwartale 2013 roku. W tym przykładzie ogólna formuła to: (SaleDate >= 01.10.12) And (DataSprzedaży <= 31.03.13)
Nawiasy w pokazanym przykładzie zostały użyte dla poprawienia czytelności.
W przeciwieństwie do operatora Or (który ma wartość True w kilku różnych okolicznościach) operator And ma wartość True tylko wtedy, gdy prawdziwe są obie strony formuły. Aby wyjaśnić użycie operatora And, rozważmy poniższe warunki:
Data sprzedaży (22.09.12) nie jest większa niż 01.10.12, ale jest mniejsza niż 31.03.13 — formuła ma wartość False.
Data sprzedaży (11.04.13) nie jest większa niż 01.10.12, ale jest mniejsza niż 31.03.13 — formuła ma wartość False.
Data sprzedaży (22.11.12) jest większa niż 01.10.12 i jest mniejsza niż 31.03.13 — formuła ma wartość True.
Użycie operatora And w jednym polu określa zakres dopuszczalnych wartości w tym polu, a zatem podstawowym przeznaczeniem operatora And w jednym polu jest definiowanie zakresu wyświetlanych rekordów. Można na przykład użyć operatora And, aby utworzyć kryterium wyświetlające wszystkich nabywców, którzy zakupili towary w okresie między 1 października 2012 roku a 31 marca 2013 roku (włącznie). Aby utworzyć taką kwerendę, wykonaj poniższe czynności: 1. Utwórz nową kwerendę z wykorzystaniem tabel tblCustomers i tblSales. 2. Dodaj pole Company z tabeli tblCustomers oraz pole SaleDate z tabeli tblSales. 3. Kliknij komórkę Kryteria: pod polem SaleDate. 4. Wpisz w komórce >= 01.10.12 And <= 31.03.13. Projekt kwerendy powinien wyglądać tak, jak pokazano na rysunku 9.13. Zwróćmy uwagę na znaki kratki (#) wykorzystane w celu otoczenia dat w wyrażeniach po obu stronach operatora And. Access rozpoznaje znaki kratki jako ograniczniki wartości dat i godzin. Bez tych znaków zinterpretowałby wartości dat jako wyrażenia liczbowe (np. 10 dzielone przez 1 podzielone przez 2012).
Stosowanie operatora Between...And Zakres rekordów można wyświetlić inną metodą, a mianowicie za pomocą operatora Between...And. Operator ten pozwala wyszukać rekordy pasujące do pewnego zakresu wartości, na przykład wszystkie rekordy transakcji, w których cena towaru wynosiła od 50 do 100 zł. Korzystając z poprzedniego przykładu, utwórzmy kwerendę podobną do pokazanej na rysunku 9.14.
308
Część III Kwerendy Accessa
Rysunek 9.13. Stosowanie operatorów And i Or w złożonych kryteriach kwerend
Rysunek 9.14. Stosowanie operatora Between...And. Wyniki są takie same jak w przypadku kwerendy z rysunku 9.13
Operandy operatora Between...And są uwzględniane w zbiorze wynikowym. Oznacza to, że w zbiorze wyników kwerendy znajdą się transakcje z 1 października 2012 roku i 31 marca 2013 roku.
Wyszukiwanie danych o wartości Null Pole może być pozbawione zawartości z kilku przyczyn. Możliwe, że w czasie wprowadzania danych wartość nie była znana, a mogło się też zdarzyć, że użytkownik zapomniał wpisać informację lub usunął ją z pola. Access nie robi nic z takim polem. Jeśli w projekcie kwerendy nie zdefiniowano wartości domyślnej, pole po prostu pozostaje puste (o pustym polu mówimy, że ma wartość Null). Z logicznego punktu widzenia Null nie jest ani prawdą, ani fałszem. Pole Null nie jest odpowiednikiem pola zawierającego same spacje albo zero. Pole Null po prostu nie ma wartości. W Accessie do pracy z polami Null służą dwa specjalne operatory: Is Null
Is Not Null
Rozdział 9. Stosowanie operatorów i wyrażeń
309
Co to jest wartość Null? Bazy danych muszą obsługiwać informacje różnego rodzaju. Wszyscy znamy dane tekstowe, liczbowe, daty, a także inne typy danych. W większości przypadków wartości danych są znane. Na przykład niemal na pewno znane jest nazwisko i imię nowego pracownika, choć jego drugie imię może być nieznane. W jaki sposób baza danych reprezentuje wartość, która jest nieznana bądź w ogóle nie istnieje? Do tego właśnie służy wartość Null. Domyślnie większość pól w tabeli bazy danych ma wartość Null do czasu, aż zostaną w nich wprowadzone wartości. Wartość może być wprowadzona przez użytkownika w formularzu albo może zostać podstawiona wartość domyślna zdefiniowana w projekcie tabeli. Jeśli się dowiemy, że pracownik nie ma drugiego imienia, możemy wprowadzić pusty ciąg znaków ("") w polu przeznaczonym na drugie imię. W tym przypadku brak drugiego imienia oznacza pusty ciąg znaków. Dopóki jednak wartość jest nieznana, pole ma wartość Null.
Operatorów tych używa się do określania kryteriów wyszukiwania rekordów na podstawie pól o wartości Null. Z wcześniejszej części tego rozdziału dowiedziałeś się, że można użyć wartości Null, aby wyszukać towary, których rekordy zawierają zdjęcie. W następnym przykładzie poszukamy rekordów nabywców, w których nie podano żadnych danych w polu Notes: 1. Utwórz nową kwerendę z wykorzystaniem tabel tblCustomers i tblSales. 2. Dodaj pole Notes i pole Company z tabeli tblCustomers oraz pole SaleDate z tabeli tblSales. 3. Wpisz Is Null jako kryterium w polu Notes. 4. Anuluj zaznaczenie pola Pokaż: w polu Notes. Kwerenda powinna mieć postać pokazaną na rysunku 9.15. Wybierz polecenie Widok/Arkusz danych, aby zobaczyć rekordy, które nie mają wprowadzonej wartości w polu Notes. Rysunek 9.15. Wykorzystanie warunku Is Null w celu pobrania wierszy zawierających pola bez danych
Zaznaczenie pola wyboru Pokaż: anulowaliśmy dlatego, że nie ma potrzeby wyświetlania pola Notes w wynikach kwerendy. Kryterium służy do wyświetlania tylko tych rekordów, dla których pole Notes ma wartość null, dlatego, mówiąc dosłownie, w polu tym nie ma nic do oglądania. Z tego względu nie ma sensu uwzględniania go w wynikach.
310
Część III Kwerendy Accessa
Kiedy używamy operatorów Is Null oraz Is Not Null, wystarczy wpisać Null albo Not Null, a Access automatycznie doda operator Is do komórki Kryteria:.
Wprowadzanie kryteriów w wielu polach Wcześniej w tym rozdziale pracowaliśmy z jednym lub wieloma kryteriami określanymi w jednym polu. W tym podrozdziale zajmiemy się kryteriami wprowadzanymi w kilku różnych polach. Aby ograniczyć rekordy według zawartości kilku pól, należy ustawić w poszczególnych polach kryteria, które służą do ograniczenia zakresu. Przypuśćmy, że chcemy wyszukać wszystkie transakcje modeli od dystrybutorów z województwa świętokrzyskiego albo interesują nas nabywcy modeli motocykli z województw pomorskiego i zachodniopomorskiego. Możemy także poszukać nabywców modeli motocykli z województwa pomorskiego albo nabywców modeli ciężarówek z województwa zachodniopomorskiego. Każda z tych kwerend wymaga umieszczenia kryteriów w wielu polach i wielu wierszach.
Stosowanie operacji And i Or w polach kwerendy Aby wykonać operację And albo Or na kilku polach kwerendy, należy umieścić przykładowe lub wzorcowe dane w komórkach Kryteria: (w przypadku operacji And) albo w komórkach Lub: danego pola odpowiednio względem położenia tych danych w innym polu. Aby wykonać operację And na dwóch polach, należy umieścić dane przykładowe lub wzorcowe w tym samym wierszu siatki QBE. Aby wykonać operację Or na dwóch polach, należy umieścić dane przykładowe lub wzorcowe w różnych wierszach siatki QBE. Na rysunku 9.16 pokazano siatkę projektu z dość ekstremalnym przykładem rozmieszczenia warunków.
Rysunek 9.16. Siatka QBE definiująca relacje And/Or między polami z wykorzystaniem wierszy Kryteria:
Rozdział 9. Stosowanie operatorów i wyrażeń
311
Kwerenda z rysunku 9.16 wyświetla rekord, jeśli spełnia jedno z poniższych kryteriów: ModelYear = 1932 AND Make = Ford AND Model = Coupe
(wszystkie muszą mieć
wartość True). (jeśli ma wartość True, jeden lub dwa pozostałe wiersze mogą mieć wartość False).
Color = Zielony
(jeśli ma wartość True, jeden lub dwa pozostałe wiersze mogą mieć wartość False).
Category = Osobowe
Jeśli którekolwiek z tych kryteriów jest spełnione, rekord znajdzie się w wynikach kwerendy. Oto instrukcja SQL-a odpowiadająca kwerendzie z rysunku 9.16: SELECT ModelYear, Make, Model, Color, Category FROM tblProducts WHERE ((ModelYear="1932") AND (Make="Ford") AND (Model="Coupe")) OR (Color="Zielony") OR (Category="Osobowe")
Położenie nawiasów w powyższej instrukcji SQL-a ma znaczenie. Jedna para nawiasów otacza warunek dla pól ModelYear, Make i Model, natomiast w oddzielnych nawiasach znajduje się każdy z warunków stosowanych w odniesieniu do pól Color i Category. Oznacza to, że warunki ModelYear, Make i Model będą zastosowane jako grupa, natomiast warunki Color i Category są stosowane indywidualnie.
Określanie kryteriów Or w wielu polach kwerendy Choć operacji Or na wielu polach nie używa się tak często jak operacji And, niekiedy operacja Or jest bardzo przydatna. Przypuśćmy, że chcemy obejrzeć rekordy modeli kupionych przez klientów z województwa śląskiego oraz rekordy modeli ciężarówek bez względu na województwo, z którego pochodzą klienci. Aby utworzyć taką kwerendę, wykonaj poniższe czynności: 1. Dodaj do kwerendy tabele tblCustomers, tblSales, tblSalesLineItems i tblProducts. 2. Dodaj pole Company i pole State z tabeli tblCustomers oraz pole Description i pole Category z tabeli tblProducts. 3. Wpisz Śląskie jako kryterium w polu State. 4. Wpisz Ciężarowe w komórce Lub: pod polem Category. Projekt kwerendy powinien wyglądać tak, jak pokazano na rysunku 9.17. Zwróćmy uwagę, że warunki dla pól State i Category w siatce QBE zostały wpisane w różnych wierszach. Kiedy wpiszemy warunki w różnych wierszach siatki QBE, Access zinterpretuje je jako operację Or pomiędzy polami. Przykładowa kwerenda zwraca rekordy klientów mieszkających w województwie śląskim lub takich, którzy kupili modele ciężarówek. Oto instrukcja SQL-a odpowiadająca kwerendzie z rysunku 9.17: SELECT tblCustomers.Company, tblCustomers.State, tblProducts.Description, tblProducts.Category FROM tblProducts
312
Część III Kwerendy Accessa
Rysunek 9.17. Stosowanie operatora Or pomiędzy polami INNER JOIN (tblCustomers INNER JOIN (tblSales INNER JOIN tblSalesLineItems ON tblSales.InvoiceNumber = tblSalesLineItems.InvoiceNumber) ON tblCustomers.CustomerID = tblSales.CustomerID) ON tblProducts.ProductID = tblSalesLineItems.ProductID WHERE (tblCustomers.State="Śląskie") OR (tblProducts.Category="Ciężarowe")
Zwróćmy uwagę na rozmieszczenie nawiasów wewnątrz klauzuli WHERE. Musi być spełniony przynajmniej jeden z dwóch warunków — albo województwo to "Śląskie", albo typ samochodu to "Ciężarowe". Przeniesienie słowa „Ciężarowe” do tego samego wiersza co „Śląskie” w siatce QBE prowadzi do zmiany działania kwerendy — w tej postaci kwerenda zwróci rekordy klientów, którzy mieszkają w województwie śląskim oraz kupili modele ciężarówek. Zmodyfikowaną kwerendę pokazano na rysunku 9.18. Oto instrukcja SQL-a uzyskana w wyniku tej niewielkiej modyfikacji: SELECT tblCustomers.Company, tblCustomers.State, tblProducts.Description, tblProducts.Category FROM tblProducts INNER JOIN (tblCustomers INNER JOIN (tblSales INNER JOIN tblSalesLineItems ON tblSales.InvoiceNumber = tblSalesLineItems.InvoiceNumber) ON tblCustomers.CustomerID = tblSales.CustomerID) ON tblProducts.ProductID = tblSalesLineItems.ProductID WHERE (tblCustomers.State="Śląskie") AND (tblProducts.Category="Ciężarowe")
Różnica jest znacząca, ponieważ ze względu na modyfikację kryterium dla rekordów jest znacznie bardziej restrykcyjne. Kwerenda Figure-18 zwraca tylko jeden rekord, natomiast kwerenda Figure-17 zwraca 9 wierszy.
Rozdział 9. Stosowanie operatorów i wyrażeń
313
Rysunek 9.18. Prosta modyfikacja w siatce QBE powoduje powstanie zupełnie innej kwerendy
Stosowanie operacji And i Or na różnych polach Pracowaliśmy już oddzielnie z operatorami And i Or, więc jesteśmy gotowi do utworzenia kwerendy, która wykorzystuje relacje And i Or między różnymi polami. W następnym przykładzie wyświetlimy informacje o wszystkich nabywcach z województwa śląskiego, którzy kupili modele motocykli, oraz o wszystkich klientach z województwa podkarpackiego, którzy zakupili ciężarówki. 1. Użyj kwerendy z poprzedniego przykładu, opróżniając najpierw dwie komórki z kryteriami. 2. Wpisz Śląskie w komórce Kryteria: kolumny State. 3. W siatce QBE wpisz Podkarpackie pod Śląskie w wierszu Lub:. 4. Wpisz Motocykle jako kryterium w polu Category. 5. Wpisz Ciężarowe pod słowem Motocykle w polu Category. Wygląd kwerendy pokazano na rysunku 9.19. Zwróćmy uwagę, że kryteria Śląskie i Motocykle są w jednym wierszu, a kryteria Podkarpackie i Ciężarowe w drugim. Kwerenda ta reprezentuje dwie relacje And między polami i relację Or w każdym polu. W tej kwerendzie należy zwrócić uwagę na to, że Access w istocie zwraca dwa zbiory danych: właścicieli modeli motocykli z województwa śląskiego oraz właścicieli modeli ciężarówek z województwa podkarpackiego. Wszystkie inne kombinacje klientów i modeli są ignorowane.
Kwerenda złożona w wielu wierszach Przypuśćmy, że chcemy obejrzeć wszystkie rekordy samochodów marki Chevy zakupionych w ciągu pierwszych sześciu miesięcy 2012 roku przez klientów z województwa dolnośląskiego albo dowolne rekordy pojazdów zakupionych przez klientów z województwa
314
Część III Kwerendy Accessa
Rysunek 9.19. Stosowanie operatorów And i Or w kwerendach wybierających
wielkopolskiego. W tym przykładzie trzeba ustawić kryteria w trzech polach: tblCustomers. State, tblSales.SaleDate i tblProducts.Description. Oto instrukcja umożliwiająca ustawienie takiego warunku: ((tblSales.SaleDate Between #1/1/2012# And #6/30/2012#) And (tblProducts. Description Like "*Chev*") And (tblCustomers.State = "Dolnośląskie")) OR (tblCustomers.State = "Wielokopolskie")
Projekt kwerendy pokazano na rysunku 9.20.
Rysunek 9.20. Stosowanie wielu operacji And i Or w różnych polach. Jest to dość skomplikowana kwerenda wybierająca
Rozdział 9. Stosowanie operatorów i wyrażeń
315
Warto pamiętać, że Access interpretuje dane na podstawie ustawień regionalnych i językowych z panelu sterowania. Dlatego w zależności od kraju krótkie daty mogą być traktowane jako mm/dd/rrrr lub dd/mm/rrrr. Gdy korzystasz z dat, koniecznie uwzględnij różnice między regionami. Ponadto Access domyślnie interpretuje daty, w których rok zapisany jest dwoma cyframi z zakresu 00 – 30, jako lata 2000 – 2030, a rok zapisany cyframi z zakresu 31 – 99 jako lata 1931 – 1999. Dlatego właśnie podczas wprowadzania danych warto konsekwentnie stosować czterocyfrowy zapis roku.
316
Część III Kwerendy Accessa
Rozdział 10.
Poza kwerendy wybierające W tym rozdziale:
Stosowanie kwerend podsumowujących
Używanie kwerend funkcjonalnych
Posługiwanie się kwerendami krzyżowymi
Pobieranie i wyświetlanie konkretnych rekordów za pomocą kwerend wybierających to podstawowe zadanie wykonywane przy analizowaniu danych z Accessa. Jednak dostępne możliwości z zakresu analizy danych są znacznie większe. Analiza danych to obszerny temat obejmujący grupowanie i porównywanie danych, ich aktualizowanie i usuwanie, przeprowadzanie obliczeń z wykorzystaniem danych, a także formatowanie danych i tworzenie na ich podstawie raportów. Access udostępnia wbudowane narzędzia i mechanizmy do wykonywania każdego z tych zadań. W tym rozdziale znajdziesz szczegółowe omówienie różnych narzędzi dostępnych w Accessie. Ponadto dowiesz się, jak przy ich użyciu wyjść poza kwerendy wybierające. Wyjściową bazę danych do tego rozdziału (Rozdział10.accdb) można pobrać z witryny poświęconej tej książce.
Kwerendy podsumowujące Kwerendy podsumowujące (nazywane czasem kwerendami grupującymi) pomagają w szybkim grupowaniu i podsumowywaniu danych. Za pomocą kwerend wybierających można pobierać rekordy tylko w takiej postaci, w jakiej występują w źródle danych. Natomiast przy użyciu kwerend podsumowujących można pobrać podsumowanie wycinka danych obejmujące sumy, średnie, liczby wystąpień itd.
318
Część III Kwerendy Accessa
Tworzenie kwerendy podsumowującej Aby dobrze zrozumieć możliwości kwerend podsumowujących, wyobraź sobie, że poproszono Cię o podanie sumy wpływów z poszczególnych okresów. Aby rozpocząć szukanie odpowiedzi, otwórz nową kwerendę w widoku projektu i dodaj do niej pola Period oraz LineTotal, jak pokazano na rysunku 10.1. Jeśli uruchomisz kwerendę w tej postaci, zamiast potrzebnego podsumowania otrzymasz wszystkie rekordy ze zbioru danych. Rysunek 10.1. Ta kwerenda zamiast potrzebnego podsumowania zwróci wszystkie rekordy ze zbioru
Oto krótkie przypomnienie na temat otwierania nowej kwerendy w widoku projektu: wyświetl zakładkę TWORZENIE ze wstążki, następnie wybierz opcję Projekt kwerendy, a wówczas nad pustym widokiem projektu kwerendy pojawi się okno dialogowe Pokazywanie tabeli, w którym należy wybrać potrzebne tabele. Jeśli potrzebujesz dodatkowych informacji, krótkie przypomnienie dotyczące podstaw stosowania kwerend Accessa znajdziesz w rozdziale 8.
Aby uzyskać sumy wpływów dla poszczególnych okresów, musisz aktywować wiersz Suma w siatce QBE. W tym celu otwórz zakładkę PROJEKTOWANIE na wstążce, a następnie kliknij przycisk Suma. Na rysunku 10.2 pokazano, że po tej operacji w siatce QBE pojawia się nowy wiersz, o nazwie Suma. Wiersz Suma informuje Accessa, którą z funkcji agregacji ma zastosować przy obliczaniu podsumowań na podstawie określonych pól. Warto zauważyć, że wiersz Suma w każdym polu siatki zawiera słowa Grupuj według. Oznacza to, że wszystkie podobne rekordy zostaną pogrupowane według danego pola, co pozwala uzyskać unikatowe elementy danych. Różne funkcje agregacji szczegółowo opisaliśmy w dalszej części rozdziału. Omawiana technika wymaga tego, aby dostosować funkcje agregujące z wiersza Suma do wykonywanych analiz. W tym scenariuszu trzeba pogrupować dane według wszystkich okresów ze zbioru danych, a następnie zsumować wpływy z poszczególnych okresów. Dlatego trzeba zastosować funkcję agregującą Grupuj według w polu Period i funkcje agregującą Suma w polu LineTotal.
Rozdział 10. Poza kwerendy wybierające
319
Rysunek 10.2. Po aktywowaniu wiersz Suma pojawia się w siatce QBE i domyślnie zawiera wartość Grupuj według
Ponieważ w wierszu Suma domyślnie używana jest funkcja Grupuj według, w polu Period nie trzeba wprowadzać żadnych zmian. Jednak w polu LineTotal należy zmienić funkcję agregującą z Grupuj według na Suma. Jest to informacja dla Accessa, że wpływy z pola LineTotal ma zsumować, a nie wykorzystać do grupowania. Aby zmienić funkcję agregującą, kliknij listę rozwijaną w wierszu Suma w polu LineTotal, jak pokazano na rysunku 10.3, a następnie wybierz opcję Suma. Na tym etapie możesz uruchomić kwerendę. Rysunek 10.3. Zmiana funkcji agregacji dla pola LineTotal na Suma
Na rysunku 10.4 widać, że wynikowa tabela zawiera podsumowanie danych z informacjami o łącznych wpływach w poszczególnych okresach.
320
Część III Kwerendy Accessa
Rysunek 10.4. Po uruchomieniu kwerendy uzyskasz podsumowanie z informacjami o łącznych wpływach w określonych okresach
Funkcje agregujące W przykładzie z rysunku 10.3 na liście rozwijanej w wierszu Suma wybrano funkcję agregującą Suma. Oczywiście można wybrać dowolną z dwunastu dostępnych funkcji. Bez wątpienia natrafisz na analizy, w których będziesz potrzebować różnych innych funkcji. Dlatego warto wiedzieć, jak działa każda z nich. Grupuj według Funkcja agregująca Grupuj według łączy na podstawie określonego pola wszystkie rekordy w unikatowe grupy. Oto kilka kwestii, o których warto pamiętać przy stosowaniu tej funkcji:
Access uruchamia funkcję Grupuj według w kwerendzie podsumowującej przed przeprowadzeniem jakichkolwiek innych agregacji. Jeśli używasz tej funkcji razem z innymi funkcjami agregacji, najpierw zostanie wykonana funkcja Grupuj według. Ilustruje to przykład przedstawiony na rysunku 10.4. Access grupuje dane według pola Period przed dodaniem wartości z pola LineTotal.
Access sortuje uzyskane grupy w porządku rosnącym. Pola, dla których działa funkcja Grupuj według, domyślnie są sortowane w porządku rosnącym. Jeśli kwerenda zawiera kilka takich pól, dane w każdym z nich są sortowane w porządku rosnącym, począwszy od pierwszego pola od lewej.
Access traktuje uzyskaną grupę pól jak unikatowy element. Aby się o tym przekonać, utwórz kwerendę podobną do tej z rysunku 10.5. Kwerenda ta zlicza transakcje zarejestrowane w okresie 200701.
Rysunek 10.5. Ta kwerenda zwraca tylko jeden wiersz — zawiera on liczbę rekordów z okresu 200701
Teraz wróć do widoku projektu kwerendy i dodaj pole ProductID (zobacz rysunek 10.6). Tym razem Access potraktuje każdą kombinację okresu i numeru produktu jak unikatowy element. Poszczególne kombinacje są grupowane przed rozpoczęciem zliczania rekordów z każdej grupy. Korzyść z tego jest taka, że analizy zostają wzbogacone o nowy wymiar. Nie tylko wiadomo, ile transakcji dla każdego identyfikatora produktu zarejestrowano w okresie 200701, lecz także po dodaniu wszystkich transakcji można uzyskać dokładną liczbę wszystkich transakcji z tego okresu.
Rozdział 10. Poza kwerendy wybierające
321
Tworzenie aliasów nazw kolumn Zauważ, że na rysunku 10.4 Access automatycznie zmienił nazwę pola LineTotal na SumaOfLine Total. Jest to udogodnienie, dzięki któremu Access informuje użytkownika, że uzyskane wartości to wynik dodawania wartości z pola LineTotal. Zmiana nazwy w niektórych sytuacjach jest wygodna, jeśli jednak chcesz udostępniać wyniki innym osobom, możesz nadać polu lepszą nazwę. Wtedy przydają się aliasy. Alias to nazwa zastępcza, którą można nadać polu, aby było łatwiejsze do znalezienia w wynikach kwerendy. Aliasy pól można tworzyć na dwa sposoby:
Pierwsza metoda. Można poprzedzić nazwę pola tekstem, który ma pełnić funkcję nowej nazwy, a następnie dodać dwukropek. Poniższy rysunek pokazuje, jak utworzyć aliasy, aby nazwy kolumn w wynikach kwerendy były zrozumiałe dla użytkowników. Po uruchomieniu tej kwerendy w zbiorze danych znajdą się kolumny Period i TotalRevenue.
Druga metoda. Kliknij nazwę pola prawym przyciskiem myszy i wybierz opcję Właściwości. Pojawi się okno dialogowe Arkusz właściwości z właściwościami wybranego pola. W polu Tytuł w tym oknie wpisz pożądany alias, tak jak na poniższym rysunku.
Pamiętaj, że jeśli zdefiniujesz alias za pomocą Arkusza właściwości, wówczas w widoku projektu ani w instrukcji SQL-a kwerendy nic nie będzie wskazywało na to, że zastosowano alias. Może to utrudniać pracę użytkownikom kwerendy. Dlatego zwykle lepiej jest definiować aliasy za pomocą pierwszej metody.
322
Część III Kwerendy Accessa
Rysunek 10.6. Ta kwerenda zwraca więcej rekordów, a po zsumowaniu liczb elementów z każdej grupy uzyskiwana jest wartość 4164
Suma, Średnia, Policz, OdchStd, Wariancja Te funkcje agregujące wykonują obliczenia matematyczne na rekordach z wybranego pola. Warto zauważyć, że funkcje te nie uwzględniają rekordów o wartości Null (ignorują puste komórki).
Suma — określa łączną wartość wszystkich rekordów dla danego pola lub w określonej grupy. Działa tylko dla typów Autonumerowanie, Waluta, Data/Godzina i Liczba.
Średnia — oblicza średnią wartość wszystkich rekordów dla danego pola lub w określonej grupy. Działa tylko dla typów Autonumerowanie, Waluta, Data/Godzina i Liczba.
Policz — zlicza elementy w danym polu lub w określonej grupie. Działa dla wszystkich typów danych.
OdchStd — oblicza odchylenie standardowe dla wszystkich rekordów w danym polu lub w określonej grupie. Działa tylko dla typów Autonumerowanie, Waluta, Data/Godzina i Liczba.
Wariancja — oblicza, w jakim stopniu wartości w danym polu lub w określonej grupie różnią się od średniej dla tej grupy. Działa tylko dla typów Autonumerowanie, Waluta, Data/Godzina i Liczba.
Minimum, Maksimum, Pierwszy, Ostatni Funkcje te (w odróżnieniu od pozostałych funkcji agregujących) uwzględniają wszystkie rekordy w określonym polu lub w danej grupie, a następnie zwracają pojedynczą wartość dla grupy.
Minimum — zwraca wartość najmniejszego rekordu z danego pola lub z określonej grupy. Działa tylko dla typów Autonumerowanie, Waluta, Data/Godzina, Liczba i Krótki tekst.
Maksimum — zwraca wartość największego rekordu z danego pola lub z określonej grupy. Działa tylko dla typów Autonumerowanie, Waluta, Data/Godzina, Liczba i Krótki tekst.
Pierwszy — zwraca wartość pierwszego rekordu z danego pola lub z określonej grupy. Działa dla wszystkich typów danych.
Rozdział 10. Poza kwerendy wybierające
323
Ostatni — zwraca wartość ostatniego rekordu z danego pola lub z określonej grupy. Działa dla wszystkich typów danych.
Wyrażenie, Gdzie Jedną z podstawowych reguł dotyczących kwerend podsumowujących jest to, że w agregacji należy uwzględnić każde pole. Jednak w niektórych sytuacjach pola są stosowane jak narzędzia — służą do wykonywania obliczeń lub filtrowania. Pola tego rodzaju są środkiem do przeprowadzenia ostatecznych analiz, a nie ich częścią. Wtedy można wykorzystać funkcję Wyrażenie lub klauzulę Gdzie. Te narzędzia są wyjątkowe, ponieważ same nie grupują danych.
Wyrażenie — funkcję tę stosuje się zwykle przy przeprowadzaniu niestandardowych obliczeń lub używaniu innych funkcji w kwerendzie podsumowującej. Nakazuje ona Accessowi przeprowadzenie niestandardowych obliczeń niezależnie dla poszczególnych rekordów lub grup.
Gdzie — klauzula ta umożliwia zastosowanie kryterium do pola, które nie występuje w kwerendzie podsumowującej. W ten sposób można wykorzystać filtry w analizach.
Aby zobaczyć, jak działa funkcja agregująca Wyrażenie, utwórz w widoku projektu kwerendę podobną do tej z rysunku 10.7. Zauważ, że używane są tu dwa aliasy — Revenue (dla pola LineTotal) i Cost (dla zdefiniowanych niestandardowych obliczeń). Zastosowanie aliasu Revenue zapewnia zrozumiałą nazwę sumie wartości z pola LineTotal. Rysunek 10.7. Funkcja agregująca Wyrażenie umożliwia przeprowadzanie niestandardowych obliczeń osobno dla grup dotyczących poszczególnych okresów
Teraz można wykorzystać zapis [Revenue] do reprezentowania sumy wartości z pola LineTotal w niestandardowych obliczeniach. Funkcja agregująca Wyrażenie wiąże ze sobą wszystkie elementy, informując Accessa, że dla grup dotyczących poszczególnych okresów należy przeprowadzić obliczenia [Revenue]*.33. Opisana kwerenda zwraca łączne wpływy (Revenue) i koszty (Cost) dla grup dotyczących każdego okresu. Aby zobaczyć działanie klauzuli Gdzie, utwórz w widoku projektu kwerendę podobną do tej z rysunku 10.8. W wierszu Suma widać, że kwerenda grupuje dane według pola ProductID i sumuje wartości z pola LineTotal. Nie ustawiono jednak agregacji na pod-
324
Część III Kwerendy Accessa
stawie pola Period, ponieważ kwerenda ma korzystać z tego pola tylko przy filtrowaniu (ma odfiltrować wszystkie okresy oprócz jednego). Jako warunek w polu Period ustawiona jest wartość 200701. Gdy uruchomisz tę kwerendę w obecnej postaci, zobaczysz następujący komunikat o błędzie: Kwerenda nie zawiera podanego wyrażenia „Period” jako elementu funkcji agregującej. Rysunek 10.8. Uruchomienie tej kwerendy spowoduje błąd, ponieważ nie zdefiniowano agregacji w polu Period
Aby można było uruchomić tę kwerendę, należy kliknąć listę rozwijaną w wierszu Suma w polu Period i wybrać opcję Gdzie. Kwerenda powinna wyglądać podobnie do tej przedstawionej na rysunku 10.9. Po ustawieniu klauzuli Gdzie kwerendę można swobodnie uruchomić. Rysunek 10.9. Dodanie klauzuli Gdzie zapobiega błędowi i pozwala uruchomić kwerendę
Warto wspomnieć o jeszcze jednej kwestii związanej z klauzulą Gdzie. Zauważ, że na rysunku 10.9 pole wyboru w wierszu Pokaż w polu Period nie jest zaznaczone. Wynika to z tego, że w kwerendach podsumowujących nie można wyświetlać pól, dla których zastosowano klauzulę Gdzie. Dlatego wspomniane pole wyboru musi pozostać puste. Jeśli je zaznaczysz dla pola z klauzulą Gdzie, wówczas pojawi się komunikat o błędzie informujący, że nie można wyświetlić pola, w którym wiersz Suma ma wartość Gdzie.
Rozdział 10. Poza kwerendy wybierające
325
Kwerendy funkcjonalne Wcześniej wspomnieliśmy, że oprócz pobierania danych w trakcie analiz kształtuje się dane, modyfikuje je, usuwa i aktualizuje. Access do wykonywania tych zadań udostępnia kwerendy funkcjonalne. Niestety wiele osób nie korzysta z tych narzędzi. Zamiast tego użytkownicy eksportują małe porcje danych do Excela, aby wykonać te operacje. Rozwiązanie to może być odpowiednie, gdy analizy przeprowadzane są jednokrotnie dla małego zbioru danych. Co jednak zrobić, gdy te same analizy trzeba przeprowadzać co tydzień lub gdy zbiór danych jest za duży dla Excela? W takich sytuacjach wielokrotne eksportowanie danych do Excela, manipulowanie nimi i ponowne przenoszenie do Accessa jest niepraktyczne. Za pomocą kwerend funkcjonalnych można zwiększyć wydajność i zmniejszyć prawdopodobieństwo wystąpienia błędu. Cały proces analityczny można wtedy przeprowadzić w Accessie. Kwerendy funkcjonalne można traktować podobnie jak wybierające. Kwerenda funkcjonalna pobiera zbiór danych ze źródła na podstawie podanych definicji i kryteriów. Różnica polega na tym, że kwerenda funkcjonalna nie wyświetla zbioru danych, ale wykonuje na nim pewne operacje. Zależą one od typu kwerendy. Kwerend funkcjonalnych (w odróżnieniu od wybierających) nie można zastosować jako źródła danych formularza lub raportu, ponieważ kwerendy te nie zwracają zbioru danych.
Istnieją cztery rodzaje kwerend funkcjonalnych: tworzące tabele, usuwające, dołączające i aktualizujące. Kwerendy poszczególnych typów wykonują określone operacje.
Kwerendy tworzące tabele Kwerenda tworząca tabelę generuje nową tabelę z danymi z istniejącej tabeli. Nowa tabela zawiera rekordy zgodne z definicjami i kryteriami z kwerendy. Jeśli tworzysz kwerendę i chcesz zapisać zwrócone przez nią wyniki w odrębnej tabeli, możesz zastosować kwerendę tworzącą tabelę do wygenerowania trwałej tabeli na podstawie uzyskanych wyników. Następnie można wykorzystać nową tabelę w innych operacjach analitycznych. Przy budowaniu kwerend tworzących tabele trzeba określić nazwę generowanej tabeli. Jeśli podasz nazwę istniejącej tabeli, ta zostanie zastąpiona. Jeżeli w wyniku uruchomienia kwerendy tworzącej tabelę przypadkowo zastąpisz tabelę, nie będziesz mógł jej odtworzyć. Starannie dobierz nazwę tworzonej tabeli, aby uniknąć nadpisania istniejących informacji
.
Dane w tabeli generowanej przez kwerendę tworzącą tabelę nie są w żaden sposób powiązane z danymi źródłowymi. Oznacza to, że dane w nowej tabeli nie zostaną zaktualizowane po zmodyfikowaniu danych z pierwotnej tabeli.
Załóżmy, że dział marketingu poprosił Cię o przygotowanie listy klientów wraz z informacjami na temat historii transakcji każdego z nich. Potrzebne dane można uzyskać za pomocą kwerendy tworzącej tabelę. Aby zbudować taką kwerendę, wykonaj następujące czynności:
326
Część III Kwerendy Accessa
1. W widoku projektu kwerendy utwórz kwerendę podobną do tej z rysunku 10.10. Rysunek 10.10. Utwórz tę kwerendę w widoku projektu
2. Otwórz zakładkę PROJEKTOWANIE na wstążce, a następnie kliknij przycisk Utwórz tabelę. Pojawi się okno dialogowe Tworzenie tabeli (zobacz rysunek 10.11). Rysunek 10.11. Wprowadź nazwę nowej tabeli
3. W polu Nazwa tabeli wprowadź nazwę, jaką chcesz nadać nowej tabeli. Tu wpisz nazwę SalesHistory. Uważaj, aby nie wprowadzić nazwy tabeli, która już istnieje w bazie danych, ponieważ grozi to zastąpieniem pierwotnej tabeli. 4. Kliknij przycisk OK, aby zamknąć okno dialogowe, a następnie uruchom kwerendę. Access wyświetli komunikat ostrzegawczy widoczny na rysunku 10.12, aby poinformować, że wykonywanego zadania nie można anulować. Rysunek 10.12. Kliknij przycisk Tak, aby uruchomić kwerendę
5. Kliknij przycisk Tak, aby zatwierdzić operację i utworzyć nową tabelę. Gdy kwerenda zakończy działanie, wśród obiektów znajdziesz nową tabelę o nazwie SalesHistory.
Rozdział 10. Poza kwerendy wybierające
327
Przekształcanie wyników kwerendy podsumowującej w trwałe dane Wyników kwerendy podsumowującej z natury nie można modyfikować. Oznacza to, że nie można zmienić wartości rekordów zwróconych przez taką kwerendę, ponieważ nie istnieje relacja między zagregowanymi a pierwotnymi danymi. Można jednak przekształcić kwerendę podsumowującą w kwerendę tworzącą tabelę i utworzyć trwałą tabelę na podstawie wyników zwróconych przez kwerendę podsumowującą. W nowej trwałej tabeli można następnie swobodnie edytować dane. Aby zobaczyć działanie tej techniki, utwórz w widoku projektu kwerendę pokazaną na poniższym rysunku. Następnie przekształć ją na kwerendę tworzącą tabelę, podaj nazwę nowej tabeli i uruchom gotową kwerendę.
Zauważ, że na rysunku zdefiniowana jest kolumna o aliasie Customer. Po aliasie wystarczy wpisać słowo „All” ujęte w cudzysłów. Gdy uruchomisz tę kwerendę, zobaczysz, że w nowej tabeli znajdzie się kolumna o nazwie Customer, w której wartość każdego rekordu to All. Ten przykład pokazuje, że przy uruchamianiu kwerend tworzących tabele można dodać nową kolumnę, podając jej alias i określając jej zawartość po dwukropku.
Kwerendy usuwające Kwerenda usuwająca kasuje rekordy z tabeli na podstawie podanych definicji i warunków. Kwerenda tego typu wpływa na grupę rekordów spełniających podane kryterium. Choć rekordy można usuwać ręcznie, w niektórych sytuacjach zastosowanie kwerendy usuwającej jest wydajniejszym rozwiązaniem. Jeśli zbiór danych jest bardzo duży, kwerenda usuwająca skasuje rekordy szybciej niż można to zrobić ręcznie. Ponadto jeżeli chcesz usunąć wybrane rekordy na podstawie kilku skomplikowanych kryteriów, też warto zastosować kwerendę usuwającą. Także gdy zamierzasz skasować rekordy z jednej tabeli na podstawie porównania ich z rekordami z innej tabeli, kwerenda usuwająca będzie dobrym rozwiązaniem. Skutków wykonania kwerendy usuwającej (podobnie jak innych kwerend funkcjonalnych) nie można cofnąć. Kwerenda usuwająca jest jednak bardziej niebezpieczna od pozostałych kwerend funkcjonalnych, ponieważ usuniętych danych nie można odzyskać.
328
Część III Kwerendy Accessa
Ponieważ usuniętych danych nie można odzyskać, warto wyrobić sobie nawyk wykonywania opisanych poniżej czynności, które pozwalają uniknąć popełnienia poważnego błędu:
Uruchom kwerendę wybierającą, aby wyświetlić rekordy, które chcesz usunąć. Następnie przejrzyj te rekordy w celu upewnienia się, że na pewno powinny zostać skasowane. Dopiero wtedy uruchom kwerendę usuwającą.
Uruchom kwerendę wybierającą, aby wyświetlić rekordy, które chcesz usunąć. Następnie przekształć tę kwerendę na kwerendę tworzącą tabelę i uruchom ją, aby zarchiwizować kasowane dane. Dopiero wtedy uruchom kwerendę usuwającą w celu skasowania rekordów.
Utwórz kopię zapasową bazy danych przed uruchomieniem kwerendy usuwającej.
Załóżmy, że dział marketingu poinformował Cię, że wygenerowana tabela SalesHistory zawiera niepotrzebne rekordy. Pracownicy działu chcą, abyś skasował całą historię sprzed okresu 200806. Do wykonania tego zadania posłuży kwerenda usuwającą dla utworzonej wcześniej tabeli SalesHistory. Aby utworzyć kwerendę usuwającą, wykonaj następujące czynności: 1. Dodaj pole Period i wpisz < 200806 w polu Kryteria. Siatka QBA powinna wyglądać tak jak na rysunku 10.13. Rysunek 10.13. Ta kwerenda pobiera wszystkie rekordy z okresów wcześniejszych niż 200806
2. Przeprowadź test, uruchamiając kwerendę. 3. Przejrzyj zwrócone rekordy. Zauważ, że kryteria spełnia 6418 rekordów. Teraz wiadomo, że po uruchomieniu kwerendy usuwającej opartej na przedstawionej definicji skasowanych zostanie 6418 rekordów. 4. Wróć do widoku projektu. 5. Otwórz zakładkę PROJEKTOWANIE na wstążce i kliknij przycisk Usuń. 6. Ponownie uruchom kwerendę. Access wyświetli komunikat widoczny na rysunku 10.14, informując, że kwerenda usunie 6418 rekordów, oraz ostrzegając, iż operacji tej nie będzie można cofnąć. Liczba ta jest zgodna z oczekiwaniami, ponieważ wcześniejszy test także zwrócił 6418 rekordów.
Rozdział 10. Poza kwerendy wybierające
329
Rysunek 10.14. Kliknij przycisk Tak, aby kontynuować usuwanie
7. Ponieważ wszystko się zgadza, kliknij przycisk Tak, aby zatwierdzić operację i usunąć rekordy. Gdy zbiór danych jest bardzo duży, Access może wyświetlić komunikat z informacją, że polecenie Cofnij będzie niedostępne z uwagi na zbyt rozbudowaną operację lub brak wystarczającej ilości wolnej pamięci. Wiele osób błędnie interpretuje ten komunikat, myśląc, że operacji nie można wykonać z uwagi na za małą ilość wolnej pamięci. Komunikat informuje jednak o tym, że Access nie będzie umożliwiał wycofania zmian, gdy zechcesz kontynuować pracę. Dotyczy to kwerend usuwających, dołączających i aktualizujących.
Kwerendy dołączające Kwerenda dołączająca dodaje rekordy do tabeli na podstawie określonych definicji i warunków. Kwerendy tego rodzaju pozwalają dodawać wyniki na koniec tabeli (powoduje to dołączenie wierszy do tabeli). Kwerenda dołączająca kopiuje rekordy z jednej tabeli lub kwerendy na koniec innej tabeli. Takie kwerendy są przydatne przy przesyłaniu dużych zbiorów danych z jednej tabeli do drugiej. Jeśli istnieje tabela z dawnymi transakcjami służąca do archiwizowania rekordów z informacjami o transakcjach, za pomocą kwerendy dołączającej można dodać do niej najnowszy zbiór informacji z tabeli z nowymi transakcjami. Głównym zagrożeniem związanym z kwerendami dołączającymi jest utrata rekordów w procesie dołączania. Nie wszystkie dołączane rekordy rzeczywiście są dodawane do tabeli. Ponadto warto unikać wielokrotnego uruchamiania kwerend dołączających, ponieważ może to prowadzić do powielenia danych.
W procesie dołączania rekordy mogą zostać utracone z dwóch powodów. Oto one:
Nieudana konwersja typów — ten błąd ma miejsce, gdy typ danych źródłowych jest niezgodny z typem kolumny w docelowej tabeli. Załóżmy, że w tabeli istnieje pole o nazwie Koszt. Jest to pole typu tekstowego, ponieważ w niektórych rekordach koszt jest jeszcze nieznany i wartość pola to DU (do ustalenia). Jeśli spróbujesz dołączyć wartości z tego pola do innej tabeli, w której pole Koszt jest typu liczbowego, wszystkie wartości DU zostaną zmienione na Null, co spowoduje usunięcie oznaczenia DU.
Naruszenie klucza — ten błąd zachodzi przy próbie dołączenia powtarzających się rekordów do pola w docelowej tabeli, jeśli pole jest ustawione jako klucz główny lub jest indeksem, w którym nie mogą występować duplikaty. Tak więc jeżeli pole nie może zawierać powtarzających się wartości, Access nie zezwoli na dołączenie rekordu, który zawiera duplikat istniejącej już wartości z danego pola.
330
Część III Kwerendy Accessa
Usuwanie rekordów z jednej tabeli na podstawie rekordów z drugiej W trakcie analiz często będziesz musiał usuwać rekordy z jednej tabeli na podstawie rekordów z innej tabeli. Zadanie to jest stosunkowo łatwe, jednak wielu użytkowników ma z nim problem z powodu jednego prostego błędu. Kwerenda na poniższym rysunku wygląda prosto. Informuje Accessa, aby usunął rekordy danego klienta z tabeli Customer_ListA, jeśli klient ten występuje także w tabeli Customer_ListB.
Gdy uruchomisz tę kwerendę, Access wyświetli komunikat widoczny na poniższym rysunku. W komunikacie znajduje się prośba o określenie, która tabela zawiera usuwane rekordy.
Komunikat ten pojawia się wielu użytkownikom Accessa. Niestety nie określa on jednoznacznie, co trzeba zrobić, aby naprawić błąd. Rozwiązanie jest jednak proste. Najpierw należy usunąć z siatki QBE pole CustomerName. Następnie trzeba kliknąć dwukrotnie gwiazdkę (*) w tabeli Customer_ListA. Jest to bezpośrednia informacja dla Accessa, że usuwane rekordy znajdują się w tabeli Customer_ ListA. Na poniższym rysunku pokazano, jak w poprawny sposób zbudować potrzebną kwerendę.
Innym zagrożeniem dotyczącym kwerend dołączających jest to, że mogą nie zostać wykonane. Może się to zdarzyć z pięciu powodów:
Naruszenie blokady — ten błąd zdarza się, gdy docelowa tabela jest wyświetlona w widoku projektu lub jest używana przez inną osobę w sieci.
Rozdział 10. Poza kwerendy wybierające
331
Naruszenie reguły sprawdzania poprawności — ten błąd ma miejsce, gdy pole w docelowej tabeli ma ustawioną jedną z poniższych właściwości:
Właściwość Wymagane ustawiona na Tak — jeśli pole w docelowej tabeli ma właściwość Wymagane ustawioną na Tak i nie dołączysz danych w tym polu, kwerenda dołączająca nie zostanie wykonana.
Właściwość Zerowa dł. dozwolona ustawiona na Nie — jeśli pole w docelowej tabeli ma właściwość Zerowa dł. dozwolona ustawioną na Nie i nie dołączysz danych w tym polu, kwerenda dołączająca nie zostanie wykonana.
Właściwość Reguła poprawności ustawiona na dowolną wartość — jeżeli dla pola z docelowej tabeli ustawiono regułę poprawności, a kwerenda dołączająca narusza tę regułę, kwerenda nie zostanie wykonana. Na przykład jeśli zgodnie z regułą poprawności pole Koszt w docelowej tabeli musi mieć wartość większą od zera (reguła > 0), nie można dołączyć rekordów z wartością zero lub mniejszą.
Na szczęście Access ostrzega przed popełnieniem każdego z tych błędów. Na rysunku 10.15 przedstawiono komunikat ostrzegawczy, który informuje o tym, że z powodu błędów nie można dołączyć wszystkich rekordów. Z komunikatu dowiesz się też, ilu rekordów nie można dołączyć. Tu z uwagi na naruszenie klucza nie można dodać 5979 rekordów. W oknie można kliknąć Tak lub Nie. Jeśli klikniesz Tak, ostrzeżenie zostanie zignorowane i kwerenda dołączy rekordy (oprócz tych, które powodują błędy). Jeżeli wybierzesz opcję Nie, kwerenda zostanie anulowana, co oznacza, że nie dołączy żadnych rekordów.
Rysunek 10.15. Komunikat ostrzegawczy informuje, że w procesie dołączania zostaną utracone rekordy Warto pamiętać, że skutków uruchomienia kwerend dołączających (podobnie jak innych kwerend funkcjonalnych) nie można cofnąć. Jeśli potrafisz wykryć rekordy dołączone do docelowej tabeli, możesz anulować operację dołączania, usuwając nowe rekordy. Oczywiście wymaga to opracowania metody identyfikowania dołączonych rekordów. Możesz na przykład utworzyć pole z kodem lub tagiem, który informuje, że rekord jest dołączony. Kodem tym może być cokolwiek — od daty po prosty znak.
Załóżmy, że dział marketingu poinformował Cię, iż podał błędne dane — potrzebna jest historia transakcji z roku podatkowego 2008. Dlatego do raportu SalesHistory trzeba dodać okresy od 200801 do 200805. Do wykonania tego zadania posłuży kwerenda dołączająca.
332
Część III Kwerendy Accessa
Aby uzyskać potrzebne dane, wykonaj następujące czynności: 1. W widoku projektu utwórz kwerendę podobną do tej z rysunku 10.16. Rysunek 10.16. Ta kwerenda pobiera wszystkie rekordy z okresów od 200801 do 200805
2. Otwórz zakładkę PROJEKTOWANIE na wstążce, a następnie kliknij przycisk Dołącz. Pojawi się okno dialogowe Dołączanie (zobacz rysunek 10.17). Rysunek 10.17. Wprowadź nazwę tabeli, do której chcesz dołączyć wyniki wykonania kwerendy
3. W polu Nazwa tabeli wpisz nazwę tabeli, do której chcesz dołączyć wyniki wykonania kwerendy. Tu wprowadź nazwę SalesHistory. 4. Po wpisaniu nazwy docelowej tabeli kliknij przycisk OK. W siatce QBE pod wierszem Sortuj pojawi się wiersz Dołączanie do (zobacz rysunek 10.18). Należy podać nazwę pola z docelowej tabeli, w którym mają się pojawić informacje zwrócone przez kwerendę. Na przykład w wierszu Dołączanie do dla pola Period znajduje się słowo Period. Oznacza to, że dane z pola Period kwerendy zostaną dodane do pola o tej samej nazwie w tabeli SalesHistory. 5. Uruchom kwerendę. Access wyświetli komunikat (zobacz rysunek 10.19) z informacją, że dodanych zostanie 1760 wierszy. Komunikat zawiera też ostrzeżenie, że operacji nie można cofnąć. 6. Kliknij przycisk Tak, aby zatwierdzić operację i dodać rekordy.
Rozdział 10. Poza kwerendy wybierające
333
Rysunek 10.18. W wierszu Dołączanie do wybierz nazwę pola z docelowej tabeli, do którego chcesz dołączyć informacje zwrócone przez kwerendę
Rysunek 10.19. Kliknij przycisk Tak, aby kontynuować dołączanie
Dodawanie wiersza z sumą do zbioru danych Twój przełożony oczekuje, że przygotujesz raport z podsumowaniem wpływów, w którym znajdzie się suma wpływów uzyskanych przez każdego managera z poszczególnych rynków. Przełożony chce też otrzymać łączny poziom wpływów z każdego rynku. Zamiast generować dwa odrębne raporty możesz udostępnić jedną tabelę ze szczegółowymi danymi na temat managerów i z łącznymi wpływami dla poszczególnych rynków. Jest to łatwe: 1. Utwórz w widoku projektu kwerendę wyglądającą podobnie do tej z poniższego rysunku. Zauważ, że utworzono tu alias dla pola LineTotal.
2. Przekształć ją na kwerendę tworzącą tabelę i nazwij tabelę RevenueSummary. 3. Uruchom kwerendę.
334
Część III Kwerendy Accessa
4. Następnie wykorzystaj wygenerowaną właśnie tabelę RevenueSummary do podsumowania wpływów dla poszczególnych rynków. W tym celu utwórz w widoku projektu kwerendę podobną do tej z poniższego rysunku.
Przyjrzyj się przez chwilę kwerendzie z rysunku. Zauważ, że znajduje się tu niestandardowe pole Product_Category z wartością (Total). To gwarantuje, że można będzie zidentyfikować wiersze z sumami dodane do tabeli RevenueSummary — w wierszach tych w polu Product_Category znajdzie się wartość Total. 5. Przekształć kwerendę na kwerendę dołączającą i dodaj wyniki do tabeli RevenueSummary. Teraz możesz otworzyć tabelę RevenueSummary i posortować dane według pól Market i Product_ Category. Na poniższym rysunku widać, że udało się utworzyć tabelę zawierającą łączne wpływy dla każdej kategorii produktów i łączne wpływy dla każdego rynku.
Kwerendy aktualizujące Głównym powodem stosowania kwerend aktualizujących jest dążenie do zaoszczędzenia czasu. Nie ma łatwiejszej metody jednoczesnej edycji dużych ilości danych niż uruchomienie kwerendy aktualizującej. Wyobraź sobie, że w tabeli Customers znajdują się kody pocztowe klientów. Jeśli kod pocztowy 32-750 zostanie zmieniony na 32-751, będziesz mógł łatwo zaktualizować tabelę Customers i zastąpić wartość 32-750 kodem 32-751.
Rozdział 10. Poza kwerendy wybierające
335
Przy stosowaniu kwerend aktualizujących (jak też innych kwerend funkcjonalnych) trzeba zadbać o to, aby nie znaleźć się w sytuacji, w której nie da się cofnąć skutków wykonania kwerendy. Aby umożliwić sobie odzyskanie pierwotnych danych po popełnieniu błędu, przed uruchomieniem kwerendy aktualizującej utwórz kopię bazy. Możesz też uruchomić kwerendę wybierającą w celu wyświetlenia danych, a następnie przekształcić ją na kwerendę tworzącą tabelę. Kwerendę tworzącą tabelę możesz wykorzystać do zarchiwizowania aktualizowanych danych, po czym możesz uruchomić kwerendę aktualizującą w celu zmodyfikowania rekordów.
Załóżmy, że się dowiedziałeś, iż kod pocztowy wszystkich klientów o kodzie 33605 został zmieniony na kod 33606. Aby baza danych zawierała poprawne informacje, trzeba w tabeli Dim_Customers zaktualizować wszystkie kody pocztowe 33605 wartością 33606. Poniżej wyjaśniamy, jak to zrobić: 1. W widoku projektu utwórz kwerendę podobną do tej z rysunku 10.20. Rysunek 10.20. Ta kwerenda pobiera wszystkich klientów, których kod pocztowy to 33605
2. Przeprowadź test, uruchamiając kwerendę. 3. Przejrzyj zwrócone rekordy. Zauważ, że kryteria spełnia sześć rekordów. Wiesz zatem, że po uruchomieniu tak zdefiniowanej kwerendy aktualizującej zmodyfikowanych zostanie sześć rekordów. 4. Wróć do widoku projektu. 5. Otwórz zakładkę PROJEKTOWANIE na wstążce i kliknij przycisk Aktualizuj. W siatce QBE pojawi się wiersz Aktualizacja do. Należy wpisać w nim wartość, która ma zastąpić bieżące dane. W kwerendzie pokazanej na rysunku 10.21 kod pocztowy wybranych rekordów ma zostać zmieniony na 33606. Rysunek 10.21. Ta kwerenda aktualizuje kod pocztowy wszystkich klientów z kodem 33605 wartością 33606
336
Część III Kwerendy Accessa
6. Uruchom kwerendę. Access wyświetli komunikat widoczny na rysunku 10.22. Komunikat informuje, że kwerenda zaktualizuje sześć wierszy danych, oraz ostrzega, że operacji nie będzie można cofnąć. Sześć to liczba zgodna z oczekiwaniami, ponieważ we wcześniejszym teście zwróconych zostało sześć rekordów. Rysunek 10.22. Kliknij przycisk Tak, aby kontynuować aktualizowanie
7. Ponieważ wszystko się zgadza, kliknij przycisk Tak, aby zatwierdzić operację i zaktualizować rekordy.
Stosowanie wyrażeń w kwerendach aktualizujących Natrafisz na sytuacje, w których będziesz musiał przeprowadzić aktualizację pojedynczych rekordów. Wtedy zamiast ustawiać w wielu rekordach określoną wartość należy zaktualizować każdy rekord indywidualnie na podstawie wyrażenia. Aby zobaczyć, jak to działa, utwórz w widoku projektu kwerendę na podstawie tabeli SalesHistory wygenerowanej w punkcie „Kwerendy tworzące tabele” we wcześniejszej części rozdziału. Kwerenda powinna wyglądać tak jak na poniższym rysunku.
Ta kwerenda informuje Accessa, że ma zaktualizować pole Period, łącząc tekst „PD” i wcześniejszą wartość z tego pola. Po uruchomieniu tej kwerendy wszystkie wartości w polu Period będą miały przedrostek „PD”. Na przykład zamiast 200801 pojawi się wartość PD 200801. Pamiętaj, że to tylko jedno przykładowe wyrażenie, które można wykorzystać do zaktualizowania rekordów. W kwerendach aktualizujących możesz zastosować niemal dowolne wyrażenie — od funkcji matematycznych po operacje na łańcuchach znaków.
Rozdział 10. Poza kwerendy wybierające
337
Kwerendy krzyżowe Kwerenda krzyżowa to kwerenda podsumowująca specjalnego rodzaju, która podsumowuje wartości z określonego pola i grupuje je na podstawie dwuwymiarowej siatki. Jeden wymiar jest określany przez wartości z lewej krawędzi siatki, a drugi — przez wartości z górnej krawędzi siatki. Kwerendy krzyżowe doskonale nadają się do analizowania trendów czasowych i pozwalają na szybkie wykrywanie anomalii w zbiorze danych. Kwerendy krzyżowe mają stosunkowo prostą strukturę. Potrzebne są przynajmniej trzy pola, aby można było utworzyć siatkę określającą kwerendę krzyżową. Pierwsze pole wyznacza nagłówki wierszy, drugie — nagłówki kolumn, a na podstawie trzeciego tworzone są podsumowania danych w głównej części siatki. Dane w środku można utworzyć za pomocą dowolnej funkcji agregującej — Suma, Liczba, Średnia itd. Na rysunku 10.23 przedstawiono podstawową strukturę kwerendy krzyżowej.
O modyfikowalnych zbiorach danych Nie wszystkie zbiory danych są modyfikowalne. Czasem Access nie może z pewnych przyczyn zmodyfikować danego zbioru danych. Jeśli wykonywanie kwerendy aktualizującej się nie powiedzie, wówczas pojawi się komunikat z informacją, że w operacji trzeba zastosować modyfikowalną kwerendę lub że zbiór rekordów nie jest modyfikowalny. Kwerenda aktualizująca może nie zadziałać z następujących powodów:
W kwerendzie używane jest sprzężenie z inną kwerendą. Aby rozwiązać ten problem, utwórz tabelę tymczasową, którą można wykorzystać w sprzężeniu zamiast innej kwerendy.
Kwerenda jest oparta na kwerendzie krzyżowej, kwerendzie podsumowującej, kwerendzie składającej lub podkwerendzie, w której wykorzystano funkcje agregujące. Aby rozwiązać ten problem, utwórz tabelę tymczasową, którą można wykorzystać w sprzężeniu zamiast wspomnianych kwerend.
W kwerendzie wykorzystano przynajmniej trzy tabele, między którymi występują relacje wiele do jednego do wielu. Aby rozwiązać ten problem, utwórz tabelę tymczasową, którą można wykorzystać bez stosowania relacji.
Kwerenda jest oparta na tabeli, w której właściwość Wartości unikatowe ma wartość Tak. Aby rozwiązać ten problem, należy ustawić wartość tej właściwości dla tabeli na Nie.
W kwerendzie wykorzystano tabelę zablokowaną przez innego użytkownika. Aby rozwiązać ten problem, należy się upewnić, że tabela nie jest otwarta w widoku projektu lub nie jest zablokowana przez inną osobę.
W kwerendzie używana jest tabela z bazy danych otwartej w trybie tylko do odczytu lub zapisanej w napędzie przeznaczonym tylko do odczytu. Aby rozwiązać ten problem, uzyskaj uprawnienia do zapisu do bazy lub napędu.
W kwerendzie używana jest dołączona tabela ODBC bez unikatowego indeksu lub tabela Paradox bez klucza głównego. Aby rozwiązać ten problem, dodaj klucz główny lub unikatowy indeks do dołączonej tabeli.
W kwerendzie wykorzystano kwerendę przekazującą SQL-a. Aby rozwiązać ten problem, utwórz tabelę tymczasową, którą można wykorzystać zamiast kwerendy.
338
Część III Kwerendy Accessa
Rysunek 10.23. Podstawowa struktura kwerendy krzyżowej
Są dwie metody tworzenia kwerend krzyżowych: można wykorzystać kreator lub utworzyć kwerendę krzyżową ręcznie, za pomocą siatki QBE.
Używanie kreatora kwerend krzyżowych Aby utworzyć kwerendę krzyżową za pomocą kreatora, wykonaj następujące czynności: 1. Otwórz zakładkę TWORZENIE na wstążce, a następnie kliknij przycisk Kreator kwerend. Pojawi się okno dialogowe Nowa kwerenda (zobacz rysunek 10.24). Rysunek 10.24. W oknie dialogowym Nowa kwerenda wybierz opcję Kreator kwerend krzyżowych
2. Z listy wybierz opcję Kreator kwerend krzyżowych, a następnie kliknij przycisk OK. Pierwszy etap kreatora kwerend krzyżowych wymaga podania źródła danych. Na rysunku 10.25 widać, że jako źródło danych można wykorzystać kwerendę lub tabelę. Tu będzie to tabela Dim_Transactions. Rysunek 10.25. Wybierz źródło danych dla kwerendy krzyżowej
Rozdział 10. Poza kwerendy wybierające
339
3. Wybierz tabelę Dim_Transactions, a następnie kliknij przycisk Dalej. Kolejny krok wymaga określenia pól używanych do generowania nagłówków wierszy. 4. Wybierz pole ProductID i kliknij przycisk z symbolem >, aby przenieść pole na listę wybranych elementów. Okno dialogowe powinno wyglądać tak jak na rysunku 10.26. Zauważ, że pole ProductID pojawia się teraz na przykładowym diagramie w dolnej części okna dialogowego. Rysunek 10.26. Wybierz pole ProductID, a następnie kliknij przycisk Dalej
Do określania nagłówków wierszy w kwerendach krzyżowych można wykorzystać do trzech pól. Pamiętaj, że Access traktuje każdą kombinację pól jak unikatowy element. Oznacza to, że na podstawie kombinacji pól najpierw generowane są grupy, a następnie agregowane są dane z każdej z tych grup. Następny krok polega na zidentyfikowaniu pola, które posłuży za nagłówek kolumn w kwerendzie krzyżowej. Do określania nagłówków kolumn można wykorzystać tylko jedno pole. 5. Wybierz z listy pole OrderDate. Zauważ, że przykładowy diagram w dolnej części rysunku 10.27 został zaktualizowany — używane jest w nim pole OrderDate. Rysunek 10.27. Wybierz pole OrderDate, a następnie kliknij przycisk Dalej
340
Część III Kwerendy Accessa Jeśli pole używane jako nagłówek kolumny zawiera dane obejmujące kropkę (.), wykrzyknik (!) lub nawias kwadratowy ([ lub ]), znaki te zostaną zastąpione w nagłówku podkreśleniem (_). Nie dzieje się tak, gdy te same dane są używane w nagłówkach wierszy. Jest to celowe rozwiązanie, ponieważ konwencje nazewnicze Accessa zabraniają stosowania wymienionych znaków w nazwach pól.
Jeśli jako nagłówki kolumn używane jest pole z datą (takie jak OrderDate w przykładzie), należy wykonać krok przedstawiony na rysunku 10.28. W tym kroku można określić przedziały w celu pogrupowania dat. Rysunek 10.28. Wybierz opcję Kwartał, a następnie kliknij przycisk Dalej
6. Wybierz opcję Kwartał. Zauważ, że przykładowy diagram w dolnej części okna dialogowego jest odpowiednio aktualizowany. To już prawie koniec. W przedostatnim kroku (zobacz rysunek 10.29) określ pole, na podstawie którego chcesz agregować dane, i wybierz używaną funkcję. Rysunek 10.29. Wybierz pole LineTotal i funkcję Suma, a następnie kliknij przycisk Dalej
Rozdział 10. Poza kwerendy wybierające
341
7. Z listy pól wybierz LineTotal, a następnie wybierz Suma z listy funkcji. Zwróć uwagę na pole wyboru Tak, dołącz sumy wierszy. Pole to jest domyślnie zaznaczone, co gwarantuje, że w kwerendzie krzyżowej znajdzie się kolumna z sumami wartości z poszczególnych wierszy. Jeśli nie chcesz dodawać takiej kolumny, usuń zaznaczenie pola wyboru. Gdy przyjrzysz się przykładowemu diagramowi w dolnej części okna dialogowego, zrozumiesz, jak działa gotowa kwerenda krzyżowa. Opisana tu kwerenda oblicza sumę wartości z pola LineTotal w ujęciu kwartalnym dla każdej wartości z pola ProductID. Ostatni krok, przedstawiony na rysunku 10.30, polega na nadaniu nazwy kwerendzie krzyżowej. Rysunek 10.30. Kliknij przycisk Zakończ, aby zobaczyć wyniki wykonania kwerendy
8. Nazwij kwerendę Podsumowanie kwartalne wg produktów. Po nadaniu nazwy możesz wyświetlić kwerendę lub zmodyfikować jej projekt. 9. Załóżmy, że chcesz wyświetlić wyniki kwerendy. Kliknij przycisk Zakończ. Za pomocą kilku kliknięć udało się uzyskać rozbudowany przegląd wpływów uzyskanych w poszczególnych kwartałach dzięki poszczególnym produktom (zobacz rysunek 10.31). Rysunek 10.31. Wystarczy kilka kliknięć, aby otrzymać zaawansowane analizy
342
Część III Kwerendy Accessa
Przekształcanie kwerend krzyżowych na trwałe dane Z pewnością zdarzą Ci się sytuacje, gdy będziesz musiał przekształcić wyniki kwerendy krzyżowej na trwałe dane, aby móc wykorzystać je w dalszych analizach. Można to zrobić za pomocą prostej sztuczki: wystarczy wykorzystać zapisaną kwerendę krzyżową w kwerendzie tworzącej tabelę i wygenerować w ten sposób nową tabelę na podstawie wyników wykonania kwerendy krzyżowej. Zacznij od utworzenia nowej kwerendy w widoku projektu. Dodaj do niej zapisaną kwerendę krzyżową. Na poniższym rysunku zwróć uwagę na to, że wykorzystano utworzoną wcześniej kwerendę Podsumowanie kwartalne wg produktów. Dodaj pola, które chcesz umieścić w nowej tabeli.
Następnie przekształć projekt w kwerendę tworzącą tabelę i uruchom go. Po wykonaniu kwerendy tworzącej tabelę uzyskasz trwałą tabelę z wynikami zwróconymi przez kwerendę krzyżową.
Ręczne tworzenie kwerend krzyżowych Choć kreator kwerend krzyżowych umożliwia łatwe tworzenie takich kwerend, ma pewne ograniczenia, które mogą utrudniać analizę danych. Oto te ograniczenia:
Można wybrać tylko jedno źródło danych dla kwerendy krzyżowej. Oznacza to, że jeśli potrzebujesz danych z różnych tabel, będziesz musiał wykonać dodatkowe kroki w celu utworzenia kwerendy tymczasowej używanej jako źródło danych.
Kreator kwerend krzyżowych nie umożliwia filtrowania ani ograniczania danych na podstawie kryteriów.
Można wykorzystać tylko trzy pola jako nagłówki wierszy.
Nie można bezpośrednio zdefiniować kolejności nagłówków kolumn.
Dobra wiadomość jest taka, że kwerendę krzyżową można utworzyć ręcznie za pomocą siatki QBE. Technika ta zapewnia większą swobodę w analizach. Tworzenie kwerend krzyżowych za pomocą siatki QBE Poniżej opisano, jak utworzyć kwerendę krzyżową za pomocą siatki QBE: 1. Utwórz kwerendę podsumowującą przedstawioną na rysunku 10.32. Zauważ, że potrzebne pola pochodzą z różnych tabel. Jedną z zalet ręcznego tworzenia kwerend krzyżowych jest to, że nie trzeba ograniczać się do jednego źródła danych — przy definiowaniu pól kwerendy można wykorzystać dowolną liczbę takich źródeł.
Rozdział 10. Poza kwerendy wybierające
343
Rysunek 10.32. Utwórz przedstawioną tu kwerendę podsumowującą
2. Otwórz zakładkę PROJEKTOWANIE na wstążce i kliknij przycisk Krzyżowa. W siatce QBE pojawi się nowy wiersz o nazwie Krzyżowe (zobacz rysunek 10.33). Pozwala on określić, jaką rolę każde pole odgrywa w tworzonej kwerendzie krzyżowej.
Rysunek 10.33. W wierszu Krzyżowe określ funkcję każdego pola
3. Pod każdym polem wybierz w kolumnie Krzyżowe, czy pole ma być nagłówkiem wiersza, nagłówkiem kolumny czy wartością. 4. Uruchom kwerendę, aby zobaczyć, jak działa. W trakcie tworzenia kwerendy krzyżowej w siatce QBE pamiętaj o następujących zagadnieniach:
Trzeba podać przynajmniej po jednym polu pełniącym funkcję nagłówka wiersza, nagłówka kolumny i wartości.
Nie można zdefiniować więcej niż jednego pola dla nagłówków kolumn.
Nie można zdefiniować więcej niż jednego pola dla wartości.
Nie jesteś ograniczony do stosowania tylko trzech pól dla nagłówków wierszy.
344
Część III Kwerendy Accessa
Tworzenie kwerend krzyżowych z kilkoma polami wartości Jedną z reguł tworzenia kwerend krzyżowych jest to, że nie można podawać więcej niż jednego pola wartości. Można jednak obejść to ograniczenie i przeanalizować więcej niż jeden wskaźnik dla tych samych grup danych. Aby zrozumieć, jak to zrobić, utwórz kwerendę krzyżową przedstawioną na poniższym rysunku i zapisz ją pod nazwą Krzyżowa-1. Nagłówkiem kolumny jest niestandardowe pole, które zawiera nazwę regionu i słowo Revenue.
Następnie utwórz nową kwerendę krzyżową, przedstawioną na poniższym rysunku, i zapisz ją pod nazwą Krzyżowa-2. Także tu nagłówkiem kolumny jest niestandardowe pole. Zawiera ono nazwę regionu i słowo Transactions.
W ostatnim kroku utwórz kwerendę wybierającą, która złącza obie kwerendy krzyżowe na podstawie nagłówków wierszy. W przykładzie przedstawionym na poniższym rysunku nagłówkiem wiersza jest pole Product_Category. Dodaj wszystkie pola w odpowiedniej kolejności. Gdy uruchomisz tę kwerendę, otrzymasz analizy obejmujące obie kwerendy krzyżowe. W ten sposób uzyskasz wartości z kilku pól. Warto pamiętać, że jeśli jako nagłówków wierszy używa się kilku pól, przy złączaniu trzeba uwzględnić każde z nich.
Rozdział 10. Poza kwerendy wybierające
345
Dostosowywanie kwerend krzyżowych Kwerendy krzyżowe są przydatne, jednak czasem trzeba je dostosować, aby uzyskać oczekiwane wyniki. W tym podpunkcie wyjaśniamy kilka sposobów, które pozwalają dopasować kwerendy krzyżowe do własnych potrzeb. Definiowanie kryteriów w kwerendach krzyżowych
Możliwość filtrowania i ograniczania wyników kwerend krzyżowych to następna zaleta związana z ręcznym tworzeniem takich kwerend. Aby zdefiniować filtr dla kwerendy krzyżowej, wystarczy określić kryteria, tak jak w każdej innej kwerendzie podsumowującej. Przedstawia to rysunek 10.34.
Rysunek 10.34. Można zdefiniować kryteria, aby przefiltrować wyniki zwracane przez kwerendę krzyżową
346
Część III Kwerendy Accessa Zmienianie kolejności sortowania nagłówków kolumn kwerendy krzyżowej
W kwerendach krzyżowych nagłówki domyślnie sortowane są w kolejności alfabetycznej. Na przykład kwerenda krzyżowa z rysunku 10.35 generuje zbiór danych, w których nagłówki kolumn podane są w następującej kolejności: Canada, Midwest, North, Northeast, South, Southeast, Southwest i West.
Rysunek 10.35. Ta kwerenda krzyżowa wyświetla wszystkie regiony jako uporządkowane alfabetycznie kolumny
W większości sytuacji jest to odpowiednie rozwiązanie, jednak jeśli centrala firmy znajduje się w Kalifornii, zarząd najpierw chce zapoznać się z wynikami z regionu West. Kolejność kolumn w kwerendzie krzyżowej można określić, zmieniając wartość atrybutu Nagłówki kolumn we właściwościach kwerendy. Aby uzyskać dostęp do atrybutu Nagłówki kolumn, wykonaj następujące czynności: 1. Otwórz kwerendę w widoku projektu. 2. Kliknij prawym przyciskiem myszy szary obszar nad białą siatką QBE i wybierz opcję Właściwości. Pojawi się okno dialogowe z właściwościami kwerendy (zobacz rysunek 10.36). Rysunek 10.36. Atrybut Nagłówki kolumn jest ustawiony tak, aby kolumny pojawiały się w następującej kolejności: West, Canada, Midwest, North, Northeast, South, Southeast i Southwest
Rozdział 10. Poza kwerendy wybierające
347
3. W atrybucie Nagłówki kolumn zmień kolejność, w jakiej mają się pojawiać nagłówki kolumn. Możliwość zmiany wartości atrybutu Nagłówki kolumn jest przydatna, gdy chcesz wyświetlić miesiące w naturalnej kolejności, a nie w kolejności alfabetycznej. Wystarczy wpisać nazwy kolumn z miesiącami w kolejności, w jakiej mają się pojawić, np. „Styczeń”, „Luty”, „Marzec”, „Kwiecień”, „Maj”, „Czerwiec”, „Lipiec”, „Sierpień”, „Wrzesień”, „Październik”, „Listopad”, „Grudzień”.
W trakcie korzystania z atrybutu Nagłówki kolumn należy pamiętać o następujących kwestiach:
Nazwy poszczególnych kolumn trzeba ująć w cudzysłów i oddzielić od siebie przecinkami.
Błąd w nazwie kolumny może prowadzić do pominięcia kolumny w wynikach zwracanych przez kwerendę krzyżową. Wtedy zamiast tej kolumny pojawia się pusta fikcyjna kolumna o błędnie zapisanej nazwie.
Trzeba zapisać każdą kolumnę, która ma się znaleźć w wynikach kwerendy krzyżowej. Pominięcie kolumny w atrybucie Nagłówki kolumn spowoduje, że nie pojawi się ona w wynikach.
Gdy usuniesz zawartość atrybutu Nagłówki kolumn, wszystkie kolumny pojawią się w kolejności alfabetycznej.
348
Część III Kwerendy Accessa
Część IV
Analizowanie danych w Accessie W tej części:
Rozdział 11. Przekształcanie danych
Rozdział 12. Obliczenia i daty
Rozdział 13. Analizy warunkowe
Rozdział 14. Podstawy SQL-a w Accessie
Rozdział 15. Podkwerendy i funkcje agregujące domeny
Rozdział 16. Statystyki opisowe
Wiesz już, jak porządkować dane w tabelach i jak za pomocą kwerend wchodzić w interakcje z tymi danymi. Dzięki rozdziałom z tej części poznasz narzędzia i funkcje Accessa 2013, które pozwolą Ci przeprowadzać bardziej wartościowe analizy danych. Wykorzystanie Accessa do analizy danych pomaga usprawnić proces analityczny, zwiększyć wydajność i przeanalizować większe zbiory danych. Rozdział 11. dotyczy przekształcania danych. Znajdziesz tu przykłady ilustrujące, jak porządkować i kształtować surowe dane, tak aby możne je było prezentować. Rozdział 12. zawiera szczegółowe instrukcje na temat opracowywania i stosowania niestandardowych obliczeń w analizach. Z tego rozdziału dowiesz się też, jak pracować z datami i przeprowadzać na nich proste obliczenia. Rozdział 13. zawiera wprowadzenie do technik analizy warunkowej, które pozwalają dodać logikę biznesową do procesu analitycznego. Rozdział 14. poświęcony jest składni SQL-a. Znajdziesz tu SQL-owe kwerendy, które można wykorzystać do usprawnienia analiz. Rozdział 15. to wprowadzenie do podkwerend i funkcji agregujących domeny. W rozdziale 16. znajdziesz wiele zaawansowanych analiz statystycznych, które można przeprowadzić za pomocą podkwerend i funkcji agregujących dla zbiorów rekordów.
350
Część IV Analizowanie danych w Accessie
Rozdział 11.
Przekształcanie danych W tym rozdziale:
Wyszukiwanie i usuwanie powtarzających się rekordów
Uzupełnianie pustych pól
Scalanie pól tekstowych
Zmienianie wielkości znaków
Usuwanie początkowych i końcowych spacji
Wyszukiwanie i zastępowanie konkretnego tekstu
Uzupełnianie łańcuchów znaków
Przetwarzanie łańcuchów znaków
Przekształcenia danych zwykle wymagają wykonania określonych czynności, które mają pozwolić na uporządkowanie danych: określenie struktury tabeli, usunięcie powtórzeń, oczyszczenie tekstu, usunięcie pustych pól lub ustandaryzowanie pól z datami. Otrzymane dane często są nieuporządkowane i nieprzetworzone. Oznacza to, że mogą występować w nich powtórzenia, puste pola, niespójny tekst itd. Przed przeprowadzeniem wartościowych analiz należy przekształcić i uporządkować dane. Wiele osób przechowuje dane w Accessie, jednak nieliczni użytkownicy wykorzystują ten program do przekształcania danych. Część osób woli wyeksportować dane do Excela, tam przeprowadzić niezbędne operacje porządkujące, a następnie zaimportować dane z powrotem do Accessa. Wynika to z dobrej znajomości środowiska Excela, które zapewnia wiele możliwości. Jednak eksportowanie i importowanie danych w celu wykonania prostych zadań to niewydajne podejście, zwłaszcza gdy zbiór danych jest duży. W tym rozdziale znajdziesz wprowadzenie do wybranych narzędzi i technik Accessa, które ułatwiają porządkowanie i „dopieszczanie” danych bez konieczności korzystania z Excela. Wyjściową bazę danych do tego rozdziału, Rozdział11.accdb, można pobrać z witryny poświęconej tej książce.
352
Część IV Analizowanie danych w Accessie
Wyszukiwanie i usuwanie powtarzających się rekordów Powtarzające się rekordy bardzo utrudniają przeprowadzanie analiz. Duplikaty mogą mieć poważny wpływ na wykonywane analizy — mogą zakłócić niemal wszystkie wskaźniki, podsumowania i wnioski analityczne. Dlatego po otrzymaniu nowego zbioru danych znalezienie i usunięcie powtarzających się rekordów powinno być priorytetem.
Czym są powtarzające się rekordy? Przed rozpoczęciem wyszukiwania i usuwania duplikatów należy się zastanowić, czym są powtarzające się rekordy (inaczej duplikaty). Przyjrzyj się tabeli z rysunku 11.1. Zawiera ona 11 rekordów. Ile jest wśród nich duplikatów?
Rysunek 11.1. Czy w tabeli występują powtarzające się rekordy? Zależy to od tego, jak je zdefiniujesz
Jeśli na rysunku 11.1 za powtarzające się uznasz rekordy z taką samą wartością SicCode, znajdziesz w tabeli 11 duplikatów. Jeżeli powtarzające się rekordy muszą mieć identyczne pola SicCode i PostalCode, duplikaty będą tylko dwa (z wartościami PostalCode 77032 i 77040). Gdyby duplikaty musiały mieć identyczne wartości w polach SicCode, PostalCode i CompanyNumber, w tabeli nie występowałyby żadne powtarzające się rekordy. Ten przykład ilustruje, że jeśli dwa rekordy mają tę samą wartość w jednej kolumnie, nie są automatycznie duplikatami. To programista musi ustalić, które pola lub kombinacje pól pozwalają zdefiniować unikatowe rekordy w zbiorze danych. Gdy już wiesz, które pola umożliwiają wyznaczenie unikatowych rekordów w tabeli, możesz łatwo wykryć duplikaty, tworząc z tych pól klucz główny. Aby zobaczyć, jak to działa, otwórz tabelę LeadList w widoku projektu, a następnie oznacz pole CompanyNumber jako klucz główny. Jeśli spróbujesz zapisać tabelę po tej zmianie, zobaczysz komunikat o błędzie przedstawiony na rysunku 11.2. Komunikat ten oznacza, że w zbiorze danych występują powtarzające się rekordy i trzeba je poprawić. Przypomnienie na temat projektowania tabel znajdziesz w rozdziale 3.
Rozdział 11. Przekształcanie danych
353
Rysunek 11.2. Jeśli przy próbie ustawienia klucza głównego zobaczysz ten komunikat o błędzie, oznacza to, że w zbiorze danych występują duplikaty
Wyszukiwanie duplikatów Jeśli ustaliłeś, że zbiór danych rzeczywiście zawiera duplikaty, zwykle warto najpierw je wyszukać i przejrzeć, a dopiero potem usunąć. Staranny przegląd powtórzeń pozwala się upewnić, że rekord nie zostanie pomyłkowo uznany za duplikat i usunięty z analiz. Może się okazać, że poprawne rekordy zostały mylnie uznane za duplikaty. Wtedy należy wykorzystać dodatkowe pole do ustalania, które rekordy są unikatowe. Najłatwiejszym sposobem na znalezienie duplikatów w zbiorze danych jest uruchomienie kreatora wyszukiwania duplikatów: 1. Otwórz zakładkę TWORZENIE na wstążce i kliknij przycisk Kreator kwerend. Pojawi się okno dialogowe Nowa kwerenda (zobacz rysunek 11.3). Rysunek 11.3. Wybierz opcję Kreator kwerend wyszukujących duplikaty i kliknij przycisk OK
2. Zaznacz opcję Kreator kwerend wyszukujących duplikaty i kliknij przycisk OK. 3. Zaznacz wybrany zbiór danych, który chcesz wykorzystać w kwerendzie wyszukującej duplikaty (zobacz rysunek 11.4). 4. Określ, które pola (lub kombinacje pól) określają unikatowe rekordy w zbiorze danych, a następnie kliknij przycisk Dalej. W przykładowych ustawieniach widocznych na rysunku 11.5 unikatowe rekordy definiuje pole CompanyNumber. 5. Określ dodatkowe pola, które kwerenda ma wyświetlać (zobacz rysunek 11.6), a następnie kliknij przycisk Dalej.
354
Część IV Analizowanie danych w Accessie
Rysunek 11.4. Wybierz zbiór danych, w którym chcesz wyszukiwać duplikaty, a następnie kliknij przycisk Dalej
Rysunek 11.5. Wybierz pola, które określają unikatowe rekordy w zbiorze danych
Rysunek 11.6. Wybierz pola, które kwerenda ma wyświetlać
Rozdział 11. Przekształcanie danych
355
6. Podaj nazwę kwerendy i kliknij przycisk Zakończ (zobacz rysunek 11.7). Nowa kwerenda wyszukująca duplikaty natychmiast się otworzy i będziesz mógł ją sprawdzić. Wygenerowaną kwerendę przedstawia rysunek 11.8. Gdy Access znalazł powtarzające się rekordy, możesz usunąć duplikaty, kasując je. Rysunek 11.7. Nazwij kwerendę i kliknij przycisk Zakończ
Rysunek 11.8. Kwerenda wyszukująca duplikaty
Rekordy wyświetlane przez kwerendę wyszukującą duplikaty to nie tylko duplikaty. Wyniki obejmują jeden unikatowy rekord i jego powtórzenia. Zauważ, że na rysunku 11.8 występują cztery rekordy, w których pole CompanyNumber ma wartość 11145186. Trzy spośród nich to duplikaty, które można usunąć, natomiast należy pozostawić jeden unikatowy rekord.
Usuwanie powtarzających się rekordów Jeśli pracujesz z małymi zbiorami danych, usuwanie duplikatów jest proste — wystarczy ręcznie skasować powtarzające się dane w wynikach kwerendy wyszukującej duplikaty. Jeżeli jednak zbiór danych jest duży, kwerenda może zwrócić zbyt wiele rekordów, aby można je było ręcznie usunąć. Ręczne usuwanie rekordów w kwerendzie wyszukującej duplikaty, która zwróciła 5000 wierszy, może być bardzo męczące dla oczu. Na szczęście istnieje inne rozwiązanie.
356
Część IV Analizowanie danych w Accessie
Można masowo usunąć duplikaty, wykorzystując wbudowane w Accessa zabezpieczenie przed powtarzającymi się kluczami głównymi. Aby zobaczyć, jak działa ta technika, wykonaj następujące czynności: 1. Kliknij prawym przyciskiem myszy tabelę LeadList i wybierz opcję Kopiuj. 2. Kliknij ponownie prawym przyciskiem myszy i wybierz opcję Wklej. Pojawi się okno dialogowe Wklejanie tabeli jako (zobacz rysunek 11.9). Rysunek 11.9. Otwórz okno dialogowe Wklejanie tabeli jako, aby skopiować strukturę tabeli do nowej tabeli o nazwie LeadList_NoDups
3. Nadaj nowej tabeli nazwę LeadList_NoDups i w sekcji Opcje wklejania wybierz ustawienie Tylko struktura. Powstanie nowa pusta tabela o strukturze identycznej ze strukturą pierwotnej tabeli. 4. Otwórz tabelę LeadList_NoDups w widoku projektu i ustaw odpowiednie pole (lub kombinację pól) jako klucz główny. Sam musisz ustalić, które pole (lub która kombinacja) najlepiej pozwala zidentyfikować unikatowe rekordy w zbiorze danych. Na rysunku 11.10 do wykrywania unikatowych rekordów służy pojedyncze pole CompanyNumber, dlatego ustawiono je jako klucz główny. Rysunek 11.10. Pole (lub pola), które najlepiej określa unikatowe rekordy, ustaw jako klucz główny
Teraz zatrzymaj się na chwilę i pomyśl o tym, co już zrobiłeś. Na tym etapie powinieneś mieć tabele LeadList i LeadList_NuDups. Druga z nich powinna być pusta i mieć ustawione pole CompanyNumber jako klucz główny. 5. Utwórz kwerendę dołączającą, która doda wszystkie rekordy z tabeli LeadList do tabeli LeadList_NoDups. Gdy uruchomisz tę kwerendę, pojawi się komunikat podobny do tego z rysunku 11.11. Nie wiesz, czym są kwerendy dołączające? Ich szczegółowe omówienie znajdziesz w rozdziale 10.
Rozdział 11. Przekształcanie danych
357
Rysunek 11.11. Teraz można dołączyć wszystkie rekordy z pominięciem duplikatów
Ponieważ pole CompanyNumber w tabeli LeadList_NoDups jest ustawione jako klucz główny, Access nie pozwala na dołączenie rekordów z powtarzającą się wartością tego pola. Wystarczyło kilka kliknięć, aby utworzyć tabelę pozbawioną duplikatów. Teraz możesz wykorzystać ją jako źródło danych w dalszych analizach. Access nie stosuje zaawansowanych operacji logicznych do ustalenia, czy rekordy mogą być duplikatami. Żądania są przetwarzane przez Accessa dosłownie. Na przykład literówka w adresie lub numerze telefonu spowoduje, że rekordy, które są duplikatami, nie zostaną usunięte. Warto o tym pamiętać, zwłaszcza przy korzystaniu z pól tekstowych, w których dane wprowadza się ręcznie. Usuwanie duplikatów za pomocą jednej kwerendy tworzącej tabelę Oto sztuczka, która pozwala usunąć duplikaty za pomocą kwerendy tworzącej tabelę: 1. Otwórz zakładkę TWORZENIE i wybierz opcję Projekt kwerendy. 2. W oknie dialogowym Pokazywanie tabeli wybierz tabelę zawierającą duplikaty. 3. W zakładce NARZĘDZIA KWEREND PROJEKTOWANIE wybierz polecenie Arkusz właściwości. Pojawi się okno dialogowe Arkusz właściwości widoczne na poniższym rysunku.
Teraz wystarczy zmienić wartość właściwości Wartości unikatowe na Tak. Następnie zamknij okno dialogowe Arkusz właściwości i zmień typ kwerendy na kwerendę tworzącą tabelę.
358
Część IV Analizowanie danych w Accessie
Typowe zadania z zakresu przekształcania danych Oprócz usunięcia duplikatów rekordów nieuporządkowane zbiory danych często wymagają innych przekształceń. W tym podrozdziale opisaliśmy wybrane z typowych zadań z zakresu przekształcania danych.
Uzupełnianie pustych pól W danych często występują puste pola. Są to pola o wartości Null (oznacza ona brak wartości). Puste pola nie zawsze oznaczają problemy. Jeśli poprawnie zastosować takie pola, mogą być ważnym elementem dobrze zaprojektowanej relacyjnej bazy danych. Mimo to czasem trzeba uzupełnić puste pola sensownymi kodami oznaczającymi brak wartości. Aby uzupełnić puste pola w zbiorze danych, wystarczy uruchomić kwerendę aktualizującą. W przykładzie widocznym na rysunku 11.12 puste komórki w polu DollarPotential są aktualizowane wartością 0. Rysunek 11.12. Ta kwerenda aktualizuje puste wartości w polu DollarPotential wartością 0
Należy zauważyć, że istnieją dwa rodzaje pustych komórek — o wartości Null i z pustym łańcuchem znaków (""). Przy uzupełnianiu pustych komórek w polach tekstowych warto dodać pusty łańcuch znaków jako kryterium w kwerendzie aktualizującej, aby się upewnić, że uwzględnione zostaną wszystkie pola. W przykładzie widocznym na rysunku 11.13 puste komórki w polu Segment są aktualizowane wartością „Other”. Rysunek 11.13. Ta kwerenda aktualizuje puste komórki w polu Segment wartością „Other”
Rozdział 11. Przekształcanie danych
359
Scalanie łańcuchów znaków Bardzo dziwne jest, gdy użytkownicy eksportują dane z Accessa do Excela, aby scalić dwa lub więcej łańcuchów znaków ze sobą, po czym importują dane z powrotem do Accessa. W Accessie łańcuchy znaków można scalać na różne sposoby, używając prostych kwerend aktualizujących. Scalanie pól Przyjrzyj się kwerendzie aktualizującej przedstawionej na rysunku 11.14. W tej kwerendzie pole MyTest jest aktualizowane za pomocą scalonych wartości z pól Type i Code. Rysunek 11.14. Ta kwerenda scala wartości z pól Type i Code
Warto najpierw utworzyć pole testowe i sprawdzić efekty przekształcania danych, a dopiero potem wprowadzać zmiany w danych.
Poświęć chwilę na przeanalizowanie poniższych elementów kwerendy: [Type] — ten człon informuje Accessa, że należy wykorzystać wartość z pola Type.
— ampersand to operator dla łańcuchów znaków przeznaczony do scalania ich ze sobą.
&
[Code] — ten człon informuje Accessa, że należy wykorzystać wartość z pola Code.
Wyniki wykonania tej kwerendy przedstawia rysunek 11.15. Rysunek 11.15. Pole MyTest zawiera teraz scalone wartości z pól Type i Code
360
Część IV Analizowanie danych w Accessie Przy wykonywaniu kwerend aktualizujących, które scalają dane, należy się upewnić, że docelowe pole jest wystarczająco długie, aby pomieściło scalony łańcuch znaków. Jeśli scalony łańcuch ma 100 znaków, a pole jest przeznaczone na 50 znaków, scalony łańcuch zostanie bez ostrzeżenia skrócony.
Dodawanie własnego tekstu do wartości pól Do wartości pól można dodać własny tekst. Możliwe, że chcesz scalić wartości z pól Type i Code, a przy tym oddzielić je dwukropkiem. Tak działa kwerenda z rysunku 11.16. Rysunek 11.16. Ta kwerenda scala wartości z pól Type i Code oraz rozdziela je dwukropkiem
Poświęć chwilę na przeanalizowanie poniższych elementów kwerendy: [Type] — ten człon informuje Accessa, że należy wykorzystać wartość z pola Type.
— ampersand to operator dla łańcuchów znaków przeznaczony do scalania ich ze sobą.
&
— ten fragment powoduje dodanie dwukropka i spacji do scalanego łańcucha znaków.
": "
— ampersand to operator dla łańcuchów znaków przeznaczony do scalania ich ze sobą.
&
[Code] — ten człon informuje Accessa, że należy wykorzystać wartość z pola Code.
Wynik uruchomienia tej kwerendy przedstawia rysunek 11.17. Rysunek 11.17. Pole MyTest zawiera teraz scalone wartości z pól Type i Code oraz dwukropek między nimi
W kwerendach własny tekst należy ująć w cudzysłów.
Rozdział 11. Przekształcanie danych
361
Zmiana wielkości liter Upewnianie się, czy litery w tekście w bazie danych mają odpowiednią wielkość, może wydawać się trywialne, jest to jednak ważne zagadnienie. Wyobraź sobie, że otrzymałeś tabelę z danymi klientów, w której adresy są zapisane małymi literami. Jak takie adresy będą wyglądały na etykietach, listach i fakturach? Na szczęście użytkownicy pracujący z tabelami zawierającymi tysiące rekordów mogą wykorzystać kilka wbudowanych funkcji Accessa, dzięki którym zmiana wielkości liter jest bardzo prosta. Tabela LeadList z rysunku 11.18 zawiera pole Address, w którym dane są zapisane małymi literami. Rysunek 11.18. Wartości w polu Address są zapisane małymi literami
Aby poprawić wartości w polu Address, można zastosować funkcję StrConv. Funkcja ta przekształca znaki w łańcuchach na odpowiednią wielkość. Aby zastosować tę funkcję, należy przekazać do niej dwa wymagane argumenty — przekształcany łańcuch znaków i sposób konwersji. StrConv(przekształcany łańcuch znaków,sposób konwersji)
Przekształcany łańcuch znaków to używany tekst. W kwerendzie można zastosować nazwę pola, aby określić, że wartości z danego pola mają zostać przekształcone we wszystkich wierszach. Sposób konwersji informuje Accessa, czy ma zastosować same wielkie litery, same małe litery czy wielkie litery tylko na początku słów. Do określania sposobu konwersji służą stałe: 1
— powoduje przekształcenie wszystkich liter na wielkie.
2
— powoduje przekształcenie wszystkich liter na małe.
3
— powoduje przekształcenie pierwszej litery każdego słowa na wielką.
Oto przykłady: StrConv("To Tekst",1)
— efekt przekształcenia to „TO TEKST”.
StrConv("TO TEKST",2)
— efekt przekształcenia to „to tekst”.
StrConv("to tekst",3)
— efekt przekształcenia to „To Tekst”.
Kwerenda aktualizująca widoczna na rysunku 11.19 powoduje, że w tekście w polu Address pierwsze litery w słowach zmieniają się na wielkie.
362
Część IV Analizowanie danych w Accessie
Rysunek 11.19. Ta kwerenda przekształca pierwsze litery słów w adresie na wielkie
Można też wykorzystać funkcje Ucase i Lcase, aby przekształcić litery w tekście na wielkie lub małe. Funkcje te opisaliśmy w dodatku D w tej książce.
Usuwanie początkowych i końcowych spacji z łańcuchów znaków Gdy otrzymasz zbiór danych z systemu mainframe, hurtowni danych, a nawet pliku tekstowego, pola często będą zawierały na początku i na końcu spacje, które mogą prowadzić do uzyskania nieoczekiwanych wyników — zwłaszcza wtedy, gdy wartości ze spacjami na początku i na końcu łączy się z innymi, poprawnymi wartościami. Aby się o tym przekonać, przyjrzyj się zbiorowi danych z rysunku 11.20. Rysunek 11.20. Spacje na początku uniemożliwiają poprawną agregację
Przedstawiono tu kwerendę podsumowującą, która wyświetla potencjalne wpływy dla stanów Kalifornia, Nowy Jork i Teksas. Jednak początkowe spacje powodują, że Access umieszcza dane dla każdego stanu w dwóch zbiorach, przez co dane są nieprecyzyjne. Początkowe i końcowe spacje można łatwo usunąć za pomocą funkcji Trim. Rysunek 11.21 przedstawia, jak za pomocą kwerendy aktualizującej zmodyfikować pole i usunąć początkowe i końcowe spacje. Rysunek 11.21. Aby usunąć początkowe i końcowe spacje, wystarczy przekazać nazwę pola do funkcji Trim w kwerendzie aktualizującej
Rozdział 11. Przekształcanie danych
363
Funkcja Ltrim usuwa tylko początkowe spacje, natomiast funkcja Rtrim — tylko spacje końcowe. Funkcje te opisaliśmy w dodatku D w tej książce.
Wyszukiwanie i zastępowanie określonego tekstu Załóżmy, że pracujesz w firmie o nazwie BLVD Inc. Pewnego dnia prezes informuje Cię, że skrót „blvd” w adresach można uznać za wykorzystanie zastrzeżonej nazwy firmy, dlatego trzeba go jak najszybciej zmienić na „Boulevard”. Jak wykonać to zadanie? Możesz wpaść na pomysł, aby wykorzystać funkcję wyszukiwania i zastępowania, dostępną we wszystkich aplikacjach z pakietu Office. Jednak dane mogą zawierać setki tysięcy wierszy, a funkcja wyszukiwania i zastępowania potrafi przetwarzać za jednym razem tylko kilka tysięcy rekordów. Nie jest to więc wydajne rozwiązanie. W takich sytuacjach idealnym narzędziem jest funkcja Replace: Replace(Wyrażenie, Szukany, Zastępnik[, Start[, Liczba[, Porównanie]]])
Funkcja Replace przyjmuje trzy argumenty wymagane i trzy opcjonalne: (wymagany) — jest to kompletny sprawdzany łańcuch znaków. W kontekście kwerendy można podać nazwę pola, aby określić, że sprawdzona ma zostać wartość tego pola w każdym wierszu.
Wyrażenie
Szukany
(wymagany) — jest to podłańcuch, który należy znaleźć i zastąpić.
Zastępnik
(wymagany) — jest to podłańcuch zastępujący szukane fragmenty.
(opcjonalny) — jest to pozycja w łańcuchu, od której należy rozpocząć wyszukiwanie. Wartość domyślna tego argumentu to 1.
Start
(opcjonalny) — jest to liczba zastępowanych wystąpień szukanego podłańcucha. Domyślnie podmieniane są wszystkie wystąpienia.
Liczba
(opcjonalny) — określa sposób porównywania (więcej informacji znajdziesz w dodatku D).
Porównanie
Oto przykłady: Replace("Rama", "R", "S") zwraca „Sama”. Replace("To Ster", " S", "s") zwraca „Toster”. Replace("Microsoft Access", "Microsoft ", "") zwraca „Access”. Replace("Roadsign Road", "Road", "Rd", 9) rozpoczyna zastępowanie od
dziewiątego znaku, co daje „Roadsign Rd”. Rysunek 11.22 przedstawia, jak zastosować funkcję Replace, aby wykonać opisane wcześniej zadanie.
364
Część IV Analizowanie danych w Accessie
Rysunek 11.22. Ta kwerenda znajduje wszystkie wystąpienia tekstu „blvd” i zastępuje je słowem „Boulevard”
Dodawanie własnego tekstu w określonych miejscach łańcucha znaków Przy przekształcaniu danych czasem trzeba dodać własny tekst w określonych miejscach łańcucha znaków. Na rysunku 11.23 widoczne są dwa pola. W polu Phone znajduje się nieprzetworzony numer telefonu z raportu z systemu mainframe. Pole MyTest zawiera ten sam numer w wybranym przez programistę formacie. Jak widać, w odpowiednich miejscach łańcucha znaków dodano dwa nawiasy i łącznik, aby uzyskać odpowiedni format. Rysunek 11.23. Numer telefonu przekształcono na wybrany format, dodając odpowiednie znaki w określonych miejscach łańcucha znaków
Modyfikacje widoczne na rysunku 11.23 wprowadzono za pomocą funkcji Rigth, Left i Mid. Funkcje te pozwalają pobrać fragmenty łańcucha znaków począwszy od różnych pozycji:
Funkcja Left zwraca określoną liczbę znaków liczoną od lewej strony łańcucha. Wymaganymi argumentami funkcji Left są przetwarzany tekst i liczba zwracanych znaków. Na przykład wywołanie Left("70056-3504", 5) zwraca pięć znaków, począwszy od pierwszego znaku od lewej (70056).
Funkcja Right zwraca określoną liczbę znaków liczoną od prawej strony łańcucha. Wymaganymi argumentami funkcji Right są przetwarzany tekst i liczba zwracanych znaków. Na przykład wywołanie Right("Microsoft", 4) zwraca cztery znaki, począwszy od pierwszego znaku od prawej (soft).
Funkcja Mid zwraca określoną liczbę znaków liczoną od wskazanej pozycji. Wymagane argumenty tej funkcji to przetwarzany łańcuch znaków, pozycja początkowa i liczba zwracanych znaków. Na przykład wywołanie Mid("Lonely", 2, 3) zwraca trzy znaki, począwszy od drugiego (one).
Rozdział 11. Przekształcanie danych
365
Jeśli liczba znaków w tekście jest mniejsza niż argument określający liczbę zwracanych znaków, funkcja Mid zwraca cały tekst. Na przykład wywołanie Mid("go",1,10000) zwraca go. W dalszej części rozdziału przekonasz się, że to rozwiązanie przydaje się przy pracy z funkcjami zagnieżdżonymi.
Na rysunku 11.24 pokazano, w jaki sposób zaktualizowano pole MyTest, aby poprawnie sformatować numer telefonu. Rysunek 11.24. Ta kwerenda aktualizuje pole MyTest za pomocą odpowiednio sformatowanego numeru telefonu
Poświęć chwilę na przeanalizowanie poniższych elementów kwerendy: "("
— ten człon dodaje otwierający nawias do wynikowego łańcucha znaków.
— ampersand to operator dla łańcuchów znaków przeznaczony do scalania ich ze sobą.
&
Left([Phone],3)
— to wywołanie funkcji pobiera trzy pierwsze znaki z pola
[Phone].
— ampersand to operator dla łańcuchów znaków przeznaczony do scalania ich ze sobą.
&
")"
— ten człon dodaje zamykający nawias do wynikowego łańcucha znaków.
— ampersand to operator dla łańcuchów znaków przeznaczony do scalania ich ze sobą.
&
— to wywołanie funkcji pobiera trzy znaki z pola [Phone], począwszy od czwartego znaku.
Mid([Phone],4,3)
— ampersand to operator dla łańcuchów znaków przeznaczony do scalania ich ze sobą.
&
"-"
— ten tekst dodaje łącznik do wynikowego łańcucha znaków.
— ampersand to operator dla łańcuchów znaków przeznaczony do scalania ich ze sobą.
&
Right([Phone],4)
[Phone].
— to wywołanie funkcji pobiera cztery ostatnie znaki z pola
366
Część IV Analizowanie danych w Accessie
Dopełnianie łańcuchów do określonej liczby znaków Może się zdarzyć, że pewne pola będą musiały mieć określoną liczbę znaków, aby dane można było wykorzystać w zewnętrznych platformach takich jak ADP lub SAP. Załóżmy, że pole CompanyNumber widoczne na poniższym rysunku musi mieć dziesięć znaków. Krótsze pola trzeba uzupełnić zerami na początku, aby utworzyć dziesięcioznakowy łańcuch.
Pól liczbowych (typu Liczba) nie można dopełniać zerami, ponieważ Access usuwa zera z początków liczb. Jeśli chcesz uzupełnić zerami wartość liczbową, musisz zmienić typ danych pola na tekstowy. Rozwiązanie polega na dodaniu dziesięciu zer do każdego numeru firmy (niezależnie od jego długości) i przekazaniu nowej wersji numeru to funkcji Right, która pobierze tylko dziesięć ostatnich znaków. Na przykład numer 29875764 najpierw zostanie przekształcony na postać 000000000029875764, po czym należy przekazać go do funkcji Right, która ma pobrać tylko dziesięć ostatnich znaków: Right("000000000029875764",10). Wynik to 0029875764. Choć wykonywane są tu dwa kroki, pożądany wynik można uzyskać za pomocą jednej kwerendy aktualizującej. Na poniższym rysunku pokazaliśmy, jak to zrobić. Przedstawiona kwerenda najpierw scala każdy numer firmy z ciągiem 0000000000, a następnie przekazuje połączony łańcuch znaków do funkcji Right, która pobiera tylko dziesięć ostatnich znaków.
Poniżej pokazano wyniki zwrócone przez tę kwerendę. Pole CompanyNumber zawiera teraz dziesięcioznakowe numery firm.
Rozdział 11. Przekształcanie danych
367
Przetwarzanie łańcuchów znaków na podstawie znaczników Czy otrzymałeś kiedyś zbiór danych, w którym kilka odrębnych elementów znajdowało się w jednym polu i było rozdzielonych przecinkami? Na rysunku 11.25 widać, że wartościami pola ContactName są łańcuchy znaków reprezentujące nazwisko, imię i inicjał drugiego imienia. Trzeba przetworzyć ten łańcuch znaków na trzy odrębne pola. Rysunek 11.25. Trzeba przetworzyć wartości z pola ContactName na trzy odrębne pola
Choć nie jest to proste zadanie, można je wykonać stosunkowo łatwo, wykorzystując funkcję InStr: InStr(Start, Łańcuch znaków, Szukany, Porównanie)
Funkcja InStr szuka określonego podłańcucha w innym łańcuchu znaków i zwraca pozycję znalezionego fragmentu. Funkcja ta przyjmuje dwa argumenty wymagane i dwa opcjonalne: (opcjonalny) — jest to pozycja w łańcuchu, od której należy rozpocząć wyszukiwanie. Wartość domyślna tego argumentu to 1.
Start
Łańcuch znaków Szukany
(wymagany) — jest to przeszukiwany łańcuch znaków.
(wymagany) — jest to szukany podłańcuch.
(opcjonalny) — określa sposób porównywania. Jeśli podasz argument Porównanie, argument Start przestanie być opcjonalny.
Porównanie
Oto przykłady: InStr("Alexander, Mike, H.",",") zwraca wartość 10, ponieważ pierwszy
przecinek w podanym łańcuchu znaków to znak numer 10. InStr(11,"Alexander, Mike, H.",",") zwraca wartość 16, ponieważ pierwszy przecinek od znaku 11. to znak numer 16.
Skoro funkcja InStr zwraca tylko numer, jak może pomóc w wykonaniu opisanego zadania? Należy zastosować ją razem z funkcjami Left, Right i Mid, aby pobrać fragmenty łańcuchów znaków. Na przykład zamiast określać w funkcji Left długość podłańcucha za pomocą zapisanej na stałe liczby, można wywołać zagnieżdżoną funkcję InStr, aby zwróciła potrzebną wartość. Na przykład wywołanie Left("Alexander, Mike",9) zadziała tak samo jak Left("Alexander, Mike",Instr("Alexander, Mike", ",")-1).
368
Część IV Analizowanie danych w Accessie
Przy stosowaniu funkcji InStr w funkcjach Left, Right i Mid czasem trzeba dodać lub odjąć jeden znak (zależy to od wykonywanego zadania). Na przykład wywołanie Left("Zey, Robert", InStr("Zey,Robert", ",")) zwraca "Zey,". Dlaczego zwracany jest także przecinek? Funkcja InStr zwraca liczbę 4, ponieważ pierwszy przecinek w łańcuchu znajduje się na czwartej pozycji. Funkcja Left wykorzystuje następnie wartość 4 jako argument określający długość podłańcucha, dlatego pobiera cztery pierwsze znaki: "Zey,". Jeśli chcesz pobrać tekst bez przecinka, musisz zmodyfikować wywołanie w następujący sposób: Left("Zey, Robert", InStr("Zey, Robert", ",")-1)
Odjęcie 1 od wyniku zwróconego przez funkcję InStr spowoduje, że zamiast 4 funkcja zwróci 3. Wtedy w funkcji Left argument określający długość będzie miał wartość 3, dlatego pobrane zostaną trzy pierwsze znaki: "Zey".
Najłatwiejszym sposobem na przetworzenie pola z imieniem i nazwiskiem osoby kontaktowej (zobacz rysunek 11.26) jest zastosowanie dwóch kwerend aktualizujących. Czasem przetwarzanie łańcuchów znaków jest skomplikowane, dlatego warto utworzyć pola testowe i wykonać operacje najpierw w nich. Dzięki temu można poradzić sobie z ewentualnymi pomyłkami.
Pierwsza kwerenda Pierwsza kwerenda, przedstawiona na rysunku 11.26, pobiera nazwisko z pola ContactName i zapisuje to nazwisko w polu Contact_LastName. Następnie umieszcza w polu Contact_ FirstName pozostałą część łańcucha. Rysunek 11.26. Ta kwerenda aktualizuje pola Contact_LastName i Contact_FirstName
Gdy otworzysz tabelę LeadList, zobaczysz efekty uruchomienia pierwszej z kwerend aktualizujących. Rysunek 11.27 przedstawia, jakie postępy udało się poczynić do tej pory. Druga kwerenda Druga kwerenda, przedstawiona na rysunku 11.28, aktualizuje pola Contact_FirstName i Contact_MI.
Rozdział 11. Przekształcanie danych
369
Rysunek 11.27. Sprawdzanie postępów
Rysunek 11.28. Ta kwerenda przetwarza imię i inicjał drugiego imienia z pola Contact_FirstName
Po uruchomieniu drugiej kwerendy można otworzyć tabelę i wyświetlić wyniki (zobacz rysunek 11.29). Rysunek 11.29. Dwie kwerendy pozwoliły przetworzyć pole ContactName na trzy odrębne pola
370
Część IV Analizowanie danych w Accessie
Rozdział 12.
Obliczenia i daty W tym rozdziale:
Korzystanie z obliczeń w analizach
Korzystanie z dat w analizach
W praktyce niewiele firm może analizować surowe dane w ich pierwotnej postaci. Zazwyczaj trzeba przeprowadzić pewne wstępne analizy z wykorzystaniem obliczeń i dat. Dopiero potem można przejść do ogólnych analiz. Do pracy z obliczeniami i datami wielu użytkowników najchętniej stosuje Excela. Jednak, jak dowiesz się z dalszej części rozdziału, Access udostępnia wiele narzędzi i funkcji wbudowanych, które umożliwiają korzystanie z obliczeń i dat. Wyjściową bazę danych do tego rozdziału, Rozdział12.accdb, można pobrać z witryny poświęconej tej książce. W trakcie używania tej przykładowej bazy danych będziesz mógł otworzyć kwerendy przedstawione na rysunkach. Niektóre z nich mogą wyglądać nieco inaczej niż na zrzutach. Nie martw się tym — Access czasem przenosi kryteria i wyrażenia z uwagi na działanie wbudowanego optymalizatora kwerend. Optymalizator odpowiada za uporządkowanie kwerendy w taki sposób, aby działała jak najszybciej i najwydajniej.
Korzystanie z obliczeń w analizach Jeśli jesteś użytkownikiem Excela próbującym poznać Accessa, jednym z pytań, jakie sobie zadasz, będzie bez wątpienia: „Gdzie można wpisywać wzory?”. W Excelu obliczenia można stosować w postaci wzorów bezpośrednio w analizowanym zbiorze danych. W Accessie jest to niemożliwe. Pytanie więc brzmi: „Gdzie w Accessie umieszczane są obliczenia?”. Wiesz już, że w Accessie pracuje się inaczej niż w Excelu. Najlepszym podejściem w przypadku używania środowiska bazodanowego jest przechowywanie danych niezależnie od analiz. Dlatego nie należy zapisywać obliczeń (wzorów) w zbiorze danych. To prawda, że można zapisywać obliczone wyniki w tabelach, jednak używanie tabel do przechowywania obliczonych danych jest problematyczne z kilku powodów:
372
Część IV Analizowanie danych w Accessie
Zachowane wyniki obliczeń zajmują cenną pamięć dyskową.
Zachowane wyniki obliczeń wymagają ciągłej konserwacji przy zmianie danych w tabelach.
Zachowane wyniki obliczeń zwykle powodują powiązanie danych z jednym procesem analitycznym.
Zamiast zapisywać obliczone wyniki jako trwałe dane, lepiej jest przeprowadzać obliczenia w czasie rzeczywistym, wtedy, gdy są potrzebne. Jest to gwarancją uzyskania możliwie aktualnych i precyzyjnych danych, a ponadto nie prowadzi do powiązania danych z konkretnymi analizami.
Typowe scenariusze związane z obliczeniami W Accessie do przeprowadzania obliczeń służą wyrażenia. Wyrażenie to połączenie wartości, operatorów i funkcji. Elementy te są przetwarzane, co prowadzi do zwrócenia nowej wartości, którą można zastosować w dalszych etapach przetwarzania. Na przykład 2+2 to wyrażenie zwracające liczbę całkowitą 4, którą można wykorzystać w późniejszych analizach. W Accessie wyrażenia można stosować niemal wszędzie (w kwerendach, formularzach, raportach, stronach dających dostęp do danych, a nawet — w pewnym zakresie — w tabelach) i wykonywać przy ich użyciu różne zadania. Z tego punktu dowiesz się, jak wzbogacić analizy dzięki przeprowadzanym w czasie rzeczywistym obliczeniom opartym na wyrażeniach. Stosowanie stałych w obliczeniach Większość obliczeń zwykle obejmuje trwale zapisane liczby lub stałe. Stała to niezmienna wartość statyczna. Na przykład w wyrażeniu [List_Price]*1,1 wartość 1,1 to stała (nigdy się nie zmienia). Na rysunku 12.1 pokazujemy, jak wykorzystać stałe w wyrażeniu w kwerendzie. Rysunek 12.1. W tej kwerendzie za pomocą stałej obliczana jest cena po 10-procentowej podwyżce
Tu tworzona jest kwerenda, która analizuje, jak będzie wyglądała cena produktu po 10-procentowej podwyżce. Zastosowane wyrażenie o aliasie „Podwyżka” zwiększa wartość w polu List_Price każdego rekordu o stałą 1,1. W ten sposób obliczana jest cena o 10% wyższa od pierwotnej ceny zapisanej w polu List_Price.
Rozdział 12. Obliczenia i daty
373
Używanie pól w obliczeniach Nie we wszystkich obliczeniach potrzebne są stałe. Wiele operacji matematycznych przeprowadza się na danych, które już znajdują się w polach w zbiorze danych. Obliczenia można przeprowadzać na podstawie dowolnych pól typu Liczba lub Waluta. W kwerendzie z rysunku 12.2 nie zastosowano żadnych stałych. Obliczenia są przeprowadzane na wartościach z każdego rekordu ze zbioru danych. Przypomina to używanie wartości z komórek we wzorach w Excelu. Rysunek 12.2. W tej kwerendzie na podstawie dwóch pól obliczana jest wartość DollarVariance
Wykorzystywanie wyników agregacji w obliczeniach Zastosowanie wyników agregacji w obliczeniach pozwala wykonać kilka etapów analiz w jednej kwerendzie. Rysunek 12.3 przedstawia kwerendę podsumowującą. Jest ona wykonywana w następujący sposób: 1. Kwerenda grupuje rekordy według regionów. 2. Kwerenda określa liczbę zamówień i sumę wpływów dla każdego regionu. 3. Kwerenda przypisuje wartościom zdefiniowane aliasy (OrderCount i Rev). 4. Kwerenda wykorzystuje wyniki agregacji jako wyrażenia przy obliczaniu wartości AvgDollarPerOrder dla poszczególnych regionów.
Rysunek 12.3. W tej kwerendzie wyniki agregacji dla każdego regionu wykorzystano w wyrażeniach w obliczeniach
374
Część IV Analizowanie danych w Accessie
Stosowanie wyników jednych obliczeń w innych jako wyrażeń Warto pamiętać, że w kwerendzie można przeprowadzić więcej niż jedne obliczenia. Wyniki jednych obliczeń można wykorzystać w innych jako wyrażenia. Przedstawia to rysunek 12.4.
Rysunek 12.4. W tej kwerendzie wykorzystano wyniki jednych obliczeń w drugich jako wyrażenie
Ta kwerenda najpierw oblicza zmodyfikowane prognozy, a następnie wykorzystuje wyniki tych obliczeń w innych, które zwracają różnicę między pierwotnymi a zmodyfikowanymi prognozami. Wykorzystywanie obliczeń jako argumentu funkcji Przyjrzyj się kwerendzie z rysunku 12.5. Obliczenia z tej kwerendy zwracają liczbę z częścią ułamkową. Zwracana jest liczba zawierająca separator dziesiętny i wiele dalszych cyfr. Użytkownik chce jednak zwracać zaokrągloną wartość, aby wynikowy zbiór danych był bardziej czytelny.
Rysunek 12.5. Wyniki tych obliczeń są mało czytelne, ponieważ zawierają wiele cyfr po separatorze dziesiętnym. Zaokrąglenie wyników znacznie poprawi ich czytelność
Rozdział 12. Obliczenia i daty
375
Aby przekształcić wyniki obliczeń na liczbę całkowitą, można zastosować funkcję Int. Jest to funkcja matematyczna, która usuwa część ułamkową liczby i zwraca liczbę całkowitą. Funkcja ta przyjmuje jeden argument — liczbę. Jednak zamiast zapisywać tę liczbę na stałe w wywołaniu funkcji, można przekazać wynik obliczeń jako argument. Przedstawia to rysunek 12.6.
Rysunek 12.6. Jako argument funkcji Int można wykorzystać wynik obliczeń. Pozwala to usunąć część ułamkową z uzyskanych danych Obliczenia zwracające wartość liczbową można wykorzystać w dowolnej funkcji, która przyjmuje argumenty liczbowe.
Tworzenie obliczeń za pomocą konstruktora wyrażeń Jeśli nie chcesz ręcznie tworzyć złożonych wyrażeń obejmujących funkcje i obliczenia, możesz wykorzystać dostępny w Accessie konstruktor wyrażeń. Narzędzie to pozwala tworzyć wyrażenia za pomocą kilku kliknięć myszą. Doświadczonym użytkownikom Excela konstruktor wyrażeń może przypominać excelowy kreator wstawiania funkcji. Oba mechanizmy pozwalają tworzyć wyrażenia dzięki wskazywaniu potrzebnych funkcji i pól z danymi. Aby uruchomić konstruktor wyrażeń, kliknij prawym przyciskiem myszy w komórce siatki QBE, gdzie ma się znaleźć wyrażenie, a następnie wybierz opcję Konstruuj, co pokazano na rysunku 12.7. Konstruktor wyrażeń można uruchomić w wyniku kliknięcia prawym przyciskiem myszy w dowolnym miejscu, w którym można wpisać wyrażenie: we właściwościach formantów formularzy, właściwościach formantów raportów, właściwościach pól tabel, a także w siatce QBE kwerend.
376
Część IV Analizowanie danych w Accessie
Rysunek 12.7. Otwórz konstruktor wyrażeń, klikając prawym przyciskiem myszy w wierszu Pole w siatce QBE i wybierając opcję Konstruuj
Na rysunku 12.8 widać, że konstruktor wyrażeń udostępnia cztery panele. Wyrażenia wpisuje się w górnym. W dolnych panelach widoczne są dostępne obiekty. W lewym dolnym panelu można kliknąć ikonę ze znakiem dodawania (+), aby zobaczyć obiekty bazy danych, które można wykorzystać przy konstruowaniu wyrażenia. Rysunek 12.8. Konstruktor wyrażeń wyświetla obiekty bazy danych, które można wykorzystać w wyrażeniu
Kliknij dwukrotnie dowolny obiekt bazy danych, aby przejść do obiektów z następnego poziomu. Na przykład dwukrotne kliknięcie obiektu Funkcje powoduje przejście do katalogu Funkcje wbudowane, w którym znajdują się wszystkie dostępne w Accessie funkcje. Na rysunku 12.9 widoczny jest konstruktor wyrażeń wyświetlający wszystkie dostępne funkcje matematyczne. Jeśli korzystasz z wersji Accessa innej niż 2013, konstruktor wyrażeń może wyglądać inaczej niż na rysunku 12.9. Jednak podstawowe funkcje tego narzędzia są takie same w każdej wersji programu.
Rozdział 12. Obliczenia i daty
377
Rysunek 12.9. Konstruktor wyrażeń (podobnie jak kreator wstawiania funkcji w Excelu) wyświetla wszystkie dostępne funkcje
Gdy dwukrotnie klikniesz potrzebną funkcję, Access automatycznie wprowadzi ją w górnym panelu konstruktora wyrażeń. W przykładzie z rysunku 12.10 wybrano funkcję Round. Jak widać, funkcja jest natychmiast umieszczana w górnym panelu konstruktora wyrażeń, a Access wyświetla argumenty potrzebne w funkcji. Tu podane są dwa argumenty — Number i Precision. Rysunek 12.10. Access informuje, jakie argumenty są potrzebne do działania funkcji
Jeśli nie wiesz, do czego służą poszczególne argumenty, kliknij hiperłącze w dolnej części okna dialogowego (zobacz rysunek 12.11). W oknie systemu pomocy pojawi się opis danej funkcji. Na rysunku 12.12 widać, że w funkcji Round zamiast zapisanej na stałe wartości wykorzystano wyrażenie, które generuje wartość dynamicznie. W obliczeniach suma z pola [Dim_TransactionMaster]![Line_Total] jest dzielona przez 13. Ponieważ argument Precision jest opcjonalny, został tu pominięty.
378
Część IV Analizowanie danych w Accessie
Rysunek 12.11. Dostępne są pliki pomocy ze szczegółowym objaśnieniem każdej funkcji
Rysunek 12.12. Ta funkcja zaokrągla wyniki obliczeń ([Dim_ TransactionMaster] ![Line _Total])/13
Gdy nowe wyrażenie jest już gotowe, kliknij przycisk OK, aby umieścić je w siatce QBE. Rysunek 12.13 przedstawia nowe wyrażenie dodane jako pole. Zauważ, że dla nowego pola zastosowano domyślny alias Wyr1. Możesz zmienić go na bardziej zrozumiałą nazwę. Rysunek 12.13. Nowe wyrażenie zwraca średnie okresowe wpływy z uwzględnieniem wszystkich transakcji
Rozdział 12. Obliczenia i daty
379
Typowe błędy w obliczeniach Niezależnie od tego, w jakiej platformie analizujesz dane, w obliczeniach zawsze mogą pojawić się błędy. W Accessie nie istnieje magiczna funkcja, która zapobiegałaby wystąpieniu błędów w analizach. Można jednak wykonać kilka prostych czynności, aby uniknąć pojawienia się najbardziej typowych błędów w obliczeniach. Priorytety operatorów Możliwe, że z lekcji matematyki pamiętasz, iż w skomplikowanych równaniach z wieloma operacjami matematycznymi działania nie zawsze są przeprowadzane od lewej do prawej. Niektóre są traktowane priorytetowo i dlatego należy wykonać je na początku. W Accessie obowiązują podobne reguły dotyczące priorytetów operatorów. Gdy używasz wyrażeń i obliczeń z kilkoma operacjami, każda z nich jest wykonywana w określonej kolejności. Ważne jest, aby znać priorytety operatorów Accessa. Niepoprawnie zbudowane wyrażenie może prowadzić do błędów w analizach. Kolejność operacji w Accessie wygląda tak: 1. Obliczanie wartości w nawiasach. 2. Potęgowanie (operator potęgowania to ^). 3. Negacja (operator – zmienia znak wartości). 4. Mnożenie (operator *) i dzielenie (operator /). Te operacje mają ten sam priorytet. 5. Dodawanie (operator +) i odejmowanie (operator -). Te operacje mają ten sam priorytet. 6. Scalanie łańcuchów znaków (operator &). 7. Porównania i dopasowywanie do wzorca (operatory >, <, =, <>, >=, <=, Like, Between, Is). Te operacje mają ten sam priorytet. 8. Operatory logiczne. Przetwarza się je w następującej kolejności: Not, And, Or. Operacje o tym samym priorytecie są wykonywane od lewej do prawej.
W jaki sposób znajomość kolejności operacji pomaga uniknąć błędów analitycznych? Zobacz to na prostym przykładzie. Otóż poprawnym wynikiem operacji (20+30)*40 jest 200. Jeśli jednak pominąć nawiasy, Access wykona działanie 20+30*4 w następujący sposób: 30 * 4 = 120, 120 + 20 = 140. Priorytety operatorów powodują, że Access najpierw mnoży, a dopiero potem dodaje wartości. Dlatego wyrażenie 20+30*4 zwróci błędną wartość. Ponieważ zgodnie z priorytetami operatorów Access najpierw wykonuje działania w nawiasach, umieszczenie w nich operacji 20+30 pozwala uzyskać poprawny wynik. Wykrywanie wartości Null Wartość Null oznacza brak wartości. Gdy w tabeli Accessa występuje pusta komórka (pozbawiona danych), jest uznawana za komórkę o wartości Null.
380
Część IV Analizowanie danych w Accessie
Doświadczeni użytkownicy Excela mogą być zdziwieni informacją, że wartość Null może powodować błędy w obliczeniach. W Excelu wartość Null w kolumnie liczb nie sprawia kłopotów, ponieważ Excel traktuje ją jak zero. W Accessie jest inaczej. Gdy Access natrafi na wartość Null, nie przyjmuje, że reprezentuje ona zero. Zamiast tego natychmiast zwraca wartość Null jako wynik. Aby zobaczyć, jak to działa, utwórz kwerendę przedstawioną na rysunku 12.14. Rysunek 12.14. Aby zobaczyć, w jaki sposób wartości Null mogą powodować błędy w obliczeniach, utwórz tę kwerendę w widoku projektu
Uruchom tę kwerendę. Pojawią się wyniki widoczne na rysunku 12.15. Zauważ, że w obliczeniach wariancji dla pierwszego rekordu wynik jest niezgodny z oczekiwaniami. Zamiast niego pojawia się wartość Null. Dzieje się tak, ponieważ prognoza dla tego rekordu jest wartością Null. Rysunek 12.15. Jak widać, dowolna zmienna Null w obliczeniach powoduje, że wynik to także wartość Null
Na podstawie rysunku 12.15 można sobie wyobrazić, że spowodowany wartością Null błąd w obliczeniach może prowadzić do problemów w analizach — zwłaszcza gdy proces analityczny jest skomplikowany. Ponadto błędy tego rodzaju bywają trudne do wykrycia i naprawienia. Można jednak uniknąć błędów powodowanych wartościami Null, używając funkcji Nz. Przekształca ona napotkane wartości Null na określoną wartość: Nz(Dane,Zastępnikdlanull)
Rozdział 12. Obliczenia i daty
381
Funkcja Nz przyjmuje dwa argumenty: Dane
— są to używane dane.
Zastępnikdlanull
— jest to wartość zwracana, gdy Dane mają wartość Null.
Wywołanie Nz([PoleLiczbowe]; 0) przekształca każdą wartość Null z pola PoleLiczbowe na zero. Ponieważ problemem jest tu pole Forecast, należy przekazać je do funkcji Nz. Rysunek 12.16 przedstawia zmodyfikowaną kwerendę. Rysunek 12.16. Należy przekazać pole Forecast do funkcji Nz, aby przekształcić wartości Null na zera
Na rysunku 12.17 widać, że wariancja jest zwracana dla pierwszego rekordu, choć wartości w polu Forecast to Null. Warto zauważyć, że funkcja Nz nie powoduje umieszczenia zera w miejsce wartości Null. Funkcja ta jedynie informuje Accessa, że ma traktować wartości Null jak zera w trakcie obliczania wartości pola Variance. Rysunek 12.17. W kolumnie Variance w pierwszym wierszu występuje teraz wartość
Sprawdzanie składni wyrażeń Także proste pomyłki w składni wyrażeń z obliczeniami mogą prowadzić do błędów. Stosuj się do przedstawionych poniżej wskazówek, aby uniknąć pomyłek:
Jeśli w obliczeniach używasz pól, umieszczaj je w nawiasach kwadratowych ([]).
Upewnij się, czy w nazwach pól nie pojawiły się literówki.
382
Część IV Analizowanie danych w Accessie
Uważaj, aby przy przypisywaniu aliasu do pola obliczeniowego nie podać przypadkowo nazwy pola z tabeli używanej w kwerendzie.
Nie stosuj w aliasach niedozwolonych znaków: kropki (.), wykrzyknika (!), nawiasów kwadratowych ([]) i ampersandu (&).
Używanie dat w analizach W Accessie wszystkie daty począwszy od 31 grudnia 1899 roku są zapisywane jako dodatnia liczba porządkowa. Data 31 grudnia 1899 to 1, 1 stycznia 1900 to 2 itd. System przechowywania dat w postaci liczb porządkowych (system 1900) jest domyślnym rozwiązaniem we wszystkich aplikacjach z pakietu Office. Możesz wykorzystać ten system do wykonywania obliczeń na datach.
Proste obliczenia na datach Rysunek 12.18 przedstawia jedne z najprostszych obliczeń, jakie można przeprowadzić na datach. Tu kwerenda dodaje 30 do każdej daty wysyłki. Powoduje to zwrócenie daty wysyłki przesuniętej o 30 dni do przodu. W ten sposób uzyskiwana jest nowa data. Rysunek 12.18. Ta kwerenda dodaje 30 do każdej daty wysyłki. Powstaje w ten sposób nowa data — równa dacie przesyłki przesuniętej do przodu o 30 dni
Aby obliczenia były prawidłowe, daty muszą znajdować się w polach typu Data/Godzina. Jeśli wpiszesz datę w polu tekstowym, będzie ona wyglądała jak data, ale Access będzie ją traktował jak łańcuch znaków. W efekcie obliczenia przeprowadzane na datach w formacie tekstowym będą nieprawidłowe. Upewnij się, czy wszystkie dane są przechowywane w polach typu Data/Godzina.
Można też obliczyć, ile dni dzieli dwie daty. Obliczenia przedstawione na rysunku 12.19 odejmują numer porządkowy odpowiadający jednej dacie od numeru porządkowego reprezentującego drugą datę. W ten sposób można otrzymać liczbę dni między dwoma datami.
Zaawansowane analizy z wykorzystaniem funkcji W Accessie 2013 dostępnych jest 25 wbudowanych funkcji dotyczących dat i godzin. Niektóre z nich stosuje się bardzo rzadko. Inne wykorzystywane są rutynowo. W tym punkcie znajdziesz omówienie wybranych spośród podstawowych funkcji związanych z datą i godziną. Są to funkcje, które mogą się przydać w typowych analizach.
Rozdział 12. Obliczenia i daty
383
Rysunek 12.19. Ta kwerenda określa liczbę dni między dwoma datami
Funkcja Date Date to wbudowana funkcja Accessa, która zwraca bieżącą datę systemową (czyli datę danego dnia). Dzięki tej wszechstronnej funkcji nie trzeba na stałe zapisywać w obliczeniach bieżącej daty. Oznacza to, że można przeprowadzać dynamiczne obliczenia, w których bieżąca data systemowa jest używana jak zmienna. W ten sposób każdego dnia uzyskany zostanie inny wynik. W tym podpunkcie opisaliśmy różne sposoby, w jakie można wykorzystać funkcję Date do wzbogacenia analiz. Określanie liczby dni między aktualną datą a dniem z przeszłości
Załóżmy, że masz za zadanie wykryć zaległe płatności. Musisz znać aktualną datę, aby móc ustalić, ile dni minęło od terminu płatności. Oczywiście można wprowadzić bieżącą datę ręcznie, jest to jednak niewygodne i może prowadzić do błędów. Aby zobaczyć, jak używać funkcji Date, utwórz kwerendę z rysunku 12.20. Rysunek 12.20. Ta kwerenda zwraca liczbę dni między bieżącą datą a datami poszczególnych zamówień
Używanie funkcji Date w kryteriach
Funkcję Date można wykorzystać do odfiltrowania rekordów, umieszczając ją w wyrażeniu używanym jako kryterium. Kwerenda z rysunku 12.21 zwraca wszystkie rekordy z zamówieniami złożonymi ponad 90 dni temu.
384
Część IV Analizowanie danych w Accessie
Rysunek 12.21. Nie ma znaczenia, jaka jest data — ta kwerenda zawsze zwraca wszystkie zamówienia złożone ponad 90 dni wcześniej
Obliczanie długości okresu w latach za pomocą funkcji Date
Załóżmy, że poproszono Cię o sporządzenie listy managerów zawierającej nazwiska i lata stażu pracy. Aby wykonać to zadanie, trzeba obliczyć różnicę między aktualną datą a datą zatrudnienia każdego managera. Pierwszy krok wymaga utworzenia kwerendy przedstawionej na rysunku 12.22. Rysunek 12.22. Należy obliczyć różnicę między bieżącą datą a dniem zatrudnienia każdego managera
Patrząc na wyniki zwrócone przez kwerendę (zobacz rysunek 12.23), łatwo zauważyć, że zwracana jest liczba dni między datami, a nie liczba lat. Rysunek 12.23. W zbiorze danych znajdują się liczby dni, a nie liczby lat
Rozdział 12. Obliczenia i daty
385
Aby rozwiązać problem, wróć do widoku projektu i podziel wartości przez 365,25. Dlaczego właśnie tyle? Jest to średnia liczba dni w roku, jeśli uwzględni się lata przestępne. Wprowadzoną zmianę przedstawia rysunek 12.24. Zauważ, że pierwotne obliczenia są teraz umieszczone w nawiasach. Pozwala to uniknąć błędów związanych z priorytetami operatorów. Rysunek 12.24. Należy podzielić pierwotny wynik przez 365,25, aby przekształcić wartość na liczbę lat
Spojrzenie na wyniki (zobacz rysunek 12.25) pozwala się przekonać, że po tej zmianie kwerenda zwraca liczbę lat. Teraz wystarczy usunąć część ułamkową za pomocą funkcji Int. Dlaczego zastosowano właśnie ją? Ponieważ nie zaokrągla danych w górę lub w dół, a jedynie przekształca wartość na czytelną liczbę całkowitą. Rysunek 12.25. Kwerenda zwraca teraz lata, trzeba jednak usunąć część ułamkową wyniku
Chcesz zaokrąglić liczbę lat? Możesz umieścić obliczenia dat w funkcji Round. Opisaliśmy ją w dodatku D.
Umieszczenie obliczeń w funkcji Int gwarantuje, że w wyniku uzyskasz tylko liczbę lat bez części ułamkowej (zobacz rysunek 12.26). Wiek osób można obliczyć za pomocą tej samej metody. Wystarczy zastąpić datę zatrudnienia datą urodzenia.
386
Część IV Analizowanie danych w Accessie
Rysunek 12.26. Ta kwerenda zwraca liczbę lat, jaką każdy pracownik spędził w firmie
Funkcje Year, Month, Day i Weekday Funkcje Year, Month, Day i Weekday służą do zwracania liczb całkowitych reprezentujących różne części dat. Wszystkie te funkcje pobierają jako argument prawidłową datę. Oto przykłady: Year(#1997-12-31#) zwraca 1997. Month(#1997-12-31#) zwraca 12. Day(#1997-12-31#) zwraca 31. Weekday(#1997-12-31#) zwraca 4. Funkcja Weekday na podstawie daty zwraca dzień tygodnia. W Accessie dni tygodnia mają numery od 1 do 7 (1 to niedziela). Dlatego jeśli funkcja Weekday zwraca 4, dniem tygodnia jest środa. Jeśli w Twoim kraju niedziela nie jest pierwszym dniem tygodnia, możesz wykorzystać opcjonalny argument FirstDayOfWeek. Określa on, który dzień tygodnia należy traktować jako pierwszy (1 to niedziela, 2 to poniedziałek, 3 to wtorek itd.). Jeśli pominiesz ten argument, domyślnie pierwszym dniem tygodnia będzie niedziela.
Na rysunku 12.27 pokazujemy, jak korzystać z wymienionych funkcji w kwerendach.
Rysunek 12.27. Funkcje Year, Month, Day i Weekday umożliwiają przetwarzanie części dat
Rozdział 12. Obliczenia i daty
387
Łatwy sposób na uwzględnianie w kwerendach tylko dni roboczych Załóżmy, że poproszono Cię o podanie łącznych wpływów wygenerowanych dzięki danemu produktowi, przy czym ważne są tylko wpływy uzyskane w dniach roboczych w roku kalendarzowym 2008. Dni robocze to te, które nie są weekendami ani świętami. Pierwszą rzeczą, jaką trzeba zrobić, aby wykonać to zadanie, jest utworzenie tabeli z listą wszystkich świąt w 2008 roku. Na poniższym rysunku widać, że taka tabela może zawierać tylko jedno pole z listą wszystkich dat odpowiadających świętom.
Po utworzeniu tabeli z wszystkimi świętami można przystąpić do pracy nad kwerendą. Na poniższym rysunku pokazujemy, jak utworzyć kwerendę, która odfiltrowuje dni wolne od pracy.
Warto poświęcić chwilę na przeanalizowanie zawartości ostatniego rysunku: 1. Tworzone jest sprzężenie lewostronne tabel TransactionMaster i Holidays, co informuje Accessa, że należy pobrać wszystkie rekordy z tabeli TransactionMaster. 2. Dla tabeli Holidays używane jest kryterium Is Null. To sprawia, że w tabeli TransactionMaster uwzględniane są tylko te daty, które nie pasują do dni wolnych wymienionych w tabeli Holidays. 3. Następnie tworzone jest pole DayCheck, w którym zapisywany jest dzień tygodnia dla daty każdej usługi z tabeli TransactionMaster. 4. Kwerenda filtruje dane według nowo utworzonego pola DayCheck, tak aby wykluczyć dni tygodnia, które reprezentują soboty i niedziele. 5. W ostatnim kroku dane są filtrowane w taki sposób, aby pozostały tylko rekordy, dla których rok w dacie zamówienia to 2008.
388
Część IV Analizowanie danych w Accessie
Funkcja DateAdd W wielu organizacjach analizuje się, którego dnia zostanie osiągnięta określona wartość. Na przykład większość firm chce wiedzieć, jaka będzie data 30 dni po złożeniu zamówienia. Ponadto warto ustalić, którego dnia należy wysłać do klienta przypomnienie. Łatwym sposobem na przeprowadzenie analiz tego typu jest wykorzystanie funkcji DateAdd. Zwraca ona datę, do której dodano określony okres: DateAdd(Okres;Liczba;Data)
Funkcja DateAdd zwraca datę, do której dodano określony okres. Funkcja ta przyjmuje trzy wymagane argumenty: Okres
(wymagany) — używany okres; możliwe okresy to:
"yyyy" — rok, "q" — kwartał, "m" — miesiąc, "y" — dzień roku, "d" — dzień, "w" — dzień tygodnia, "ww" — tydzień, "h" — godzina, "n" — minuta, "s" — sekunda. Liczba (wymagany) — liczba dodawanych jednostek danego okresu; liczba dodatnia
powoduje zwrócenie daty z przyszłości, natomiast liczba ujemna — daty z przeszłości. Data
Kwerenda z rysunku 12.28 pokazuje, jak wykorzystać funkcję DateAdd, aby ustalić dokładną datę osiągnięcia pewnej wartości. Kwerenda tworzy dwa nowe pola — Warning i Overdue. Funkcja DateAdd użyta w polu Warning zwraca datę przesuniętą o trzy tygodnie do przodu względem daty zamówienia. Funkcja DateAdd z pola Overdue zwraca datę przesuniętą o miesiąc do przodu względem pierwotnej daty zamówienia.
Rozdział 12. Obliczenia i daty
389
Rysunek 12.28. Ta kwerenda zwraca pierwotną datę zamówienia, datę dnia, kiedy należy wysłać przypomnienie, a także datę określającą, kiedy upływa 30 dni od złożenia zamówienia
Grupowanie danych według kwartałów Dlaczego miałbyś grupować dane według kwartałów? Większość baz danych przechowuje raczej konkretne daty niż oznaczenia kwartałów. Dlatego jeśli chcesz przeanalizować dane kwartalne, musisz przekształcić daty na kwartały. Co ciekawe, nie istnieje funkcja dla dat i godzin, która umożliwiałaby grupowanie dat według kwartałów. Istnieje jednak funkcja Format. Format to funkcja z kategorii Tekstowe. Umożliwia przekształcenie danych na łańcuch znaków. Przekształcanie odbywa się na podstawie instrukcji formatowania. W kontekście analizowania dat istnieje kilka poprawnych instrukcji, które można przekazać do funkcji Format: Format(#2004-01-31#; "yyyy") zwraca 2004. Format(#2004-01-31#; "yy") zwraca 04. Format(#2004-01-31#; "q") zwraca 1. Format(#2004-01-31#; "mmm") zwraca Jan. Format(#2004-01-31#; "mm") zwraca 01. Format(#2004-01-31#; "d") zwraca 31. Format(#2004-01-31#; "w") zwraca 7. Format(#2004-01-31#; "ww") zwraca 5. Warto pamiętać, że wartość zwrócona po przekazaniu daty do funkcji Format to łańcuch znaków, dlatego nie można wykorzystać tej wartości w dalszych obliczeniach.
Kwerenda z rysunku 12.29 grupuje daty złożenia wszystkich zamówień według kwartałów, a następnie grupuje dane w ramach poszczególnych kwartałów, aby uzyskać sumę wpływów z każdego z nich.
390
Część IV Analizowanie danych w Accessie
Rysunek 12.29. Za pomocą funkcji Format można pogrupować daty według kwartałów
Jeśli chcesz zastosować bardziej wymyślne rozwiązanie, możesz wykorzystać funkcję Format w kwerendzie krzyżowej, podając Quarter jak kolumnę (zobacz rysunek 12.30).
Rysunek 12.30. Funkcję Format można też wykorzystać w kwerendzie krzyżowej
Na rysunku 12.31 widać, że wynikowy zbiór danych w przejrzysty sposób pokazuje wpływy dla produktów w ujęciu kwartalnym. Rysunek 12.31. Dane udało się pogrupować według kwartałów
Rozdział 12. Obliczenia i daty
391
Funkcja DateSerial Funkcja DateSerial umożliwia utworzenie daty dzięki połączeniu jej elementów: roku, miesiąca i dnia. Funkcja ta doskonale się nadaje do przekształcania na datę odrębnych łańcuchów znaków, które razem reprezentują określony dzień. DateSerial(Rok;Miesiąc;Dzień)
Funkcja DateSerial przyjmuje trzy argumenty: Rok (wymagany) — dowolna liczba lub wyrażenie liczbowe o wartości od 100 do 9999. Miesiąc Dzień
(wymagany) — dowolna liczba lub wyrażenie liczbowe.
(wymagany) — dowolna liczba lub wyrażenie liczbowe.
Poniższa przykładowa instrukcja zwraca wartość 2012-04-03. DateSerial(2012; 4; 3)
W jaki sposób może to być przydatne? Teraz można zastosować kilka sztuczek i wykonać obliczenia w wywołaniu funkcji DateSerial. Oto kilka możliwości:
Można otrzymać pierwszy dzień ostatniego miesiąca, odejmując 1 od bieżącego miesiąca i podając 1 jako argument Dzień: DateSerial(Year(Date()); Month(Date()) - 1; 1)
Można otrzymać pierwszy dzień następnego miesiąca, dodając 1 do bieżącego miesiąca i podając 1 jako argument Dzień: DateSerial(Year(Date()); Month(Date()) + 1; 1)
Można otrzymać ostatni dzień bieżącego miesiąca, dodając 1 do bieżącego miesiąca i podając 0 jako argument Dzień: DateSerial(Year(Date()); Month(Date()) + 1; 0)
Można otrzymać ostatni dzień następnego miesiąca, dodając 2 do bieżącego miesiąca i podając 0 jako argument Dzień: DateSerial(Year(Date()); Month(Date()) + 2; 0)
Przekazanie 0 jako argumentu Dzień automatycznie powoduje otrzymanie ostatniego dnia miesiąca poprzedzającego miesiąc określony w funkcji DateSerial. Warto wspomnieć, że funkcja DateSerial potrafi przeskakiwać między latami. Wywołanie Month(Date()) – 1 działa poprawnie także dla stycznia, a Month(Date()) + 1 dla grudnia.
392
Część IV Analizowanie danych w Accessie
Rozdział 13.
Analizy warunkowe W tym rozdziale:
Stosowanie kwerend z parametrami
Stosowanie funkcji warunkowych
Funkcje IIf i Switch
Do tej pory przedstawialiśmy proste analizy. Wystarczyło utworzyć kwerendę, dodać kryteria i obliczenia, zapisać kwerendę i uruchomić ją w odpowiednim momencie. Co jednak robić, jeśli kryteria związane z analizami często się zmieniają lub gdy procesy analityczne zależą od wystąpienia określonych warunków? W takich sytuacjach należy się posłużyć analizą warunkową, czyli analizą, której wynik zależy od wcześniej zdefiniowanego zbioru warunków. Oprócz kodu VBA i makr istnieje też kilka innych narzędzi i funkcji (np. kwerendy z parametrami, funkcja IIf i funkcja Switch) pozwalających tworzyć analizy warunkowe. W tym rozdziale poznasz narzędzia i funkcje, które pomogą Ci zaoszczędzić czas, uporządkować proces analityczny i wzbogacić analizy. Początkową bazę danych do tego rozdziału, Rozdział13.accdb, można pobrać z witryny poświęconej tej książce.
Stosowanie kwerend z parametrami W trakcie pracy nad procesem analitycznym możesz zauważyć, że często trudno jest przewidzieć każdą możliwą kombinację kryteriów, jaka może być potrzebna. W takiej sytuacji przydatne są kwerendy z parametrami. Kwerenda z parametrami to interaktywna kwerenda, która przed rozpoczęciem pracy żąda podania kryteriów. Jest przydatna, gdy przy każdym uruchomieniu kwerendy trzeba przekazać do niej inne pytania, używając różnych kryteriów. Aby dobrze zrozumieć, w jaki sposób kwerendy z parametrami mogą być przydatne, utwórz kwerendę przedstawioną na rysunku 13.1. Za jej pomocą można wyświetlić wszystkie zamówienia złożone w okresie 200705.
394
Część IV Analizowanie danych w Accessie
Rysunek 13.1. Ta kwerenda zawiera zapisane na stałe kryterium określające okres
Choć kwerenda ta zwraca pożądane wyniki, problem polega na tym, że kryterium określające okres jest zapisane na stałe jako 200705. Dlatego gdy zechcesz przeanalizować wpływy z innego okresu, będziesz musiał utworzyć kwerendę od nowa. Zastosowanie kwerendy z parametrami pozwala opracować analizy warunkowe, oparte na zmiennych określanych przy każdym uruchomieniu kwerendy. Aby utworzyć taką kwerendę, wystarczy zastąpić zapisane na stałe kryteria tekstem umieszczonym w nawisach kwadratowych ([]), co przedstawia rysunek 13.2. Rysunek 13.2. Aby utworzyć kwerendę z parametrami, zastąp zapisane na stałe kryteria tekstem umieszczonym w nawiasach kwadratowych
Gdy uruchomisz kwerendę z parametrami, pojawi się okno dialogowe Wprowadzanie wartości parametru, gdzie należy podać wartość zmiennej. Warto zauważyć, że tekst wpisany w nawiasach kwadratowych z parametrem pojawia się w oknie dialogowym. Na tym etapie można wprowadzić wartość parametru, co przedstawia rysunek 13.3. Rysunek 13.3. Wpisz kryteria w oknie dialogowym Wprowadzanie wartości parametru i kliknij przycisk OK
Rozdział 13. Analizy warunkowe
395
Jak działają kwerendy z parametrami? Gdy uruchamiasz kwerendę z parametrami, Access próbuje przekształcić tekst na literały, otaczając tekst cudzysłowem. Jeśli jednak wokół tekstu znajdują się nawiasy kwadratowe ([]), Access przyjmuje, że ten tekst to zmienna. Wtedy w kilku krokach próbuje określić wartość zmiennej: 1. Access sprawdza, czy zmienna to nazwa pola. Jeśli tak jest, w wyrażeniu używana jest wartość tego pola. 2. Jeżeli zmienna nie jest nazwą pola, Access sprawdza, czy zmienna odpowiada polu obliczeniowemu. Jeśli tak jest, Access wykonuje odpowiednie operacje matematyczne. 3. Jeżeli zmienna nie jest polem obliczeniowym, Access sprawdza, czy zmienna wskazuje pewien obiekt, np. formant z otwartego formularza lub raportu. 4. Jeśli wszystko zawiodło, pozostaje tylko zapytać użytkownika o wartość zmiennej. Access wyświetla wtedy okno dialogowe Wprowadzanie wartości parametru z wyświetlonym tekstem z wiersza Kryteria.
Podstawowe zasady dotyczące kwerend z parametrami Kwerendy z parametrami (podobnie jak inne mechanizmy Accessa) związane są z określonymi podstawowymi regułami, których należy przestrzegać, aby rozwiązanie działało poprawnie. Oto te zasady:
Trzeba umieścić nawiasy kwadratowe ([]) wokół parametru. Jeśli tego nie zrobisz, Access automatycznie przekształci wprowadzony tekst na literał.
Nie można podać nazwy pola jako parametru. W przeciwnym razie Access zastąpi parametr wartością danego pola.
W nazwie parametru nie można używać kropek (.), wykrzykników (!), nawiasów kwadratowych ([]) ani ampersandów (&).
Nazwa parametru nie powinna zawierać zbyt wielu znaków. Jeśli będzie za długa, może nie zmieścić się w całości w oknie dialogowym Wprowadzanie wartości parametru. Ponadto nazwy parametrów powinny być jak najbardziej jednoznaczne i zwięzłe. Jeśli chcesz umieścić nazwę pola w określeniu parametru, dodaj do niej wybrane znaki. Na przykład zamiast używać określenia [System_Period] wpisz [System_Period:?]. Dwukropek (:) i znak zapytania (?) nie pełnią tu żadnej specjalnej funkcji — możesz dodać dowolny inny znak. Chodzi o to, aby umożliwić Accessowi odróżnienie określenia parametru od nazwy pola, a jednocześnie utworzyć określenie jak najbardziej podobne do nazwy pola.
Używanie kwerend z parametrami W przykładzie widocznym na rysunku 13.2 wykorzystano parametr do zdefiniowania jednego kryterium. Choć jest to najczęstszy sposób korzystania z parametrów w kwerendach, istnieje też wiele innych możliwości. Można nawet powiedzieć, że im bardziej
396
Część IV Analizowanie danych w Accessie
pomysłowo podejdziesz do kwerend z parametrami, tym bardziej eleganckie i zaawansowane będą późniejsze analizy. W tym punkcie opisaliśmy różne sposoby stosowania parametrów w kwerendach. Stosowanie wielu warunków opartych na parametrach Nie ma ograniczenia liczby parametrów stosowanych w kwerendzie. Na rysunku 13.4 pokazano, jak wykorzystać w kwerendzie więcej niż jeden parametr. Gdy uruchomisz tę kwerendę, zobaczysz prośbę o podanie okresu i identyfikatora produktu. Pozwala to dynamicznie przefiltrować dane na podstawie dwóch kryteriów bez konieczności modyfikowania kwerendy. Rysunek 13.4. W kwerendzie można zastosować więcej niż jeden parametr
Łączenie parametrów z operatorami Parametry można łączyć z dowolnymi operatorami, jakie standardowo mogą występować w kwerendach. Stosowanie parametrów razem ze standardowymi operatorami umożliwia dynamiczne rozszerzanie lub zawężanie filtrów w analizach bez konieczności tworzenia nowej kwerendy. Aby zobaczyć, jak to działa, utwórz kwerendę przedstawioną na rysunku 13.5. Rysunek 13.5. W tej kwerendzie połączono operatory standardowe z parametrami, aby ograniczyć listę wyników
Rozdział 13. Analizy warunkowe
397
W tej kwerendzie używane są operatory BETWEEN...AND oraz > (znak większości). Służą one do ograniczenia listy wyników kwerendy na podstawie parametrów zdefiniowanych przez użytkownika. Ponieważ kwerenda obejmuje trzy parametry, użytkownik jest proszony o podanie wartości trzykrotnie: musi podać okres początkowy, okres końcowy i wartość w złotówkach. Liczba zwróconych rekordów zależy od wprowadzonych parametrów. Na przykład jeśli wpiszesz 200701 jako okres początkowy, 200703 jako okres końcowy i 500 jako liczbę złotych, otrzymasz 1700 rekordów. Łączenie parametrów z symbolami wieloznacznymi Jednym z problemów w kwerendach z parametrami jest to, że jeśli użytkownik pominie parametr przy uruchamianiu kwerendy, nie zwróci ona żadnych rekordów. Jednym ze sposobów na rozwiązanie tego problemu jest połączenie parametrów z symbolami wieloznacznymi, tak że gdy użytkownik pominie parametr, kwerenda zwróci wszystkie rekordy. Aby zobaczyć, jak stosować symbole wieloznaczne z parametrami, utwórz kwerendę przedstawioną na rysunku 13.6. Po uruchomieniu wyświetla ona prośbę o podanie okresu. Ponieważ używany jest symbol wieloznaczny, można albo podać okres i przefiltrować dzięki temu dane na podstawie jednego okresu, albo pominąć parametr i otrzymać wszystkie rekordy. Rysunek 13.6. Jeśli użytkownik pominie parametr w tej kwerendzie, to z uwagi na wykorzystanie symbolu wieloznacznego zwróci ona wszystkie rekordy
Stosowanie symboli wieloznacznych razem z parametrami umożliwia użytkownikom uzyskanie wyników także po wprowadzeniu fragmentu parametru. Załóżmy, że kryterium w kwerendzie z parametrami wygląda tak: Like [Podaj nazwisko] & "*"
Gdy wpiszesz „A” jako parametr, otrzymasz wszystkie nazwiska rozpoczynające się od litery A. Teraz przyjmijmy, że kryterium w kwerendzie z parametrami wygląda tak: Like "*" & [Podaj nazwisko] & "*"
Wpisanie „A” powoduje zwrócenie wszystkich nazwisk zawierających literę A. Warto zauważyć, że te kryteria prowadzą do zwrócenia tylko rekordów o określonej wartości. Nie są zwracane rekordy, których wartość to Null. Aby otrzymać także rekordy o wartości Null, należy zastosować następujące kryterium: Like "*" & [Enter Lastname] & "*" or IS NULL
398
Część IV Analizowanie danych w Accessie
Używanie parametrów jako zmiennych w obliczeniach Parametry można stosować nie tylko jako kryteria w kwerendach. Można je wykorzystać w dowolnym miejscu, gdzie używa się zmiennej. Wyjątkowo przydatne są parametry w obliczeniach. Na przykład kwerenda z rysunku 13.7 pozwala zobaczyć, jak wysokie będą ceny po podwyżce o procent wpisany jako parametr. Gdy uruchomisz tę kwerendę, musisz wprowadzić wartość procentową, o jaką chcesz podnieść ceny. Kwerenda z parametrami wykorzysta tę wartość jako zmienną w obliczeniach. Rysunek 13.7. Parametry można wykorzystać w obliczeniach. Pozwala to zmieniać wartości zmiennych w obliczeniach przy każdym uruchomieniu kwerendy
Używanie parametrów jako argumentów funkcji Parametry można też wykorzystać jako argumenty funkcji. Na rysunku 13.8 pokazano, jak wywołać funkcję DateDiff za pomocą parametrów zamiast przy użyciu dat zapisanych na stałe. Gdy uruchomisz tę kwerendę, zostaniesz poproszony o podanie początkowej i końcowej daty. Daty te posłużą za argumenty funkcji DateDiff. W ten sposób przy każdym uruchomieniu kwerendy można podawać nowe daty bez konieczności jej modyfikowania.
Rysunek 13.8. Argumentami funkcji mogą być parametry zamiast zapisanych na stałe wartości Pamiętaj, że wartości wprowadzone jako parametry muszą pasować do typu danych argumentu funkcji. Na przykład jeśli chcesz wykorzystać parametr w funkcji DateDiff, musisz wprowadzić datę. W przeciwnym razie funkcja nie zadziała.
Rozdział 13. Analizy warunkowe
399
Po uruchomieniu kwerendy 13.8 datę początkową i datę końcową trzeba wprowadzić tylko raz, choć każda z tych dat jest używana w dwóch miejscach kwerendy. Wynika to z tego, że wartość przypisana do parametru jest używana także w dalszych jego wystąpieniach.
Jeśli musisz więcej niż raz wprowadzić wartość parametru używanego kilkakrotnie w kwerendzie, prawdopodobnie w jednym z miejsc pojawiła się literówka. Aby tego uniknąć, możesz kopiować nazwę parametru. Tworzenie parametrów przyjmujących różne wartości Kwerenda z parametrami z poniższego rysunku umożliwia dynamiczne filtrowanie wyników na podstawie okresu podanego jako parametr. Kwerenda ta nie umożliwia jednak jednoczesnego wyświetlania wyników dla więcej niż jednego okresu.
Można wykorzystać więcej niż jeden parametr, co pokazano na poniższym rysunku. W odróżnieniu od kwerendy z poprzedniego rysunku ta umożliwia uwzględnienie w wynikach więcej niż jednego okresu. Nadal jednak obowiązuje tu ograniczenie liczby parametrów, jakie można umieścić w kwerendzie (tu można podać maksymalnie trzy parametry).
400
Część IV Analizowanie danych w Accessie
Jak pozwolić na wprowadzenie dowolnej liczby parametrów? Rozwiązanie jest stosunkowo proste. Należy utworzyć parametr przekazywany do funkcji InStr, aby ustalić numer pozycji. Więcej informacji o funkcji InStr znajdziesz w rozdziale 4. W kwerendzie przedstawionej na poniższym rysunku pokazano, jak uzyskać pożądany efekt.
Warto zauważyć, że parametr nie pełni tu funkcji kryterium w polu Period. Zamiast tego parametr jest używany w funkcji InStr do sprawdzenia numeru pozycji zmiennej wprowadzonej w oknie parametrów: InStr([Wpisz okresy rozdzielone przecinkami];[Period])
Jeśli funkcja InStr znajdzie zmienną, zwróci numer pozycji. Jeśli jej nie znajdzie, zwróci zero. Tak więc szukane są rekordy, dla których zwracany jest numer pozycji większy niż zero (czyli które spełniają warunek ustawiony w kryterium). Gdy uruchomisz tę kwerendę, pojawi się okno dialogowe Wprowadzanie wartości parametru (zobacz poniższy rysunek). Możesz w nim wpisać dowolną liczbę zmiennych.
Stosowanie funkcji warunkowych Kwerendy z parametrami nie są jedynym narzędziem Accessa umożliwiającym przeprowadzanie analiz warunkowych. Access udostępnia też wbudowane funkcje, które ułatwiają porównywanie wartości, sprawdzanie poprawności danych i warunkowe obliczanie wartości. Dwie spośród tych funkcji to IIf i Switch. Te funkcje warunkowe (nazywane też funkcjami sterowania przepływem programu) sprawdzają warunki i w zależności od wyniku wykonują inne operacje. Z tego podrozdziału dowiesz się, jak za pomocą funkcji IIf i Switch sterować przebiegiem analiz.
Rozdział 13. Analizy warunkowe
401
Funkcja IIf Funkcja IIf (od ang. immediate if, czyli „natychmiastowe if”) działa jak instrukcja IF, ale dla jednej operacji. Funkcja IIf sprawdza warunek i zwraca wynik na podstawie tego, czy warunek jest spełniony czy nie: IIf(Wyrażenie; WynikDlaTrue; WynikDlaFalse)
Aby zastosować funkcję IIf, trzeba podać trzy wymagane argumenty: sprawdzane wyrażenie, wartość zwracaną dla wyrażeń o wartości True i wartość zwracaną dla wyrażeń o wartości False. Wyrażenie
(wymagany) — sprawdzane wyrażenie.
WynikDlaTrue
(wymagany) — wartość zwracana dla wyrażeń o wartości True.
WynikDlaFalse
(wymagany) — wartość zwracana dla wyrażeń o wartości False.
Przecinki w funkcji IIf możesz traktować jak instrukcje THEN i ELSE. Przyjrzyj się poniższemu wywołaniu funkcji IIf: IIf(Dzieci = 2; "Bliźniaki"; "Nie bliźniaki")
Funkcja ta oznacza: „jeśli Dzieci równa się dwa, to Bliźniaki, w przeciwnym razie to Nie bliźniaki”.
Używanie funkcji IIf w celu uniknięcia błędów matematycznych Aby zapoznać się z prostym problemem, w którego rozwiązaniu może pomóc funkcja IIf, utwórz kwerendę przedstawioną na rysunku 13.9. Rysunek 13.9. Ta kwerenda wykonuje obliczenia na podstawie wartości pól Actual i Forecast, aby ustalić zależność między nimi
Gdy uruchomisz tę kwerendę, zauważysz, że nie wszystkie wyniki wyglądają poprawnie. Jak widać na rysunku 13.10, wystąpiły błędy z uwagi na dzielenie przez zero (wynikają one z tego, że kwerenda próbuje podzielić wpływy przez zerowe prognozy). Rysunek 13.10. Błędy w wynikach są efektem dzielenia wpływów przez zero
402
Część IV Analizowanie danych w Accessie
Choć problem ten wydaje się mało istotny, w skomplikowanym, wielopoziomowym procesie analitycznym błędy tego typu mogą prowadzić do niepoprawnych analiz. Aby uniknąć takich błędów, można przeprowadzić na zbiorze danych analizy warunkowe z wykorzystaniem funkcji IIf i przed wykonaniem obliczeń sprawdzać wartość pola Forecast w każdym rekordzie. Jeśli pole to ma wartość zero, należy pominąć obliczenia i zwrócić zero. Jeżeli pole ma wartość niezerową, można przeprowadzić obliczenia, aby uzyskać prawidłową wartość. Wywołanie funkcji IIf powinno wyglądać tak: IIf([Forecast]=0;0;[Actual]/[Forecast])
Na rysunku 13.11 pokazano, jak działa ta funkcja.
Rysunek 13.11. Ta funkcja IIf umożliwia sprawdzanie pól Forecast pod kątem wartości zero i pomijanie pól o tej wartości w obliczeniach
Jak widać na rysunku 13.12, pozwala to uniknąć błędów. Rysunek 13.12. Funkcja IIf pomaga uniknąć błędów dzielenia przez zero
Przyspieszanie pracy za pomocą funkcji IIf Za pomocą funkcji IIf można też przyspieszyć proces analityczny i zaoszczędzić dzięki temu czas. Załóżmy, że na liście danych kontaktowych chcesz oznaczyć dużych i małych klientów na podstawie ich potencjalnych wydatków. Zdecydowałeś się zaktualizować pole MyTest w zbiorze danych wartościami „LARGE” i „SMALL” w zależności od potencjalnych wydatków poszczególnych klientów. Gdyby nie było funkcji IIf, zadanie to wymagałoby uruchomienia dwóch kwerend aktualizujących, przedstawionych na rysunkach 13.13 i 13.14. Czy kwerendy przedstawione na rysunkach 13.13 i 13.14 wykonają opisane zadanie? Tak. Jednak ten sam efekt można uzyskać za pomocą jednej kwerendy wykorzystującej funkcję IIf.
Rozdział 13. Analizy warunkowe
403
Rysunek 13.13. Ta kwerenda aktualizuje pole MyTest i oznacza słowem „LARGE” wszystkich klientów o potencjalnych wydatkach równych przynajmniej 10 000 złotych
Rysunek 13.14. Ta kwerenda aktualizuje pole MyTest i oznacza słowem „SMALL” wszystkich klientów o potencjalnych wydatkach niższych niż 10 000 złotych
Kwerenda aktualizująca z rysunku 13.15 pokazuje, jak wykorzystać funkcję IIf jako wyrażenie aktualizujące. Rysunek 13.15. Używając funkcji IIf, opisane zadanie można wykonać w jednej kwerendzie
Przyjrzyj się funkcji IIf używanej jako wyrażenie aktualizujące: IIf([DollarPotential]>=10000;"LARGE";"SMALL")
Funkcja ta informuje Accessa, że ma sprawdzić wartość pola DollarPotential w każdym rekordzie. Jeśli polecenie to ma wartość równą przynajmniej 10 000, należy zaktualizować dane za pomocą słowa „LARGE”. Jeżeli wartość jest mniejsza niż 10 000, należy wstawić słowo „SMALL”.
404
Część IV Analizowanie danych w Accessie
W funkcjach IIf można stosować operatory warunkowe (AND, OR, BETWEEN), aby dodać nowy poziom do wyrażenia warunkowego. Na przykład poniższa funkcja sprawdza potencjalne wydatki i segment, aby uzyskać wartość True lub False: IIf([DollarPotential]>10000 And [Segment]="Metal Fabrication";"True";"False")
Zagnieżdżanie funkcji IIf w celu sprawdzenia kilku warunków Testowany warunek czasem jest zbyt skomplikowany, aby było możliwe sprawdzenie go za pomocą prostej struktury IF…THEN…ELSE. Wtedy można zastosować zagnieżdżone funkcje IIf, czyli takie funkcje umieszczone w innych funkcjach IIf. Przyjrzyj się następującemu przykładowi: IIf([VALUE]>100;"A";IIf([VALUE]<100;"C";"B"))
Ta funkcja sprawdza, czy VALUE ma wartość większą niż 100. Jeśli tak jest, należy zwrócić "A". W przeciwnym razie uruchamiana jest druga funkcja IIf. Sprawdza ona, czy VALUE ma wartość mniejszą niż 100. Jeżeli tak jest, należy zwrócić "C". W przeciwnym razie zwracana jest wartość "B". Ponieważ funkcja IIf zwraca wyniki dla wartości True lub False, można rozbudować warunek, umieszczając w wyrażeniu dla wartości False inną funkcję IIf zamiast zapisanej na stałe wartości. To prowadzi do dalszych testów. Nie istnieje ograniczenie liczby zagnieżdżonych funkcji IIf, które można wykorzystać. Używanie funkcji IIf w analizach krzyżowych Wielu doświadczonych analityków używa funkcji IIf do tworzenia niestandardowych analiz krzyżowych zamiast uruchamiać kwerendy krzyżowe. Wśród wielu zalet przeprowadzania analiz krzyżowych bez kwerend krzyżowych jest możliwość kategoryzowania i grupowania niepowiązanych ze sobą danych. W przykładzie przedstawionym na rysunku 13.16 zwracana jest lista managerów zatrudnionych przed rokiem 2009 i po tym roku. W kwerendzie krzyżowej utworzenie tak precyzyjnych kategorii byłoby niemożliwe.
Rysunek 13.16. Ta kwerenda pokazuje, jak utworzyć analizy krzyżowe bez stosowania kwerendy krzyżowej
Rozdział 13. Analizy warunkowe
405
Wyniki widoczne na rysunku 13.17 są równie przejrzyste i zrozumiałe jak wyniki zwracane przez kwerendy krzyżowe. Rysunek 13.17. Wynikowy zbiór danych jest równie przejrzysty jak w kwerendach krzyżowych
Inną zaletą przeprowadzania analiz krzyżowych bez kwerend krzyżowych jest możliwość uwzględnienia w raporcie więcej niż jednych obliczeń. Na rysunku 13.18 pokazano kwerendę, która zwraca sumę jednostek i wpływy w formacie znanym z kwerend krzyżowych.
Rysunek 13.18. Tworzenie za pomocą funkcji IIf raportów w formacie kwerend krzyżowych pozwala obliczyć więcej niż jedną wartość
Jak widać na rysunku 13.19, wynikowy zbiór danych zapewnia bogate informacje w czytelnym formacie. Ponieważ standardowa kwerenda krzyżowa nie pozwala na obliczenie więcej niż jednej wartości (tu wartościami są liczba jednostek i wpływy), uzyskanie takiego widoku za pomocą kwerendy tego typu byłoby niemożliwe. Rysunek 13.19. Kwerenda krzyżowa nie umożliwia wykonywania wielu obliczeń, dlatego nie pozwala na przeprowadzenie takich analiz
Funkcja Switch Funkcja Switch pozwala sprawdzić wartości wyrażeń z listy i zwraca wartość powiązaną z wyrażeniem o wartości True. Aby zastosować funkcję Switch, trzeba podać przynajmniej jedno wyrażenie i przynajmniej jedną wartość: Switch(Wyrażenie; Wartość) Wyrażenie Wartość
(wymagany) — sprawdzane wyrażenie.
(wymagany) — wartość zwracana dla wyrażeń o wartości True.
406
Część IV Analizowanie danych w Accessie
Funkcja Switch jest tak przydatna, ponieważ umożliwia jednoczesne sprawdzenie wartości wielu wyrażeń i ustalenie, które z nich ma wartość True. Aby sprawdzić kilka wyrażeń, dodaj do funkcji następną parę Wyrażenie – Wartość: Switch(Wyrażenie1; Wartość1; Wyrażenie2; Wartość2; Wyrażenie3; Wartość3)
Funkcja Switch sprawdza po kolei każde wyrażenie. Jeśli wartość danego wyrażenia to True, zwracana jest wartość podana po tym wyrażeniu. Jeżeli kilka wyrażeń ma wartość True, funkcja zwraca wartość podaną po pierwszym takim wyrażeniu (pozostałe są ignorowane). Warto pamiętać, że funkcja Switch może sprawdzać wartość dowolnej liczby wyrażeń. Jeśli żadne z wyrażeń sprawdzanych przez funkcję Switch nie ma wartości True, funkcja zwraca wartość Null. Na przykład poniższa funkcja sprawdza wartość zmiennej Count i na tej podstawie zwraca określoną wartość: Switch([Count] < 10; "Mało"; [Count] > 15; "Dużo")
Problem polega na tym, że jeśli zmienna Count ma wartość z przedziału od 10 do 15, funkcja zwróci Null, ponieważ żadne z wyrażeń nie pasuje do takiej wartości. Może to pośrednio powodować błędy w innych miejscach analiz. Aby uniknąć takiej sytuacji, można dodać uniwersalne wyrażenie i powiązać z nim wartość zwracaną, gdy żadne z wcześniejszych wyrażeń nie ma wartości True: Switch([Count] < 10, "Mało", [Count] > 15, "Dużo", True, "Średnio")
Dodanie ostatniego wyrażenia, True, sprawia, że gdy żadne z pozostałych wyrażeń nie ma wartości True, zwracana jest wartość "Średnio".
Porównanie funkcji IIf i Switch Choć funkcja IIf jest wszechstronnym narzędziem, które pozwala wykonać większość analiz warunkowych, ma ograniczoną liczbę argumentów, dlatego działa jak podstawowa konstrukcja IF…THEN…ELSE. To ograniczenie sprawia, że trudno jest sprawdzać złożone warunki bez stosowania zagnieżdżonych funkcji IIf. Chociaż nie ma nic złego w używaniu takich funkcji, w niektórych analizach liczba sprawdzanych warunków powoduje, że tworzenie zagnieżdżonych funkcji IIf jest w najlepszym przypadku niepraktyczne. Aby się o tym przekonać, zastanów się nad następującą sytuacją: klientów często dzieli się na grupy na podstawie rocznych lub łącznych wpływów, jakie generują dla firmy. Załóżmy, że firma przypisuje klientów do czterech grup: A, B, C i D (tabela 13.1). Tabela 13.1. Grupy klientów Roczne wpływy
Grupa klientów
>= 10 000 złotych
A
>= 5000 złotych, ale < 10 000 złotych
B
>= 1000 złotych, ale < 5000 złotych
C
< 1000 złotych
D
Rozdział 13. Analizy warunkowe
407
Masz przypisać klientów z tabeli TransactionMaster do tych grup na podstawie przeprowadzonych przez nich transakcji. Możesz wykorzystać funkcję IIf lub Switch. Problem z funkcją IIf polega na tym, że w tej sytuacji wymaga wielokrotnego zagnieżdżenia. Oznacza to, że trzeba umieścić wyrażenia IIf w innych wyrażeniach tego rodzaju, aby obsłużyć możliwe warunki. Jeśli zdecydujesz się zastosować funkcję IIf, wyrażenie będzie wyglądało tak: IIf([REV]>=10000;"A",IIf([REV]>=5000 And [REV]<10000;"B"; IIf([REV]>1000 And [REV]<5000;"C";"D")))
Jak widać, nie tylko trudno jest ustalić, jak działa ten kod, ale z uwagi na jego złożoność można łatwo popełnić w nim błąd składniowy lub logiczny. W porównaniu z przedstawioną wcześniej zagnieżdżoną funkcją IIf poniższa funkcja Switch jest całkiem prosta: Switch([REV]<1000;"D";[REV]<5000;"C";[REV]<10000;"B";True;"A")
Funkcja ta informuje Accessa, że ma zwrócić "D", jeśli REV ma wartość poniżej 1000. Jeżeli REV ma wartość poniżej 5000, zwracane jest "C". Jeśli wartość REV jest mniejsza niż 10000, należy zwrócić "B". Gdy żaden z tych warunków nie jest spełniony, funkcja zwraca "A". Na rysunku 13.20 pokazano, jak wykorzystać tę funkcję w kwerendzie.
Rysunek 13.20. Funkcja Switch okazuje się czasem bardziej praktyczna od funkcji IIf. Ta kwerenda dzieli klientów na grupy na podstawie generowanych przez nich wpływów Może zwróciłeś uwagę na to, że rekordy o wartości poniżej 1000 mają też wartość mniejszą niż 10 000. Dlaczego więc funkcja nie przypisuje wszystkich rekordów do grupy B? Warto pamiętać, że funkcja Switch sprawdza wyrażenia od lewej do prawej i zwraca tylko wartość powiązaną z pierwszym wyrażeniem, którego wartość to True. Dlatego należy odpowiednio uporządkować wyrażenia w funkcji Switch. Ich kolejność powinna być dostosowana do analiz.
Po uruchomieniu kwerendy otrzymasz zbiór danych przedstawiony na rysunku 13.21.
408
Część IV Analizowanie danych w Accessie
Rysunek 13.21. Każdy klient jest na podstawie warunku przypisywany do grupy odpowiadającej poziomowi rocznych wpływów
Rozdział 14.
Podstawy SQL-a w Accessie W tym rozdziale:
Podstawy SQL-a
Zaawansowany SQL
Kwerendy charakterystyczne dla SQL-a
SQL (ang. Structured Query Language) to język używany do wykonywania różnych zadań w relacyjnych systemach baz danych (np. w Accessie). Aby poinformować Accessa, że ma wykonać określoną kwerendę, należy przekazać instrukcje w SQL-u. Nie bój się — już wcześniej tworzyłeś i stosowałeś instrukcje w SQL-u, nawet jeśli o tym nie wiedziałeś. W tym rozdziale odkryjesz rolę, jaką SQL odgrywa w Accessie, a także dowiesz się, co oznaczają instrukcje SQL-a generowane w trakcie tworzenia kwerend. Ponadto poznasz zaawansowane operacje, jakie można wykonywać za pomocą instrukcji SQL-a. Pozwalają one wykonywać zadania niemożliwe do zrealizowania za pomocą accessowego interfejsu użytkownika. Podstawy, które tu poznasz, pomogą Ci w stosowaniu zaawansowanych technik omawianych w dalszych rozdziałach książki. Wyjściową bazę danych dla tego rozdziału, Rozdział14.accdb, można pobrać z witryny poświęconej tej książce.
Podstawy SQL-a Głównym powodem, dla którego interakcje z SQL-em w Accessie są ograniczone, jest to, że Access jest bardziej przyjazny dla użytkowników, niż się powszechnie uważa. Access większość operacji wykonuje w środowisku przyjaznym dla użytkownika, w którym wykonywane na zapleczu żmudne zadania są ukryte. Aby się o tym przekonać, utwórz w widoku projektu kwerendę widoczną na rysunku 14.1. Ta stosunkowo prosta kwerenda oblicza sumę wpływów dla poszczególnych okresów.
410
Część IV Analizowanie danych w Accessie
Rysunek 14.1. Utwórz tę stosunkowo prostą kwerendę w widoku projektu
Następnie otwórz zakładkę NARZĘDZIA GŁÓWNE na wstążce i wybierz opcję Widok/ Widok SQL. Access przełączy się z widoku projektu do widoku przedstawionego na rysunku 14.2.
Rysunek 14.2. Aby otworzyć widok SQL-a, wybierz opcję Widok/Widok SQL
Na rysunku 14.2 widać, że gdy zajmowałeś się tworzeniem kwerendy w widoku projektu, Access sumiennie generował instrukcję SQL-a umożliwiającą uruchomienie kwerendy. Ten przykład pokazuje, że dzięki przyjaznemu dla użytkownika interfejsowi Accessa nie trzeba znać instrukcji SQL-a powiązanych z kwerendami. Warto więc zadać pytanie: skoro można uruchamiać kwerendy bez znajomości SQL-a, po co się go uczyć? Przyznajemy, że dostępny w Accessie wygodny interfejs do tworzenia kwerend sprawia, iż myśl o pominięciu nauki SQL-a jest kusząca. Jeśli jednak chcesz wykorzystać wszystkie oferowane przez Accessa możliwości z zakresu analizy danych, musisz poznać podstawy SQL-a.
Instrukcja SELECT Instrukcja SELECT to podstawa w SQL-u. Pozwala ona pobierać rekordy ze zbioru danych. Oto podstawowa struktura instrukcji SELECT: SELECT nazwy_kolumn FROM nazwa_tabeli
Instrukcję SELECT najczęściej stosuje się razem z klauzulą FROM. Klauzula FROM określa tabele, które stanowią źródło danych. Spróbuj wykonać następujące czynności: utwórz nową kwerendę w widoku projektu, następnie zamknij okno dialogowe Pokazywanie tabeli (jeśli jest otwarte), otwórz zakładkę PROJEKTOWANIE na wstążce i wybierz opcję Widok/Widok SQL, potem zaś w widoku SQL-a wpisz instrukcję SELECT przedstawioną na rysunku 14.3, a następnie uruchom kwerendę za pomocą przycisku Uruchom z zakładki PROJEKTOWANIE na wstążce.
Rozdział 14. Podstawy SQL-a w Accessie
411
Rysunek 14.3. Prosta instrukcja SELECT w widoku SQL-a
Gratulacje! Właśnie utworzyłeś swoją pierwszą ręcznie napisaną kwerendę. Może zauważyłeś, że utworzona automatycznie przez Accessa instrukcja SQL-a z rysunku 14.2 kończy się średnikiem. Średnik to standardowy znak kończący instrukcje SQL-a. W niektórych bazach danych jest wymagany, jednak w Accessie nie trzeba kończyć instrukcji SQL-a w ten sposób, ponieważ Access automatycznie dodaje ten znak w trakcie kompilowania kwerendy.
Wybieranie określonych kolumn Ze zbioru danych można pobrać określone kolumny, podając je w instrukcji SELECT: SELECT AccountManagerID, FullName,[Email Address] FROM Dim_AccountManagers
Jeśli nazwa kolumny z bazy danych zawiera spacje lub znaki niealfanumeryczne, w instrukcji SQL-a trzeba umieścić ją w nawiasach kwadratowych ([]). Na przykład w instrukcji SQL-a pobierającej dane z kolumny o nazwie Email Address nazwę tę należy podać jako [Email Address].
Pobieranie wszystkich kolumn Za pomocą symbolu wieloznacznego (*) można pobrać wszystkie kolumny ze zbioru danych bez konieczności bezpośredniego definiowania każdej kolumny: SELECT * FROM Dim_AccountManagers
Klauzula WHERE W instrukcji SELECT można zastosować klauzulę WHERE, aby przefiltrować zbiór danych i warunkowo pobrać określone rekordy. Klauzulę WHERE zawsze stosuje się w połączeniu z operatorami: = (równa się), <> (nie równa się), > (większy niż), < (mniejszy niż), >= (większy lub równy), <= (mniejszy lub równy) i BETWEEN (w określonym zakresie). Poniższa instrukcja SQL-a pobiera dane tylko tych pracowników, którzy mają na nazwisko „Kowal”: SELECT AccountManagerID, [Last Name], [First Name] FROM Dim_AccountManagers WHERE [Last Name] = "Kowal"
Następna instrukcja SQL-a pobiera dane pracowników o dacie zatrudnienia późniejszej niż 16 maja 2007 roku: SELECT AccountManagerID, [Last Name], [First Name] FROM Dim_AccountManagers WHERE HireDate > #5/16/2007#
412
Część IV Analizowanie danych w Accessie Zauważ, że w przedstawionych przykładach słowo Kowal ujęto w cudzysłów ("Kowal"), natomiast data 5/16/2007 jest umieszczona między znakami kratki (#5/16/2007#). Wartości tekstowe w instrukcjach SQL-a trzeba ujmować w cudzysłów, natomiast daty trzeba podawać między znakami kratki.
Sprzężenia Często trzeba tworzyć kwerendy, które wymagają złączenia dwóch lub więcej powiązanych tabel w celu uzyskania pożądanych wyników. Na przykład możesz chcieć złączyć tabelę pracowników z tabelą transakcji, aby utworzyć raport z informacjami o transakcjach i o pracownikach, którzy je zarejestrowali. Używany typ sprzężenia określa, jakie rekordy zostaną zwrócone. Szczegółowe omówienie sprzężeń znajdziesz w rozdziale 8.
Sprzężenia wewnętrzne Sprzężenie wewnętrzne informuje Accessa, że z obu tabel należy pobrać tylko rekordy o pasujących do siebie wartościach. Rekordy, które w polu uwzględnianym w sprzężeniu mają wartość niewystępującą w drugiej tabeli, są pomijane w wynikach kwerendy. Poniższa instrukcja SQL-a pobiera tylko te rekordy, w których numery pracowników z pola AccountManagerID pojawiają się zarówno w tabeli Dim_AccountManagers, jak i w tabeli Dim_Territory. SELECT Region, Market, AccountManagerID, FullName FROM Dim_AccountManagers INNER JOIN Dim_Territory ON Dim_AccountManagers.AccountManagerID = Dim_Territory.AccountManagerID
Sprzężenia zewnętrzne Sprzężenie zewnętrzne informuje Accessa, że z jednej tabeli należy pobrać wszystkie rekordy, a z innej — tylko te rekordy, które w polu uwzględnianym w sprzężeniu mają wartości pasujące do rekordów z pierwszej tabeli. Są dwa rodzaje sprzężeń zewnętrznych — lewostronne i prawostronne. Sprzężenie lewostronne (nazywane też zewnętrznym sprzężeniem lewostronnym) informuje Accessa, że należy pobrać wszystkie rekordy z pierwszej tabeli niezależnie od ich dopasowania oraz tylko te rekordy z drugiej tabeli, które w polu uwzględnianym w sprzężeniu mają pasujące wartości. Poniższa instrukcja SQL-a pobiera wszystkie rekordy z tabeli Dim_AccountManagers i tylko te rekordy z tabeli Dim_Territory, które w polu AccountManagerID mają wartość istniejącą w tabeli Dim_AccountManagers: SELECT Region, Market, AccountManagerID, FullName FROM Dim_AccountManagers LEFT JOIN Dim_Territory ON Dim_AccountManagers.AccountManagerID = Dim_Territory.AccountManagerID
Sprzężenie prawostronne (nazywane też zewnętrznym sprzężeniem prawostronnym) informuje Accessa, że należy pobrać wszystkie rekordy z drugiej tabeli niezależnie od ich dopasowania oraz tylko te rekordy z pierwszej tabeli, które w polu uwzględnianym w sprzężeniu mają pasujące wartości.
Rozdział 14. Podstawy SQL-a w Accessie
413
Poniższa instrukcja SQL-a pobiera wszystkie rekordy z tabeli Dim_Territory i tylko te rekordy z tabeli Dim_AccountManagers, które w polu AccountManagerID mają wartość istniejącą w tabeli Dim_Territory: SELECT Region, Market, AccountManagerID, FullName FROM Dim_AccountManagers RIGHT JOIN Dim_Territory ON Dim_AccountManagers.AccountManagerID = Dim_Territory.AccountManagerID
Zauważ, że w instrukcjach sprzężenia przed każdą nazwą kolumny znajduje się nazwa tabeli i kropka (np. Dim_AccountManager.AccountManagerID). W czasie tworzenia instrukcji SQL-a dla kwerend dotyczących kilku tabel zwykle warto podawać nazwy tabel wraz z nazwami pól, aby uniknąć niejednoznaczności i błędów. Access automatycznie dodaje nazwy tabel we wszystkich kwerendach. Ponadto jeśli nazwy tabel lub pól zawierają znaki specjalne (np. spacje), należy zastosować nawiasy kwadratowe.
Zaawansowane instrukcje SQL-a Wkrótce się przekonasz, że język SQL daje całkiem dużo możliwości i znacznie wykracza poza instrukcje SELECT, FROM i WHERE. W tym podrozdziale opisaliśmy wybrane z zaawansowanych zadań, jakie można wykonać za pomocą SQL-a.
Rozbudowywanie wyszukiwania za pomocą operatora Like Operator Like sam w sobie nie różni się od operatora równości (=). Na przykład dwie poniższe instrukcje SQL-a zwracają tę samą liczbę rekordów: SELECT AccountManagerID, [Last Name], [First Name] FROM Dim_AccountManagers WHERE [Last Name] = "Kowal" SELECT AccountManagerID, [Last Name], [First Name] FROM Dim_AccountManagers WHERE [Last Name] Like "Kowal"
Jednak operator Like zwykle stosuje się razem z symbolami wieloznacznymi, aby rozszerzyć zakres wyszukiwania o pasujące do wzorca rekordy. Oto symbole wieloznaczne dostępne w Accessie: *
— gwiazdka reprezentuje dowolną liczbę znaków dowolnego rodzaju.
?
—znak zapytania reprezentuje jeden dowolny znak.
#
— znak kratki reprezentuje jedną cyfrę.
[]—
nawiasy kwadratowe umożliwiają przekazanie do operatora Like jednego znaku lub tablicy znaków. Wartości pasujące do znaków z nawiasów kwadratowych są umieszczane w wynikach.
[!]— nawiasy kwadratowe z wykrzyknikiem umożliwiają przekazanie do operatora
Like jednego znaku lub tablicy znaków. Wartości pasujące do znaków z nawiasów kwadratowych są usuwane z wyników.
W tabeli 14.1 znajdziesz przykładowe instrukcje SQL-a, w których operator Like został wykorzystany do pobrania różnych rekordów z tej samej kolumny z określonej tabeli.
414
Część IV Analizowanie danych w Accessie
Tabela 14.1. Pobieranie z wykorzystaniem operatora Like Użyte symbole wieloznaczne
Przykładowa instrukcja SQL-a
Wynik
SELECT Field1 *
FROM Table1
Pobiera wszystkie rekordy, w których pole Field1 zaczyna się od litery A.
WHERE Field1 Like "A*" SELECT Field1 *
FROM Table1
Pobiera wszystkie rekordy, w których pole Field1 zawiera literę A.
WHERE Field1 Like "*A*" SELECT Field1 ?
FROM Table1
Pobiera wszystkie rekordy, w których pole Field1 zawiera trzy znaki.
WHERE Field1 Like "???" SELECT Field1 ?
FROM Table1
Pobiera wszystkie rekordy, w których pole Field1 zawiera trzy znaki, z których pierwszy to B.
WHERE Field1 Like "B??" SELECT Field1 #
FROM Table1
Pobiera wszystkie rekordy, w których pole Field1 zawiera trzycyfrową liczbę.
WHERE Field1 Like "###" SELECT Field1 #
FROM Table1 WHERE Field1 Like "A#A"
Pobiera wszystkie rekordy, w których Field1 zawiera trzy znaki: na początku literę A, w środku cyfrę, a na końcu drugą literę A.
SELECT Field1 #, *
FROM Table1
Pobiera wszystkie rekordy, w których pole Field1 zaczyna się od litery A i dowolnej cyfry.
WHERE Field1 Like "A#*" SELECT Field1 [], *
FROM Table1 WHERE Field1 Like "*[$%!*/]*" SELECT Field1
[!], *
FROM Table1 WHERE Field1 Like "*[!a-z]*" SELECT Field1
[!], *
FROM Table1 WHERE Field1 Like "*[!0-9]*"
Pobiera wszystkie rekordy, w których pole Field1 zawiera jeden ze znaków specjalnych podanych w przedstawionej instrukcji SQL-a. Pobiera wszystkie rekordy, w których pole Field1 nie zawiera wartości tekstowej, a obejmuje liczbę lub znak specjalny (np. @). Pobiera wszystkie rekordy, w których pole Field1 nie zawiera wartości liczbowej, a obejmuje tekst lub znak specjalny (np. @).
Rozdział 14. Podstawy SQL-a w Accessie
415
Pobieranie unikatowych wartości i wierszy bez grupowania Predykat DISTINCT umożliwia pobieranie samych unikatowych wartości z wybranych pól zbioru danych. Na przykład poniższa instrukcja SQL-a pobiera tylko unikatowe stanowiska z tabeli Dim_AccountManagers i zwraca sześć rekordów: SELECT DISTINCT AccountManagerID FROM Dim_AccountManagers
Jeśli dana instrukcja SQL-a pobiera więcej niż jedno pole, połączenie wartości wszystkich tych pól musi być unikatowe, aby rekord znalazł się w wynikach. Jeżeli chcesz, aby cały wiersz był unikatowy, możesz zastosować predykat DISTINCTROW. Ten predykat umożliwia pobranie tylko tych rekordów, w których cały wiersz jest unikatowy. Oznacza to, że kombinacja wszystkich wartości w pobieranych polach nie może być identyczna z kombinacją z któregokolwiek innego rekordu ze zwracanego zbioru danych. Predykat DISTINCTROW stosuje się tak samo jak klauzulę SELECT DISTINCT: SELECT DISTINCTROW AccountManagerID FROM Dim_AccountManagers
Grupowanie i agregowanie danych za pomocą klauzuli GROUP BY Klauzula GROUP BY umożliwia agregowanie rekordów ze zbioru danych na podstawie wartości kolumn. Gdy tworzysz kwerendę podsumowującą w widoku projektu, na zapleczu używana jest klauzula GROUP BY. Poniższa instrukcja SQL-a grupuje dane według pola Market i zwraca liczbę stanów dla każdego rynku: SELECT Market, Count(State) FROM Dim_Territory GROUP BY Market
Gdy używasz klauzuli GROUP BY, przed rozpoczęciem agregowania danych sprawdzana jest każda klauzula WHERE z kwerendy. Czasem jednak trzeba zastosować warunek WHERE po zakończeniu grupowania. Wtedy można zastosować klauzulę HAVING. Na przykład poniższa instrukcja SQL-a grupuje rekordy, dla których wartość pola Market to Dallas, a następnie zwraca tylko te rekordy, w których średnia wartości z pola LineItem dla grupy jest mniejsza niż 100. Grupowanie odbywa się tu przed sprawdzeniem, czy średnia wartości z pola LineItem wynosi poniżej 100. SELECT Market, Count(State) FROM Dim_Territory WHERE Market = "Dallas" GROUP BY Market HAVING Avg(LineItem) < 100
416
Część IV Analizowanie danych w Accessie
Określanie kolejności sortowania za pomocą klauzuli ORDER BY Klauzula ORDER BY umożliwia sortowanie danych na podstawie określonego pola. Domyślnie dane są sortowane rosnąco. Dlatego jeśli chcesz je posortować w ten sposób, nie musisz podawać specjalnych modyfikatorów. Poniższa instrukcja SQL-a sortuje wynikowe rekordy rosnąco według pól Last Name i First Name: SELECT AccountManagerID, [Last Name], [First Name] FROM Dim_AccountManagers ORDER BY [Last Name], [First Name]
Aby posortować dane w kolejności malejącej, trzeba zastosować słowo zastrzeżone DESC po każdej kolumnie, która ma być sortowana w ten sposób. Poniższa instrukcja SQL-a sortuje wynikowe rekordy malejąco według pola Last Name, a następnie rosnąco według pola First Name: SELECT AccountManagerID, [Last Name], [First Name] FROM Dim_AccountManagers ORDER BY [Last Name] DESC, [First Name]
Tworzenie aliasów za pomocą klauzuli AS Klauzula AS umożliwia przypisywanie aliasów do kolumn i tabel. Aliasy stosuje się zwykle z dwóch powodów: albo w celu poprawienia czytelności i skrócenia nazwy kolumny lub tabeli, albo w celu wskazania wybranego egzemplarza w przypadku używania kilku egzemplarzy tej samej tabeli. Tworzenie aliasów kolumn Poniższa instrukcja SQL-a grupuje dane według pola Market i zwraca liczbę stanów w każdym regionie. Ponadto za pomocą klauzuli AS ustawiono alias State Count dla kolumny z liczbą stanów: SELECT Market, Count(State) AS [State Count] FROM Dim_Territory GROUP BY Market HAVING Market = "Dallas"
Tworzenie aliasów dla tabel Poniższa instrukcja SQL-a przypisuje do tabeli Dim_AccountManagers alias MyTable: SELECT AccountManagerID, [Last Name], [First Name] FROM Dim_AccountManagers AS MyTable
Wyświetlanie tylko pierwszych elementów (instrukcje SELECT TOP i SELECT TOP PERCENT) Przy stosowaniu kwerendy SELECT pobierane są wszystkie rekordy zgodne z definicjami i kryteriami. Instrukcja SELECT TOP pobiera tylko pierwsze wartości i jest dla Accessa informacją, że należy przefiltrować zwracany zbiór danych i wyświetlić tylko określoną liczbę rekordów.
Rozdział 14. Podstawy SQL-a w Accessie
417
Kwerendy zwracające pierwsze wartości Aby dobrze zrozumieć, jak działa instrukcja SELECT TOP, utwórz kwerendę podsumowującą przedstawioną na rysunku 14.4. Rysunek 14.4. Utwórz tę kwerendę podsumowującą w widoku projektu. Zauważ, że wyniki są sortowane malejąco na podstawie sumy wartości z pola LineTotal
Kliknij przycisk Arkusz właściwości w zakładce NARZĘDZIA KWEREND PROJEKTOWANIE. Wyświetli się okno dialogowe Arkusz właściwości widoczne na rysunku 14.5. Aby wyświetlić to okno, możesz też wcisnąć klawisz F4 na klawiaturze. Rysunek 14.5. Zmień wartość właściwości Najwyższe wartości na 25
W oknie dialogowym Arkusz właściwości ustaw właściwość Najwyższe wartości na 25. Jak widać na rysunku 14.6, po uruchomieniu tej kwerendy zwracanych jest tylko 25 pierwszych klientów (według sumy wpływów). Aby pobrać 25 ostatnich klientów, wystarczy zmienić porządek sortowania według pola LineTotal na malejący. Access nie stosuje „dogrywek” — jeśli dla 24., 25. i 26. klienta uzyskano tę samą wartość, zwróconych zostanie 26 wierszy.
Instrukcja SELECT TOP Łatwo jest zrozumieć instrukcję SELECT TOP. Poniżej przedstawiamy kwerendę użytą do wygenerowania wyników z rysunku 14.6: SELECT TOP 25 Customer_Name, Sum(LineTotal) AS SumOfLineTotal FROM Dim_Customers INNER JOIN Dim_Transactions ON Dim_Customers.CustomerID = Dim_Transactions.CustomerID GROUP BY Customer_Name ORDER BY Sum(LineTotal) DESC
418
Część IV Analizowanie danych w Accessie
Rysunek 14.6. Gdy uruchomisz przedstawioną kwerendę, otrzymasz 25 klientów generujących najwyższe wpływy
Warto pamiętać, że nie trzeba używać wartości liczbowych lub walutowych, aby utworzyć kwerendę tego rodzaju. Poniższa instrukcja SQL-a zwraca dziesięciu managerów o najwcześniejszych datach zatrudnienia. W ten sposób można uzyskać raport o pracownikach o najdłuższym stażu: SELECT Top 10 AccountManagerID, [Last Name], [First Name] FROM Dim_AccountManagers ORDER BY HireDate ASC
Zwróć uwagę na klauzule DESC i ASC we wcześniejszych instrukcjach SQL-a. Gdy używasz instrukcji SELECT TOP, ważne jest, aby odpowiednio określić kierunek sortowania, ponieważ zależy od niego, czy kwerenda zwróci dziesięć największych, czy dziesięć najmniejszych wyników.
Instrukcja SELECT TOP PERCENT Instrukcja SELECT TOP PERCENT działa prawie dokładnie tak samo jak instrukcja SELECT TOP, ale zwraca n procent pierwszych rekordów zamiast n rekordów. Na przykład poniższa instrukcja SQL-a zwraca pierwszych 25% rekordów (pod względem wpływów): SELECT TOP 25 PERCENT Customer_Name, Sum(LineTotal) AS SumOfLineTotal FROM Dim_Customers INNER JOIN Dim_Transactions ON Dim_Customers.CustomerID = Dim_Transactions.CustomerID GROUP BY Customer_Name ORDER BY Sum(LineTotal) DESC
Warto pamiętać, że w instrukcjach SELECT TOP PERCENT procent dotyczy łącznej liczby rekordów ze sprawdzanego zbioru danych, a nie rekordów o określonej procentowo wartości w danym polu. Na przykład wcześniejsza instrukcja SQL-a nie zwraca rekordów, których wartości nie różnią się o więcej niż 25% od maksymalnej. Zamiast tego zwraca 25% wszystkich rekordów ze sprawdzanego zbioru danych. Oznacza to, że jeśli sama instrukcja SELECT zwraca 5961 rekordów, instrukcja SELECT TOP 25 PERCENT zwraca 1491 wierszy.
Rozdział 14. Podstawy SQL-a w Accessie
419
Wykonywanie kwerend funkcjonalnych za pomocą instrukcji SQL-a Może wcześniej się nad tym nie zastanawiałeś, ale gdy tworzysz kwerendę funkcjonalną, generujesz instrukcję SQL-a odpowiadającą danemu zadaniu. Tego typu instrukcje SQL-a nie ograniczają się do pobierania rekordów. Przetłumaczona kwerenda tworząca tabelę W kwerendach tworzących tabele używa się instrukcji SELECT…INTO do tworzenia zapisanej na stałe tabeli z wynikami kwerendy. Poniższa instrukcja najpierw pobiera numer, nazwisko i imię managera, a następnie tworzy nową tabelę o nazwie Employees: SELECT AccountManagerID, [Last Name], [First Name] INTO Employees FROM Dim_AccountManagers
Przetłumaczona kwerenda dołączająca W kwerendach dołączających wykorzystuje się instrukcję INSERT INTO do wstawienia nowych wierszy do określonej tabeli. Poniższy przykładowy kod wstawia do tabeli Employees nowe wiersze z tabeli Dim_AccountManagers: INSERT INTO Employees (AccountManagerID, [Last Name], [First Name]) SELECT AccountManagerID, [Last Name], [First Name] FROM Dim_AccountManagers
Przetłumaczona kwerenda aktualizująca W kwerendach aktualizujących stosuje się instrukcję UPDATE w połączeniu z modyfikatorem SET, aby zmodyfikować dane w zbiorze. Poniższa przykładowa instrukcja aktualizuje pole List_Price w tabeli Dim_Products, aby zwiększyć cenę o 10%: UPDATE Dim_Products SET List_Price = [List_Price]*1.1
Przetłumaczona kwerenda usuwająca W kwerendach usuwających stosuje się instrukcję DELETE do usuwania wierszy ze zbioru danych. W poniższej przykładowej instrukcji usuwane są wszystkie wiersze z tabeli Employees: DELETE * FROM Employees
Tworzenie kwerend krzyżowych za pomocą instrukcji TRANSFORM Instrukcja TRANSFORM pozwala utworzyć krzyżowy zbiór danych, który w zwięzły sposób wyświetla informacje. Instrukcja TRANSFORM wymaga trzech podstawowych składników:
agregowanego pola;
instrukcji SELECT, która określa zawartość wiersza w analizach krzyżowych;
pola, które określa kolumny analiz krzyżowych.
420
Część IV Analizowanie danych w Accessie
Oto składnia instrukcji TRANSFORM: TRANSFORM Aggregated_Field SELECT Field1, Field2 FROM Table1 GROUP BY Select Field1, Field2 PIVOT Pivot_Field
Poniższa instrukcja tworzy analizy krzyżowe, które wyświetlają obszar i rynek w wierszach oraz produkty w kolumnach. W komórkach przedstawione są wpływy. TRANSFORM Sum(Revenue) AS SumOfRevenue SELECT Region, Market FROM PvTblFeed GROUP BY Region, Market PIVOT Product_Description
Kwerendy charakterystyczne dla SQL-a Kwerendy tego rodzaju to kwerendy funkcjonalne, których nie da się utworzyć za pomocą siatki QBE Accessa. Kwerendy te trzeba uruchamiać albo w widoku SQL-a, albo z poziomu kodu (w makrach lub w kodzie VBA). Istnieje kilka typów kwerend charakterystycznych dla SQL-a. Każdy z nich wykonuje zadania określonego rodzaju. W tym podrozdziale znajdziesz wprowadzenie do kilku typów takich kwerend. Skoncentrowaliśmy się tu na tych, które można wykorzystać w Accessie do kształtowania i konfigurowania tabel z danymi.
Scalanie zbiorów danych za pomocą operatora UNION Operator UNION służy do scalania dwóch zgodnych ze sobą instrukcji SQL-a w celu uzyskania jednego zbioru danych przeznaczonego tylko do odczytu. Na przykład poniższa instrukcja SELECT generuje zbiór danych (zobacz rysunek 14.7) zawierający wpływy dla regionów i rynków: SELECT Region, Market, Sum(Revenue) AS [Sales] FROM PvTblFeed GROUP BY Region, Market
Rysunek 14.7. Ten zbiór danych zawiera wpływy dla regionów i rynków
Rozdział 14. Podstawy SQL-a w Accessie
421
Druga instrukcja SELECT generuje odrębny zbiór danych (zobacz rysunek 14.8), który zawiera łączne wpływy dla regionów: SELECT Region, "Total" AS [Market], Sum(Revenue) AS [Sales] FROM PvTblFeed GROUP BY Region
Rysunek 14.8. Ten zbiór danych zawiera łączne wpływy dla regionów
Chodzi o to, aby połączyć oba zbiory danych i utworzyć analizy, które w jednej tabeli będą obejmowały szczegółowe i sumaryczne dane. Operator UNION to doskonałe narzędzie do realizacji tego zadania, ponieważ służy do scalania wyników dwóch instrukcji SELECT. Aby zastosować operator UNION, utwórz nową kwerendę w widoku SQL-a i wprowadź następujący kod: SELECT Region, Market, Sum(Revenue) AS [Sales] FROM PvTblFeed GROUP BY Region, Market UNION SELECT Region, "Total" AS [Market], Sum(Revenue) AS [Sales] FROM PvTblFeed GROUP BY Region
Jak widać, powyższa instrukcja to tylko dwie instrukcje SQL-a połączone ze sobą operatorem UNION. Gdy połączy się obie instrukcje (zobacz rysunek 14.9), zwrócony zostanie zbiór danych zawierający szczegółowe i sumaryczne dane w jednej tabeli. Rysunek 14.9. Dwa zbiory danych połączono, aby utworzyć raport z sumarycznymi i szczegółowymi danymi
Przy wykonywaniu kwerend z instrukcją UNION Access dopasowuje kolumny z obu zbiorów danych na podstawie ich pozycji w instrukcjach SELECT. Oznacza to dwie rzeczy: w obu instrukcjach SELECT liczba kolumn musi być taka sama, a kolumny w obu instrukcjach zwykle powinny występować w tej samej kolejności.
422
Część IV Analizowanie danych w Accessie Warto zauważyć, że operator UNION wykonuje operację SELECT DISTINCT na wynikowych zbiorach danych. Oznacza to, że instrukcja UNION może wyeliminować powtarzające się wiersze, jeśli w obu zbiorach danych we wszystkich polach zawierają one te same wartości. Jeżeli zauważysz, że kwerenda z instrukcją UNION prowadzi do niepożądanej utraty rekordów, pomyśl o zastosowaniu operatora UNION ALL. Działa ona tak samo jak instrukcja UNION, ale nie wykonuje operacji SELECT DISTINCT, dlatego nie usuwa powtarzających się wierszy.
Tworzenie tabeli za pomocą instrukcji CREATE TABLE W procesie analitycznym często trzeba utworzyć tabelę tymczasową. Jest ona potrzebna do grupowania danych, do manipulowania nimi lub po prostu do ich przechowywania. Dzięki instrukcji CRATE TABLE tabelę można utworzyć w jednej kwerendzie charakterystycznej dla SQL-a. Instrukcja CREATE TABLE (w odróżnieniu od kwerend tworzących tabele) tworzy tylko strukturę, czyli schemat tabeli. Instrukcja ta nigdy nie zwraca rekordów. Pozwala natomiast utworzyć pustą tabelę w dowolnym miejscu procesu analitycznego. Oto podstawowa składnia instrukcji CREATE TABLE: CREATE TABLE TableName ( Type(), Type())
Aby zastosować instrukcję CREATE TABLE, utwórz nową kwerendę w widoku SQL-a, a następnie zdefiniuj strukturę tabeli. Poniższy przykładowy kod tworzy nową tabelę TempLog o trzech polach. Pierwszym z nich jest pole typu Text przyjmujące do 50 znaków, drugim — pole typu Text przyjmujące do 255 znaków, a trzecim — pole typu Date. CREATE TABLE TempLog ([User] Text(50), [Description] Text, [LogDate] Date)
Zauważ, że w kodzie nie określono wielkości drugiej kolumny tekstowej. Jeśli pominiesz wielkość pola, Access wykorzysta domyślny rozmiar określony dla bazy danych.
Manipulowanie kolumnami za pomocą instrukcji ALTER TABLE Instrukcja ALTER TABLE zapewnia dodatkowe sposoby modyfikowania na zapleczu struktury tabeli. Dostępnych jest kilka klauzul, które można wykorzystać w instrukcji ALTER TABLE. Cztery z nich są przydatne w analizach danych w Accessie. Oto te klauzule: ADD, ALTER COLUMN, DROP COLUMN i ADD CONSTRAINT. Instrukcja ALTER TABLE wraz z różnymi klauzulami jest stosowana znacznie rzadziej niż instrukcje SQL-a wymienione we wcześniejszej części rozdziału. Jest jednak przydatna, gdy w ramach procesu analitycznego trzeba zmienić strukturę tabel, ponieważ pomaga uniknąć ręcznych manipulacji. Warto zauważyć, że nie można cofnąć operacji wykonanych za pomocą instrukcji ALTER TABLE. Dlatego należy stosować ją z zachowaniem odpowiedniej ostrożności.
Rozdział 14. Podstawy SQL-a w Accessie
423
Dodawanie kolumn za pomocą klauzuli ADD Jak wskazuje jej nazwa, klauzula ADD umożliwia dodanie kolumny do istniejącej tabeli. Oto podstawowa składnia tej instrukcji: ALTER TABLE ADD Type()
Aby zastosować instrukcję ADD, wystarczy utworzyć nową kwerendę w widoku SQL-a i zdefiniować strukturę nowej kolumny. Na przykład uruchomienie przykładowej poniższej instrukcji spowoduje utworzenie nowej kolumny SupervisorPhone i dodanie jej do tabeli TempLog: ALTER TABLE TempLog ADD SupervisorPhone Text(10)
Modyfikowanie kolumn za pomocą klauzuli ALTER COLUMN Przy stosowaniu klauzuli ALTER COLUMN należy określić istniejącą kolumnę z istniejącej tabeli. Klauzula ta służy przede wszystkim do zmieniania typu danych i wielkości kolumn. Oto podstawowa składnia klauzuli: ALTER TABLE ALTER COLUMN Type()
Aby zastosować instrukcję ALTER COLUMN, utwórz nową kwerendę w widoku SQL-a i zdefiniuj zmiany dla danej kolumny. Na przykład poniższa instrukcja zmienia wielkość pola SupervisorPhone: ALTER TABLE TempLog ALTER COLUMN SupervisorPhone Text(13)
Usuwanie kolumn za pomocą klauzuli DROP COLUMN Klauzula DROP COLUMN umożliwia usunięcie danej kolumny z istniejącej tabeli. Oto podstawowa składnia tej klauzuli: ALTER TABLE DROP COLUMN
Aby zastosować klauzulę DROP COLUMN, należy utworzyć nową kwerendę w widoku SQL-a, a następnie wskazać usuwaną kolumnę. Uruchomienie poniższej przykładowej instrukcji spowoduje usunięcie kolumny SupervisorPhone z tabeli TempLog: ALTER TABLE TempLog DROP COLUMN SupervisorPhone
Dynamiczne dodawanie kluczy głównych za pomocą klauzuli ADD CONSTRAINT Dla wielu analityków Access jest łatwym narzędziem do pobierania, przekształcania i wczytywania danych. Umożliwia pobieranie danych z wielu różnych źródeł i późniejsze zmienianie formatu informacji oraz umieszczanie ich w skonsolidowanych tabelach. Liczni analitycy automatyzują proces pobierania, przekształcania i wczytywania danych. Stosują do tego makra uruchamiające serie kwerend. W większości sytuacji technika ta sprawdza się całkiem dobrze.
424
Część IV Analizowanie danych w Accessie
Jednak w niektórych sytuacjach proces pobierania, przekształcania i wczytywania wymaga dodania kluczy głównych do tymczasowej tabeli, aby dane w trakcie przetwarzania zachowały znormalizowaną postać. Wtedy większość użytkowników stosuje jedno z dwóch rozwiązań: zatrzymuje makro w trakcie działania i ręcznie dodaje potrzebne klucze główne lub tworzy trwałą tabelę wyłącznie w celu przechowywania tabeli z ustawionymi kluczami głównymi. Istnieje jednak także trzecia możliwość: za pomocą klauzuli ADD CONSTRAINT można dynamicznie tworzyć klucze główne. Oto podstawowa składnia tej klauzuli: ADD CONSTRAINT CONSTRAINTNAME PRIMARY KEY () ALTER TABLE
Aby zastosować klauzulę ADD CONSTRAINT, utwórz nową kwerendę w widoku SQL-a i zdefiniuj nowy klucz główny. Na przykład poniższa instrukcja dodaje złożony klucz oparty na trzech polach z tabeli TempLog: ALTER TABLE TempLog ADD CONSTRAINT CONSTRAINTNAME PRIMARY KEY (ID, Name, Email)
Tworzenie kwerend przekazujących Kwerenda przekazująca przesyła polecenia SQL-a bezpośrednio do serwera bazy danych (np. systemu SQL Server, Oracle itd.). Często serwery te są używane jako zaplecze systemu, natomiast Access pełni wtedy funkcję klienta lub frontonu. Polecenia należy przesyłać za pomocą składni odpowiedniej dla danego serwera. Zaletą kwerend przekazujących jest to, że parsowanie i przetwarzanie odbywa się wtedy na serwerze zaplecza, a nie w Accessie. Dzięki temu kwerendy działają znacznie szybciej niż przy pobieraniu danych z dołączonych tabel (zwłaszcza gdy dołączona tabel jest bardzo duża). Oto kroki potrzebne do utworzenia kwerendy przekazującej: 1. Kliknij przycisk Projekt kwerendy w zakładce TWORZENIE na wstążce. 2. Zamknij okno dialogowe Pokazywanie tabeli. 3. Kliknij przycisk Przekazująca na zakładce NARZĘDZIA KWEREND PROJEKTOWANIE. Pojawi się okno z kodem SQL-a. 4. Wpisz instrukcję SQL-a dostosowaną do docelowego systemu bazy danych. Prostą instrukcję SQL-a przedstawia rysunek 14.10. Rysunek 14.10. Aby utworzyć kwerendę przekazującą, musisz otworzyć okno z kodem w SQL-u
5. Kliknij przycisk Arkusz właściwości na zakładce NARZĘDZIA KWEREND PROJEKTOWANIE. Pojawi się okno dialogowe Arkusz właściwości widoczne na rysunku 14.11.
Rozdział 14. Podstawy SQL-a w Accessie
425
Rysunek 14.11. W oknie dialogowym Arkusz właściwości kwerendy trzeba określić łańcuch znaków połączenia zgodny z modelem ODBC
6. Wpisz łańcuch znaków połączenia odpowiedni dla używanego serwera. Zwykle jest to zgodny z modelem ODBC łańcuch znaków połączenia standardowo używany do nawiązywania połączenia z serwerem. 7. Kliknij przycisk Uruchom. Przy stosowaniu kwerend przekazujących trzeba pamiętać o kilku kwestiach:
Instrukcje SQL-a należy zbudować samodzielnie. Access w tym nie pomaga — nie można wykorzystać siatki QBE.
Jeśli łańcuch znaków połączenia się zmieni, trzeba będzie ponownie otworzyć właściwości kwerendy przekazującej i zmodyfikować właściwość z łańcuchem znaków połączenia ODBC. Jeżeli używasz nazwy istniejącego źródła danych, możesz też zmienić jego konfigurację.
Wyniki otrzymane z kwerendy przekazującej są dostępne tylko do odczytu. Zwróconych rekordów nie można aktualizować ani modyfikować.
Można pisać wyłącznie kwerendy pobierające dane. Kwerendy aktualizujące, dołączające, usuwając i tworzące tabele są niedozwolone.
Ponieważ instrukcje SQL-a wysyłane na serwer są zapisane na stałe, nie można stosować dynamicznych parametrów (takich jak w kwerendach z parametrami), ponieważ nie można ich przekazać na serwer po przesłaniu instrukcji SQL-a.
426
Część IV Analizowanie danych w Accessie
Rozdział 15.
Podkwerendy i funkcje agregujące domeny W tym rozdziale:
Rozbudowywanie analiz za pomocą podkwerend
Stosowanie funkcji agregujących domeny
Często analizy trzeba przeprowadzać na różnych poziomach. Na każdym poziomie używane są dane z wcześniejszego poziomu. Wbudowywanie poziomów w procesie analitycznym jest bardzo często stosowaną techniką. Na przykład gdy tworzysz kwerendę używającą innej kwerendy jako źródła danych, budujesz analizy wielopoziomowe. Gdy rozwijasz kwerendę opartą na tabeli tymczasowej generowanej przez kwerendę tworzącą tabelę, także korzystasz z wielopoziomowych analiz. Wszystkie standardowe techniki tworzenia analiz wielopoziomowych mają dwie wspólne cechy:
Powodują dodanie etapu do procesu analitycznego. Każda kwerenda, którą trzeba uruchomić, aby wykonać inną kwerendę (a nawet każda tabela tymczasowa potrzebna do przeprowadzenia analiz), oznacza konieczność wykonania innego zadania przed uzyskaniem ostatecznych wyników.
Wszystkie takie techniki wymagają tworzenia tabel tymczasowych lub kwerend pomocniczych, co powoduje umieszczanie w bazie danych tabel i kwerend, które mogą utrudniać zrozumienie procesu analitycznego. Prowadzi to też do szybkiego rozrastania się bazy danych. W takich sytuacjach przydatne mogą być podkwerendy i funkcje agregujące domeny.
Podkwerendy i funkcje agregujące domeny umożliwiają dodawanie poziomów do analiz w ramach jednej kwerendy. Dzięki temu nie trzeba stosować tabel tymczasowych ani kwerend pomocniczych. Podkwerendy i funkcje agregujące domeny wymagają znajomości SQL-a. Większość początkujących użytkowników Accessa nie posiada takiej wiedzy. Jeśli też należysz do tej grupy, na razie wstrzymaj się z dalszą lekturą tego rozdziału i zapoznaj się z rozdziałem 14. Znajdziesz w nim wprowadzenie do SQL-a wystarczające do tego, by móc przejść do dalszej części niniejszego rozdziału.
428
Część IV Analizowanie danych w Accessie
Wyjściową bazę danych do tego rozdziału, Rozdział15.accdb, można pobrać z witryny poświęconej tej książce.
Wzbogacanie analiz za pomocą podkwerend Podkwerendy to kwerendy pobierające zagnieżdżone w innych kwerendach. Głównym zadaniem podkwerend jest umożliwienie wykorzystania wyników jednej kwerendy w innej kwerendzie. W podkwerendach można pobierać odpowiedzi na wieloaspektowe pytania, określać dalsze kryteria pobierania danych i definiować nowe pola potrzebne w analizach. W kwerendzie widocznej na rysunku 15.1 pokazano, jak wykorzystać podkwerendę w siatce QBE. W trakcie analizowania tej kwerendy pamiętaj, że jest to tylko jeden przykład ilustrujący stosowanie podkwerend. Nie trzeba ich używać jako kryteriów.
Rysunek 15.1. Aby zastosować podkwerendę w widoku projektu, wystarczy wprowadzić instrukcję SQL-a
Jeśli w trakcie tworzenia kwerendy z rysunku 15.1 przełączysz się do widoku SQL-a, zobaczysz instrukcję SQL-a podobną do poniższej. Czy potrafisz znaleźć w niej podkwerendę? Poszukaj drugiej instrukcji SELECT. SELECT CustomerID, Sum(LineTotal) AS SumOfLineTotal FROM Dim_Transactions WHERE CustomerID IN (SELECT [CustomerID] FROM [Dim_Customers] WHERE [State] = "CA") GROUP BY CustomerID
Podkwerendy zawsze należy umieszczać w nawiasach.
Podkwerendy działają w ten sposób, że są wykonywane na początku, a wyniki są używane w zewnętrznej kwerendzie (w której podkwerenda jest zagnieżdżona), gdzie mogą pełnić funkcję kryterium, wyrażenia, parametru itd. W przykładzie widocznym na ry-
Rozdział 15. Podkwerendy i funkcje agregujące domeny
429
sunku 15.1 podkwerenda najpierw zwraca listę oddziałów powiązanych z rynkiem Dallas. Następnie kwerenda zewnętrzna wykorzystuje tę listę jako kryterium, aby odfiltrować pracowników, którzy nie są powiązani z tym rynkiem.
Po co stosować podkwerendy? Podkwerendy często działają wolniej niż standardowe kwerendy wykorzystujące sprzężenie. Wynika to z tego, że są wykonywane dla całego zbioru danych lub są uruchamiane wielokrotnie (jeden raz dla każdego wiersza przetwarzanego przez kwerendę zewnętrzną. Dlatego działają powoli, zwłaszcza dla dużych zbiorów danych. Po co więc je stosować? W wielu analizach potrzebne są wieloetapowe procesy, w których wykorzystuje się tabele tymczasowe lub kwerendy pomocnicze. Choć tabele i kwerendy tymczasowe same w sobie nie są niczym złym, to jeśli w procesie analitycznym jest ich za dużo, mogą utrudniać jego zrozumienie, a także prowadzić do nadmiernego rozrastania się bazy danych. Mimo że stosowanie podkwerend związane jest ze spadkiem wydajności, może to być akceptowalna cena za usprawnienie procedur i zoptymalizowanie procesu analitycznego. Gdy przyzwyczaisz się do pisania własnych instrukcji w SQL-u, zauważysz, że stosowanie podkwerend w kwerendach wykonywanych „w locie” pozwala zaoszczędzić czas.
Podstawowe zasady dotyczące podkwerend Jest kilka reguł i ograniczeń, o których należy pamiętać przy stosowaniu podkwerend: W łańcuchu znaków z instrukcją SQL-a podkwerendy musi się znajdować przynajmniej jedna instrukcja SELECT i jedna klauzula FROM. Podkwerendę należy umieścić w nawiasach. Teoretycznie w kwerendzie można zagnieździć do 31 podkwerend. Liczba ta jest jednak zależna od pamięci dostępnej w systemie i złożoności podkwerend. W podkwerendzie można zastosować klauzulę ORDER BY, jednak tylko wtedy, gdy podkwerenda jest instrukcją SELECT TOP lub SELECT TOP PERCENT. W podkwerendzie zawierającej klauzulę GROUP BY nie można używać słowa kluczowego DISTINCT.
Jeśli dana tabela jest używana zarówno w kwerendzie zewnętrznej, jak i w podkwerendzie, trzeba zastosować aliasy dla nazwy tej tabeli.
Tworzenie podkwerend bez pisania instrukcji SQL-a Możliwe, że nie chcesz stosować podkwerend, ponieważ nie lubisz pisać własnych instrukcji SQL-a. Rzeczywiście, pisanie licznych instrukcji SQL-a w celu wykonania drobnych analiz może się wydawać przesadą.
430
Część IV Analizowanie danych w Accessie
Załóżmy, że poproszono Cię o określenie liczby managerów, którzy mają dłuższy staż niż przeciętny manager. Wydaje się to stosunkowo łatwe — i rzeczywiście jest, jeśli zastosować podkwerendę. Od czego jednak zacząć? Można napisać instrukcję SQL-a w widoku SQL-a i ją uruchomić. Jednak niewielu użytkowników Accessa tworzy instrukcje SQL-a od podstaw. Pomysłowi użytkownicy wykorzystują wbudowane możliwości Accessa, aby zaoszczędzić czas i uniknąć problemów. Sztuczka polega na podziale analiz na dwie prostsze części: 1. Ustal średni staż pracy dla wszystkich managerów, tworząc kwerendę przedstawioną na rysunku 15.2. Rysunek 15.2. Utwórz kwerendę, aby ustalić średni staż pracy wszystkich managerów
2. Przełącz się do widoku SQL-a (zobacz rysunek 15.3) i skopiuj instrukcję SQL-a. Rysunek 15.3. Przełącz się do widoku SQL-a i skopiuj instrukcję SQL-a
3. Utwórz kwerendę, która określa liczbę managerów dla określonej długości stażu pracy. Kwerenda ta została przedstawiona na rysunku 15.4. Rysunek 15.4. Utwórz kwerendę zliczającą pracowników dla określonej długości stażu pracy
Rozdział 15. Podkwerendy i funkcje agregujące domeny
431
4. Kliknij prawym przyciskiem myszy w wierszu Kryteria dla pola TIS_in_Months i wybierz opcję Powiększ. Pojawi się okno dialogowe Powiększenie (zobacz rysunek 15.5). Pomaga ono wygodnie pracować z tekstem, który jest zbyt długi, aby można go było wygodnie wyświetlić w siatce QBE. Rysunek 15.5. Wklej pierwszą skopiowaną instrukcję SQL-a do wiersza Kryteria dla pola TIS_in_Months
5. Po otwarciu okna dialogowego Powiększenie wklej w białym obszarze wprowadzania skopiowaną wcześniej instrukcję SQL-a. Pamiętaj, że podkwerendy muszą się znajdować w nawiasach. Dlatego umieść wklejoną instrukcję SQL-a w nawiasach. Usuń też wszystkie znaki powrotu karetki automatycznie dodane przez Accessa.
6. Dokończ kwerendę — wpisz znak większości (>) przed podkwerendą i dla pola TIS_in_Months zmień wartość Grupuj według na Gdzie. Na tym etapie kwerenda powinna wyglądać tak jak na rysunku 15.6.
Rysunek 15.6. Gdy uruchomisz tę kwerendę, dowiesz się, że 12 managerów pracuje dłużej niż wynosi średnia stażu pracy
Jeśli teraz otworzysz kwerendę z rysunku 15.6 w widoku SQL-a, zobaczysz następującą instrukcję SQL-a:
432
Część IV Analizowanie danych w Accessie SELECT Count(AccountManagerID) AS MyCount FROM Dim_AccountManagers WHERE (((DateDiff("m",[HireDate],Date())) >(SELECT Avg(DateDiff("m",[HireDate],Date())) AS Avg_TIS_in_Months FROM Dim_ AccountManagers;)));
Dobre jest to, że nie musiałeś wpisywać tego kodu. Wystarczyło wykorzystać wiedzę na temat Accessa, aby połączyć operacje potrzebne do uzyskania odpowiedzi. Gdy lepiej poznasz SQL-a, nauczysz się łatwo ręcznie tworzyć podkwerendy.
Używanie operatorów IN i NOT IN w podkwerendach Operatory IN i NOT IN umożliwiają uruchamianie dwóch kwerend w ramach jednej. Podkwerenda jest uruchamiana jako pierwsza, a następnie wynikowy zbiór danych jest używany przez kwerendę zewnętrzną do przefiltrowania ostatecznych danych wyjściowych. W przykładzie przedstawionym na rysunku 15.7 najpierw uruchamiana jest podkwerenda, która pobiera wszystkich klientów z Kalifornii. Następnie zewnętrzna kwerenda używa wynikowego zbioru danych jako kryterium i zwraca sumę wartości z wierszy LineTotal tylko dla klientów o numerach zwróconych w podkwerendzie. Rysunek 15.7. W tej kwerendzie zastosowano operator IN i podkwerendę, dzięki czemu można jednocześnie wykonać dwie kwerendy
Operator NOT IN działa w odwrotny sposób. Zwraca sumę wartości z wierszy LineTotal dla tych klientów, których numery nie pasują do tych zwróconych przez podkwerendę.
Używanie podkwerend z operatorami porównania Jak ich nazwa wskazuje, operatory porównania (=, <, >, <=, >=, <> itd.) porównują dwa elementy i zwracają wartość True lub False. Zastosowanie operatora porównania do podkwerendy oznacza, że Access powinien porównać wynikowy zbiór danych kwerendy zewnętrznej z wynikowym zbiorem danych podkwerendy. Na przykład aby zwrócić wszystkich klientów, którzy dokonali zakupu na kwotę wyższą od średniej, można wykonać kwerendę przedstawioną na rysunku 15.8.
Rozdział 15. Podkwerendy i funkcje agregujące domeny
433
Rysunek 15.8. Można zastosować operatory porównania, aby porównać wynikowy zbiór danych kwerendy zewnętrznej z wynikami podkwerendy
Podkwerenda jest uruchamiana jako pierwsza i zwraca średni poziom zakupów dla wszystkich klientów. Jest to pojedyncza wartość, którą Access porównuje z wynikowym zbiorem danych kwerendy zewnętrznej. Oznacza to, że maksymalna wartość zakupu każdego klienta jest porównywana ze średnią. Jeśli jest wyższa, zostaje dodana do ostatecznych danych wyjściowych. W przeciwnym razie zostaje pominięta. Podkwerenda używana razem z operatorem porównania musi zwracać pojedynczą wartość.
Stosowanie podkwerend jako wyrażeń W każdym z dotychczasowych przykładów podkwerendy były używane razem z klauzulą WHERE. Wyniki podkwerendy pełniły więc funkcję kryterium dla kwerendy zewnętrznej. Jednak podkwerendę można też wykorzystać jako wyrażenie, przy czym podkwerenda musi wtedy zwracać pojedynczą wartość. W kwerendzie przedstawionej na rysunku 15.9 pokazano, jak zastosować podkwerendę jako wyrażenie w obliczeniach.
Rysunek 15.9. Podkwerenda jest używana jako wyrażenie w obliczeniach
W tym przykładzie podkwerendę wykorzystano do określenia średniej liczby produktów sprzedanych przez wszystkie oddziały firmy. Podkwerenda ta zwraca jedną wartość. Jest ona używana w obliczeniach do ustalenia różnicy między liczbą produktów sprzedanych na poszczególnych rynkach a średnią ogólną. Wyniki zwracane przez tę kwerendę przedstawia rysunek 15.10.
434
Część IV Analizowanie danych w Accessie
Rysunek 15.10. Wyniki kwerendy
Stosowanie podkwerend skorelowanych Kwerenda skorelowana to podkwerenda dotycząca kolumny używanej także w kwerendzie zewnętrznej. Wyjątkową cechą podkwerend skorelowanych jest to, że (w odróżnieniu od standardowych podkwerend, które trzeba uruchomić tylko raz, aby uzyskać wynik) są uruchamiane raz dla każdego wiersza przetwarzanego przez kwerendę zewnętrzną. Aby to zrozumieć, warto przyjrzeć się dwóm opisanym dalej instrukcjom SQL-a. Podkwerendy nieskorelowane Ta instrukcja SQL-a zawiera podkwerendę nieskorelowaną. Skąd o tym wiadomo? Otóż podkwerenda ta nie dotyczy żadnej kolumny z kwerendy zewnętrznej. Jest wykonywana jeden raz i zwraca średnie wpływy dla rekordów z całego zbioru danych. SELECT MainSummary.Branch_Number, (SELECT Avg(Revenue)FROM MainSummary) FROM MainSummary
Podkwerendy skorelowane W tej instrukcji SQL-a wykorzystano podkwerendę skorelowaną. W podkwerendzie tej użyto kolumny Branch_Number z kwerendy zewnętrznej, dlatego podkwerendę trzeba uruchomić dla każdego wiersza przetwarzanego w kwerendzie zewnętrznej. Ostateczny wynik zwracany przez tę kwerendę to zbiór danych ze średnią wartością wpływów dla każdego oddziału firmy. Na rysunku 15.11 pokazano, jak ta instrukcja SQL-a wygląda w widoku projektu. SELECT MainSummary.Branch_Number, (SELECT Avg(Revenue)FROM MainSummary AS M2 WHERE M2.Branch_Number = MainSummary.Branch_Number) AS AvgByBranch FROM MainSummary GROUP BY MainSummary.Branch_Number
Rysunek 15.11. Podkwerenda skorelowana
Rozdział 15. Podkwerendy i funkcje agregujące domeny
435
Stosowanie aliasów w podkwerendach skorelowanych Warto zauważyć, że w podkwerendzie skorelowanej zastosowano klauzulę AS do utworzenia aliasu T2 dla tabeli. Wynika to z tego, że w podkwerendzie i kwerendzie zewnętrznej używana jest ta sama tabela. Dzięki utworzeniu aliasu dla jednego z jej wystąpień można precyzyjnie poinformować Accessa, która tabela jest używana w instrukcji SQL-a. Choć alias w tej instrukcji jest tworzony dla podkwerendy, równie dobrze można przypisać alias do tabeli z kwerendy zewnętrznej. Warto zauważyć, że nazwa T1 nie ma żadnego konkretnego znaczenia. Można zastosować tu dowolny łańcuch znaków, o ile alias razem z nazwą kolumny nie mają łącznie więcej niż 255 znaków. Aby utworzyć alias dla tabeli w widoku projektu, wystarczy kliknąć prawym przyciskiem myszy listę pól i wybrać opcję Właściwości, co pokazano na poniższym rysunku.
Następnie wystarczy przypisać do właściwości Alias dowolne określenie (zobacz poniższy rysunek). O wprowadzeniu aliasu informuje lista pól, gdzie zamiast dawnej nazwy pojawia się alias.
Używanie podkwerendy skorelowanej jako wyrażenia W przykładzie przedstawionym na rysunku 15.9 wykorzystano podkwerendę nieskorelowaną do ustalenia różnicy między średnią liczbą jednostek sprzedanych na każdym rynku a średnią liczbą jednostek sprzedaną przez wszystkie oddziały firmy. Tę samą technikę można zastosować do podkwerend skorelowanych. W kwerendzie przedstawionej na rysunku 15.12 powiązanie z numerami poszczególnych oddziałów pozwala ustalić różnicę między rocznymi wpływami uzyskanymi przez każdego pracownika a średnimi wpływami w oddziale zatrudniającym tę osobę.
436
Część IV Analizowanie danych w Accessie
Rysunek 15.12. Podkwerendę skorelowaną można wykorzystać jako część wyrażenia
Używanie podkwerend w kwerendach funkcjonalnych Podkwerendy można stosować w kwerendach funkcjonalnych równie łatwo jak w kwerendach wybierających. Oto kilka przykładów ilustrujących, jak stosować podkwerendy w kwerendach funkcjonalnych. Podkwerendy w kwerendach tworzących tabele W tym przykładzie pokazano, jak zastosować podkwerendę w kwerendzie tworzącej tabelę: SELECT E1.Employee_Number, E1.Last_Name, E1.First_Name INTO OldSchoolEmployees FROM Employee_Master as E1 WHERE E1.Employee_Number IN (SELECT E2.Employee_Number FROM Employee_Master AS E2 WHERE E2.Hire_Date <#1/1/1995#)
Podkwerendy w kwerendach dołączających W tym przykładzie podkwerendę wykorzystano w kwerendzie dołączającej: INSERT INTO CustomerMaster (Customer_Number, Customer_Name, State ) SELECT CompanyNumber,CompanyName,State FROM LeadList WHERE CompanyNumber Not In (SELECT Customer_Number from CustomerMaster)
Podkwerendy w kwerendach aktualizujących W tym przykładzie zastosowano podkwerendę w kwerendzie aktualizującej: UPDATE PriceMaster SET Price = [Price]*1.1 WHERE Branch_Number In (SELECT Branch_Number from LocationMaster WHERE Region = "South")
Podkwerendy w kwerendach usuwających W tym przykładzie podkwerendę wykorzystano w kwerendzie usuwającej: DELETE * FROM LeadList WHERE CompanyNumber In (SELECT Customer_Number from CustomerMaster)
Rozdział 15. Podkwerendy i funkcje agregujące domeny
437
Jak za pomocą jednej kwerendy pobrać rekordy z drugiego kwartyla ze zbioru danych? Można łatwo uzyskać drugi kwartyl ze zbioru danych, używając podkwerendy pobierającej największe wartości: 1. Utwórz kwerendę pobierającą 25% największych rekordów ze zbioru danych. Aby utworzyć taką kwerendę, kliknij prawym przyciskiem myszy szary obszar nad białą siatką QBE i wybierz opcję Właściwości. W oknie dialogowym Arkusz właściwości zmień ustawienie właściwości Najwyższe wartości w taki sposób, aby zwracanych było N najwyższych wartości, co pokazano na poniższym rysunku (tu pobieranych jest 25% najwyższych wartości).
2. Przełącz się do widoku SQL-a (zobacz następny rysunek) i skopiuj łańcuch znaków z kodem SQL-a.
3. Przełącz się ponownie do widoku projektu i wklej skopiowaną instrukcję SQL-a w wierszu Kryteria pola Branch_Number. W tym celu kliknij prawym przyciskiem myszy w wierszu Kryteria pola Branch_Number i wybierz opcję Powiększ. Następnie w oknie dialogowym Powiększenie wklej skopiowaną instrukcję SQL-a, co pokazano na poniższym rysunku.
438
Część IV Analizowanie danych w Accessie
4. Następny krok jest nieco skomplikowany. We wklejonej instrukcji SQL-a trzeba wprowadzić pewne zmiany, aby działała poprawnie:
Ponieważ wklejona podkwerenda jest kryterium dla pola Branch_Number, w instrukcji SQL-a należy pobierać tylko pole Branch_Number. Dlatego można usunąć człon , Sum(MainSummary.Revenue).
Należy usunąć wszystkie znaki powrotu karetki.
Należy umieścić nawiasy wokół podkwerendy i dodać operator NOT IN przed całą instrukcją.
Na tym etapie okno dialogowe Powiększenie powinno wyglądać tak jak na poniższym rysunku.
5. Przełącz się do widoku projektu. Jeśli wszystko przebiegło prawidłowo, kwerenda powinna wyglądać podobnie jak na poniższym rysunku.
To już wszystko. Gdy uruchomisz tę kwerendę, otrzymasz drugi kwartyl ze zbioru danych. Aby otrzymać trzeci kwartyl, zastąp człon TOP 25 PERCENT w podkwerendzie fragmentem TOP 50 PERCENT, a w celu uzyskania czwartego kwartyla użyj wyrażenia TOP 75 PERCENT. Koniecznie zajrzyj do przykładowego pliku z kodem do tego rozdziału, aby zapoznać się z gotowymi kwerendami.
Funkcje agregujące domeny Funkcje agregujące domeny umożliwiają pobieranie i agregowanie informacji statystycznych z całego zbioru danych (z domeny). Funkcje te różnią się od kwerend podsumowujących, ponieważ te ostatnie grupują dane przed określaniem wartości, natomiast funkcje agregujące domeny obliczają wartości dla całego zbioru danych. Tak więc funkcje
Rozdział 15. Podkwerendy i funkcje agregujące domeny
439
agregujące domeny nigdy nie zwracają więcej niż jednej wartości. Aby dobrze zrozumieć różnicę między kwerendami podsumowującymi a funkcjami agregującymi domeny, utwórz kwerendę przedstawioną na rysunku 15.13. Rysunek 15.13. W tej kwerendzie pokazano różnicę między kwerendami podsumowującymi a funkcjami agregującymi domeny
Gdy uruchomisz tę kwerendę, otrzymasz wyniki przedstawione na rysunku 15.14. Warto zauważyć, że kolumna Aggregate Sum zawiera inną wartość łączną dla każdego roku, natomiast w kolumnie Domain Sum (obliczanej za pomocą funkcji agregującej domeny) znajduje się tylko jedna suma — dla całego zbioru danych. Rysunek 15.14. Wyraźnie widać różnicę między kwerendą podsumowującą a funkcją agregującą domeny Struktura funkcji agregujących domeny Istnieje 12 różnych funkcji agregujących domeny, jednak struktura każdej z nich jest taka sama: NazwaFunkcji("[Nazwa pola]";"[Nazwa zbioru danych]";"[Kryteria]")
NazwaFunkcji — jest to nazwa używanej funkcji agregującej domeny.
Nazwa pola (wymagana) — to wyrażenie określa pole zawierające przetwarzane dane.
Nazwa zbioru danych (wymagana) — to wyrażenie określa tabelę lub kwerendę zawierającą przetwarzane dane (to właśnie jest domena).
Kryteria (opcjonalne) — to wyrażenie służy do ograniczania zakresu danych, dla których wykonywana jest funkcja agregująca domeny. Jeśli nie określono kryteriów, funkcja agregująca domeny działa dla całego zbioru danych.
Funkcji agregujących domeny nie można używać razem z kwerendami z parametrami.
Choć w przykładach z tego rozdziału funkcje agregujące domeny są używane w wyrażeniach w kwerendach, warto pamiętać, że funkcje te można stosować także w makrach, modułach i obliczanych formantach w formularzach i raportach.
440
Część IV Analizowanie danych w Accessie
Różne funkcje agregujące domeny W Accessie istnieje 12 różnych funkcji agregujących domeny. Każda z nich wykonuje inne operacje. W tym punkcie opisaliśmy przeznaczenie każdej z tych funkcji. DSum Zwraca sumę wartości z określonego pola z domeny. Na przykład wywołanie DSum("[Line Total]"; "[Dim_Transactions]") zwraca sumę wartości z pola LineTotal z tabeli Dim_Transactions. DAvg Zwraca średnią wartości z określonego pola z domeny. Na przykład wywołanie Davg ("[LineTotal]"; "[Dim_Transactions]") zwraca średnią wartości z pola LineTotal z tabeli Dim_Transactions. DCount Zwraca łączną liczbę rekordów z domeny. Na przykład wywołanie DCount("*"; "[Dim_ Transactions]") zwraca liczbę rekordów w tabeli Dim_Transactions. DLookup Zwraca pierwszą wartość z określonego pola pasującą do zdefiniowanych w funkcji kryteriów. Jeśli nie podasz kryteriów, funkcja DLookup zwróci losową wartość z domeny. Na przykład wywołanie DLookUp("[Last_Name]";"[Employee_Master]";"[Employee_ Number]='42620' ") zwraca wartość pola Last_Name z rekordu, w którym pole Employee_ Number ma wartość 42620. DMin i DMax Zwracają minimalną oraz maksymalną wartość z domeny. Wywołanie DMin("[LineTotal] ";"[Dim_Transactions]") zwraca najmniejszą wartość pola LineTotal z tabeli Dim_Transactions, natomiast wywołanie DMax("[LineTotal]";"[Dim_Transactions]") zwraca największą wartość z tego pola.
DFirst i DLast Zwracają pierwszą oraz ostatnią wartość z domeny. Wywołanie DFirst("[LineTotal]";" [Dim_Transactions]") zwraca pierwszą wartość pola LineTotal z tabeli Dim_Transactions, natomiast wywołanie DLast("[LineTotal]";"[Dim_Transactions]") zwraca ostatnią wartość z tego pola.
DStDev, DStDevP, DVar i DVarP Za pomocą funkcji DStDev i DStDevP można uzyskać odchylenie standardowe dla próbki z populacji i dla całej populacji. Funkcje DVar i DVarP zwracają wariancję dla próbki z populacji i dla całej populacji. Wywołanie DStDev("[LineTotal]";"[Dim_Transactions]") zwraca odchylenie standardowe wartości z pola LineTotal z tabeli Dim_Transactions. Wywołanie DVar("[LineTotal]";"[Dim_Transactions]") zwraca wariancję wartości z pola LineTotal z tabeli Dim_Transactions.
Rozdział 15. Podkwerendy i funkcje agregujące domeny
441
Składnia funkcji agregujących domeny Funkcje agregujące domeny są wyjątkowe pod tym względem, że ich składnia zależy od sytuacji. Prowadzi to do poważnej frustracji użytkowników, którzy czasem całkowicie rezygnują ze stosowania takich funkcji. W tym punkcie opisaliśmy pewne ogólne wskazówki, które pomagają w tworzeniu funkcji agregujących domeny. Bez kryteriów To przykładowe wywołanie sumuje wartości z pola LineTotal z tabeli Dim_Transactions (to domena funkcji). Nawy pól i zbioru danych zawsze trzeba ujmować w cudzysłów. DSum("[LineTotal]";"[Dim_Transactions]")
Zwróć uwagę na zastosowane nawiasy kwadratowe. Choć nie zawsze są one niezbędne, zwykle warto je stosować przy podawaniu pola, tabeli lub kwerendy.
Stosowanie kryteriów tekstowych W tym przykładzie sumujemy wartości z pola Revenue z tabeli PvTblFeed (to domena) dla rekordów, których wartość pola Branch_Number to 301316. Warto zauważyć, że pole Branch_Number jest polem tekstowym. Kryteria tekstowe należy umieszczać w apostrofach. Ponadto całe wyrażenie stanowiące kryterium trzeba ująć w cudzysłów. DSum("[Revenue]";"[PvTblFeed]";"[Branch_Number] = '301316' ")
W wyrażeniu określającym kryterium w funkcji agregującej domeny można zastosować dowolną klauzulę WHERE. Daje to dodatkowe możliwości użytkownikom funkcji agregującej domeny, ponieważ pozwala na obsługę wielu kolumn i operatorów logicznych, takich jak AND, OR, NOT itd. Oto przykład: DSum("[Field1]";"[Table]";"[Field2] = 'A' OR [Field2] = 'B' AND [Field3] = 2")
Jeśli chcesz wskazać formant z formularza lub raportu, trzeba zastosować nieco inną składnię: DSum("[Revenue]";"[PvTblFeed]";"[Branch_Number] = ' " & [MyTextControl] & " ' " )
Warto zauważyć, że apostrofy zastosowano w celu przekształcenia wartości formantu na łańcuch znaków. Jeśli wartość w formancie formularza to 301316, człon "[Branch_Number] = ' " & [MyTextControl] & " ' " zostanie przekształcony na "[Branch_Number] = '301316' ". Stosowanie kryteriów liczbowych W tym przykładzie sumujemy wartości z pola LineTotal tabeli Dim_Transactions (jest to domena) dla rekordów, w których pole to ma wartość większą niż 500. Zauważ, że nie zastosowano tu apostrofów. Wynika to z tego, że LineTotal to pole liczbowe. DSum("[LineTotal]";"[Dim_Transactions]";"[LineTotal] > 500 ")
Jeśli chcesz wskazać formant z formularza lub raportu, musisz nieco zmienić składnię: DSum("[LineTotal]";"[Dim_Transactions]";"[LineTotal] > " [MyNumericControl])
442
Część IV Analizowanie danych w Accessie
Stosowanie kryteriów w postaci daty W tym przykładzie sumujemy wartości z pola LineTotal tabeli Dim_Transactions (jest to domena) dla rekordów, w których pole OrderDate ma wartość 07/05/2008: DSum("[LineTotal]";"[Dim_Transactions]";"[OrderDate] = #07/05/08# ")
Jeśli używany jest formant z formularza lub raportu, składnię trzeba nieco zmodyfikować: DSum("[LineTotal]";"[Dim_Transactions]";"[OrderDate] = #" & [MyDateControl] & "#")
Zauważ, że zastosowano znak kratki, aby przekształcić wartość formantu na datę. Jeśli w formancie w formularzu znajduje się wartość 07/05/2008, człon "[OrderDate] = #" & [MyTextControl] & "#" zostanie przekształcony na "[OrderDate] = #07/05/2008# ".
Stosowanie funkcji agregujących domeny Funkcje agregujące domeny, podobnie jak podkwerendy, nie są zbyt wydajne przy wykonywaniu analiz na dużą skalę i przetwarzaniu bardzo dużych zbiorów danych. Lepiej nadają się do przeprowadzania wyspecjalizowanych analiz na mniejszych podzbiorach danych. Najczęściej stosuje się je w środowisku, w którym zbiór danych jest przewidywalny i kontrolowany (np. w funkcjach, formularzach i raportach). Nie chcemy jednak przez to powiedzieć, że funkcje agregujące domeny nie znajdują zastosowania w codziennych analizach danych. W tym punkcie znajdziesz przykłady ilustrujące, jak wykonywać standardowe zadania za pomocą funkcji agregujących domeny. Obliczanie procentu z całości Kwerenda przedstawiona na rysunku 15.15 zwraca produkty według grup i sumę wartości pola LineTotal dla każdej kategorii produktów. Jest to wartościowa analiza, można ją jednak łatwo wzbogacić, dodając kolumnę określającą, jaki procent wpływów generuje każda grupa produktów. Rysunek 15.15. Można dodać kolumnę, która informuje, jaki procent wpływów generuje każda kategoria produktów
Aby uzyskać procent z wszystkich wpływów wygenerowanych dzięki każdej grupie produktów, trzeba oczywiście znać łączne wpływy uzyskane dla całego zbioru danych. W jego ustaleniu pomoże funkcja DSum. Poniższe wywołanie tej funkcji zwraca łączne wpływy dla całego zbioru danych: DSum("[LineTotal]";"[Dim_Transactions]")
Teraz można wykorzystać tę funkcję jako wyrażenie w obliczeniach, które zwracają, jaki procent wpływów wygenerowały poszczególne grupy produktów. Na rysunku 15.16 pokazano, jak utworzyć potrzebną kwerendę.
Rozdział 15. Podkwerendy i funkcje agregujące domeny
443
Rysunek 15.16. Możesz wykorzystać funkcję DSum jako wyrażenie w obliczeniach, żeby uzyskać procent łącznych wpływów
Wyniki widoczne na rysunku 15.17 są dowodem na to, że w ten sposób można szybko i łatwo uzyskać w jednej kwerendzie zarówno łączną wartość, jak i procent dla każdej grupy. Rysunek 15.17. Jedna kwerenda pobiera zarówno wpływy wygenerowane przez grupę, jak i procent łącznych wpływów
Zwracanie liczby elementów do danego dnia W kwerendzie z rysunku 15.18 wykorzystano funkcję DCount jako wyrażenie, aby zwracać liczbę faktur przetworzonych każdego dnia.
Rysunek 15.18. Ta kwerenda zwraca daty wystawienia wszystkich faktur i liczbę faktur przetworzonych każdego dnia
444
Część IV Analizowanie danych w Accessie
Zastanów się przez chwilę nad działaniem poniższego wywołania funkcji DCount: DCount("[TransactionID]";"[Dim_Transactions]";"[OrderDate]= #" & [OrderDate] & "#")
To wywołanie funkcji DCount zwraca liczbę faktur, dla których data wystawienia jest równa (=) poszczególnym datom zwróconym przez kwerendę. Dlatego w kontekście kwerendy z rysunku 15.18 wynikowy zbiór danych wyświetla wszystkie daty wystawienia faktur i liczbę faktur z każdego z tych dni. Co się stanie, jeśli zmodyfikujesz wywołanie funkcji w taki sposób, aby zwracało liczbę faktur dla daty równej lub wcześniejszej od dat zwróconych przez kwerendę? DCount("[TransactionID]";"[Dim_Transactions]";"[OrderDate]<= #" & [OrderDate] & "#")
Tu funkcja DCount zwraca liczbę faktur dla każdej daty i liczbę faktur dla dowolnej wcześniejszej daty, co daje liczbę faktur wystawionych do danego dnia. Aby zastosować to rozwiązanie, zastąp operator = z funkcji DCount operatorem <=, co pokazano na rysunku 15.19.
Rysunek 15.19. Zastosuj operator <= w funkcji DCount, aby zwrócić liczbę faktur o datach równych lub wcześniejszych względem daty zwróconej przez kwerendę
Rysunek 15.20 przedstawia uzyskaną liczbę faktur wystawionych do danego dnia. Rysunek 15.20. Teraz w ramach analiz generowana jest liczba faktur wystawionych do danego dnia
Rozdział 15. Podkwerendy i funkcje agregujące domeny
445
Można też uzyskać sumę wartości do danego dnia zamiast ich liczby. W tym celu należy wywołać funkcję DSum.
Stosowanie wartości z poprzedniego rekordu W kwerendzie z rysunku 15.21 wykorzystano funkcję DLookup do pobrania wpływów z poprzedniego rekordu. Uzyskana wartość jest zapisywana w nowej kolumnie o nazwie Yesterday.
Rysunek 15.21. W tej kwerendzie zastosowano funkcję DLookup do pobrania wpływów z poprzedniego dnia
Ta technika przypomina technikę zastosowaną do utworzenia sumy wartości do danego dnia. Obie oparte są na zmianie operatora porównania, aby zmodyfikować znaczenie funkcji agregującej domeny. Tu funkcja DLookup wyszukuje wpływy z rekordów, w których data faktury jest równa dacie o dzień wcześniejszej od daty zwróconej przez kwerendę. Jeśli odejmiesz 1 od zwróconej daty, otrzymasz wczorajszą datę! DLookUp("[Revenue]";"[TimeSummary]";"[OrderDate] = #" & [OrderDate]-1 & "#")
Jeśli dodasz 1, otrzymasz następny rekord z sekwencji. Sztuczka ta nie zadziała jednak dla pól tekstowych. Można ją zastosować tylko do dat i pól liczbowych. Jeśli używasz tabeli, w której nie występują takie pola, utwórz pole typu Autonumerowanie. Dzięki temu uzyskasz unikatowy identyfikator liczbowy, który można wykorzystać.
Gdy uruchomisz kwerendę z rysunku 15.21, uzyskasz wyniki z rysunku 15.22. Rysunek 15.22. Możesz wzbogacić ten mechanizm i przeprowadzić obliczenia dla poprzedniego dnia
446
Część IV Analizowanie danych w Accessie
Analizy te można wzbogacić, dodając pole obliczeniowe, które zwraca różnicę między dniem bieżącym a dniem wcześniejszym. Utwórz nową kolumnę i umieść w niej wyrażenie [Revenue]-NZ([Yesterday],0), co pokazano na rysunku 15.23. Warto zauważyć, że pole Yesterday umieszczono w funkcji NZ, aby uniknąć błędów powodowanych przez pola o wartości Null.
Rysunek 15.23. Można wzbogacić analizy, dodając różnicę między danym dniem a dniem wcześniejszym
Wyniki przedstawia rysunek 15.24. Rysunek 15.24. Inna operacja, którą można wykonać dzięki funkcjom agregującym domeny
Rozdział 16.
Statystyki opisowe W tym rozdziale:
Określanie pozycji, wartości modalnej i mediany
Pobieranie losowej próbki ze zbioru danych
Obliczanie percentyla
Określanie kwartyla dla rekordu
Tworzenie rozkładu częstości
Statystyki opisowe umożliwiają prezentowanie dużych ilości danych w postaci łatwych do zrozumienia podsumowań liczbowych. Gdy dodajesz, zliczasz lub uśredniasz dane, tworzysz statystyki opisowe. Należy zauważyć, że statystyki opisowe służą tylko do określania natury zbioru danych i umożliwiają tworzenie porównań, które można wykorzystać w innych analizach. Różnią się więc od statystyk dedukcyjnych, które pozwalają wyciągać wnioski wykraczające poza same dane. Aby lepiej zrozumieć różnice między statystykami opisowymi i dedukcyjnymi, pomyśl o ankietach przeprowadzanych wśród klientów. Statystyki opisowe podsumowują wyniki ankiety dla wszystkich klientów i pozwalają przedstawić dane za pomocą zrozumiałych wskaźników, natomiast statystyki dedukcyjne dotyczą wniosków, na przykład lojalności klientów ustalonej na podstawie różnic między grupami klientów. Do obliczania statystyk dedukcyjnych narzędzia w rodzaju Excela nadają się lepiej od Accessa. Dlaczego? Po pierwsze, Excel udostępnia wiele wbudowanych funkcji i narzędzi, które pozwalają na łatwe obliczanie statystyk dedukcyjnych. Access tych narzędzi nie posiada. Po drugie, statystyki dedukcyjne zwykle oblicza się dla małych zbiorów danych, które można swobodnie analizować i prezentować w Accessie. Natomiast obliczanie statystyk opisowych w Accessie jest praktycznym rozwiązaniem. Z uwagi na strukturę i wielkość danych często lepiej jest obliczać je w Accessie niż w Excelu. Wyjściową bazę danych dla tego rozdziału, Rozdział16.accdb, można pobrać z witryny poświęconej tej książce.
448
Część IV Analizowanie danych w Accessie
Podstawowe statystyki opisowe W tym podrozdziale omawiamy podstawowe zadania, które można wykonywać za pomocą statystyk opisowych.
Obliczanie statystyk opisowych za pomocą kwerend podsumowujących Na tym etapie książki uruchomiłeś już wiele kwerend Accessa. Część z nich to kwerendy podsumowujące. Gdy je uruchamiałeś, prawdopodobnie nie zdawałeś sobie sprawy, że obliczałeś statystyki opisowe. Naprawdę. Najprostsze statystyki opisowe można obliczyć za pomocą kwerend podsumowujących. Aby się o tym przekonać, utwórz kwerendę przedstawioną na rysunku 16.1.
Rysunek 16.1. Uruchomienie tej kwerendy podsumowującej pozwala uzyskać przydatne statystyki opisowe
Wyniki tej kwerendy przedstawia rysunek 16.2. Są one podobne do wyników funkcji obliczających statystyki opisowe w Excelu i udostępniają najważniejsze wskaźniki statystyczne dla całego zbioru danych.
Rysunek 16.2. Najważniejsze wskaźniki statystyczne dla całego zbioru danych
Do statystyk opisowych można łatwo dodawać poziomy. Na rysunku 16.3 dodano pole Branch_Number. Pozwala to uzyskać najważniejsze wskaźniki statystyczne dla każdego oddziału firmy.
Rysunek 16.3. Dołącz do kwerendy pole Branch_Number, aby dodać do analizy nowy wymiar
Rozdział 16. Statystyki opisowe
449
Na rysunku 16.4 widać, że można teraz porównywać statystyki opisowe dla różnych oddziałów, aby ustalić, jak funkcjonują.
Rysunek 16.4. W jednym arkuszu widoczne są statystyki opisowe dla każdego oddziału
Określanie rankingu, wartości modalnej i mediany Ustalanie rankingu rekordów, wartości modalnej i mediany w zbiorze danych to zadania, które analitycy danych muszą czasem wykonywać. Niestety, Access nie udostępnia wbudowanych funkcji, które umożliwiałyby łatwe wykonanie tych operacji. Oznacza to, że trzeba znaleźć sposób obliczania tego rodzaju statystyk opisowych. W tym punkcie poznasz pewne techniki, które można wykorzystać do ustalania rankingu, wartości modalnej i mediany. Określanie rankingu rekordów w zbiorze danych Bez wątpienia natrafisz na sytuację, gdy trzeba będzie uporządkować rekordy w zbiorze danych na podstawie pewnego wskaźnika, np. wygenerowanych wpływów. Ranking rekordów nie tylko jest przydatny w kontekście prezentowania danych, ale też stanowi ważny element przy obliczaniu zaawansowanych statystyk opisowych takich jak mediana, percentyle i kwartyle. Najłatwiejszym sposobem tworzenia rankingu rekordów w zbiorze danych jest wykorzystanie podkwerendy skorelowanej. W kwerendzie z rysunku 16.5 pokazano, jak utworzyć ranking za pomocą podkwerendy.
Rysunek 16.5. Ta kwerenda porządkuje pracowników na podstawie wpływów
450
Część IV Analizowanie danych w Accessie
Zastanów się nad podkwerendą, która generuje ranking: (SELECT Count(*)FROM RepSummary AS M1 WHERE [Rev]>[RepSummary].[Rev])+1
Ta podkwerenda skorelowana zwraca łączną liczbę rekordów z tabeli M1 (jest to tabela RepSummary o aliasie M1), dla których pole Rev w tej tabeli jest większe od pola Rev z tabeli RepSummary. Następnie wartość w podkwerendzie jest zwiększana o 1. Dlaczego? Jeśli tego nie zrobisz, dla rekordu o największej wartości zwrócona zostanie wartość 0, ponieważ jest zero rekordów większych od rekordu o maksymalnej wartości. Wtedy ranking zaczynać się będzie od wartości 0 zamiast 1. Dodanie 1 pozwala zapewnić, że ranking rozpocznie się od pozycji pierwszej. Ponieważ używana jest tu podkwerenda skorelowana, jest ona wykonywana dla każdego rekordu ze zbioru danych, dzięki czemu dla wszystkich rekordów zwracane są inne pozycje.
Szczegółowe omówienie podkwerend skorelowanych znajdziesz w rozdziale 15.
Wyniki zostały przedstawione na rysunku 16.6. Rysunek 16.6. Utworzono kolumnę Rank dla zbioru danych
Technika ta jest przydatna także wtedy, gdy trzeba utworzyć w kwerendzie pole typu Autonumerowanie.
Określanie wartości modalnej dla zbioru danych Wartość modalna w zbiorze danych to liczba, która pojawia się w tym zbiorze najczęściej. Na przykład wartością modalną dla zbioru {4, 5, 5, 6, 7, 5, 3, 4} jest 5. Access (w odróżnieniu od Excela) nie udostępnia wbudowanej funkcji Mode, dlatego trzeba opracować własną metodę określania wartości modalnej dla zbioru danych. Choć istnieją różne sposoby ustalenia wartości modalnej, najłatwiej jest za pomocą kwerendy zliczyć wystąpienia poszczególnych elementów, a następnie przefiltrować je, tak aby pozostał element o największej liczbie wystąpień. Aby zastosować tę metodę, wykonaj następujące czynności: 1. Utwórz kwerendę przedstawioną na rysunku 16.7. Wyniki (przedstawione na rysunku 16.8) nie wyglądają na pomocne, jednak jeśli zastosujesz kwerendę zwracającą tylko największą wartość, uzyskasz wartość modalną.
Rozdział 16. Statystyki opisowe
451
Rysunek 16.7. Ta kwerenda grupuje dane według pola Rev, a następnie zlicza wystąpienia każdej liczby z tego pola. Kwerenda jest sortowana malejąco na podstawie pola Rev
Rysunek 16.8. Prawie gotowe — wystarczy zastosować kwerendę zwracającą największe wartości, aby otrzymać wartość modalną
2. Otwórz zakładkę NARZĘDZIA KWEREND PROJEKTOWANIE i kliknij przycisk Arkusz właściwości. Pojawi się okno dialogowe Arkusz właściwości dla kwerendy. 3. Ustaw właściwość Najwyższe wartości na 1, jak pokazano na rysunku 16.9. Otrzymasz rekord o największej liczbie wystąpień. Rysunek 16.9. Ustaw właściwość Najwyższe wartości na 1
Na rysunku 16.10 widać, że teraz zwracana jest tylko jedna wartość z pola Rev — ta, która występuje najczęściej. To właśnie jest wartość modalna. Rysunek 16.10. Oto wartość modalna Warto pamiętać, że jeśli najczęściej występuje kilka wartości, kwerenda wyświetlająca największe wartości pokaże wszystkie rekordy o wartości maksymalnej. Prowadzi to do zwrócenia więcej niż jednej wartości modalnej. W takiej sytuacji trzeba samodzielnie określić, którą wartość modalną zastosować.
452
Część IV Analizowanie danych w Accessie
Określanie mediany dla zbioru danych Mediana dla zbioru danych to środkowa wartość ze zbioru danych. Oznacza to, że połowa liczb ma wartość większą i połowa ma wartość mniejszą od mediany. Na przykład medianą w zbiorze {3, 4, 5, 6, 7, 8, 9} jest 6, ponieważ jest to środkowa liczba w tym zbiorze danych. Dlaczego po prostu nie obliczyć średniej? Otóż czasem uwzględnienie skrajnych przypadków w średniej powoduje zafałszowanie analiz. Na przykład jeśli obliczysz średnią dla zbioru {32, 34, 35, 37, 89}, otrzymasz wynik 45,4. Problem polega na tym, że wartość ta nie reprezentuje tendencji centralnej dla badanej próbki liczb. Większy sens ma zastosowanie dla tej próbki mediany. Wynosi ona 35 i lepiej reprezentuje dane.
Access nie ma wbudowanej funkcji Median, dlatego trzeba opracować własną technikę określania mediany dla zbiorów danych. Łatwym sposobem na uzyskanie pożądanych efektów jest utworzenie kwerendy w dwóch krokach: 1. Utwórz kwerendę, która sortuje rekordy i tworzy ranking. Kwerenda z rysunku 16.11 sortuje rekordy i tworzy ich ranking w tabeli RepSummary.
Rysunek 16.11. Pierwszy krok w trakcie określania mediany dla zbioru danych wymaga określenia pozycji każdego rekordu w rankingu
2. Określ środkowy rekordy ze zbioru danych, zliczając rekordy z tego zbioru, a następnie dzieląc uzyskaną wartość przez 2. Dzięki temu otrzymasz środkową wartość. Ponieważ rekordy są teraz posortowane i uporządkowane w rankingu, rekord o pozycji odpowiadającej środkowej wartości jest medianą. Rysunek 16.12 przedstawia podkwerendę, która zwraca środkową wartość zbioru danych. Zauważ, że wartość ta jest umieszczona w funkcji Int, co powoduje usunięcie części ułamkowej liczby. Na rysunku 16.13 widać, że środkową wartość ma rekord 336. Możesz przejść do tego rekordu, aby zobaczyć medianę. Jeśli chcesz tylko zwrócić medianę, zastosuj podkwerendę jako kryterium w polu Rank, jak pokazano na rysunku 16.14.
Rozdział 16. Statystyki opisowe
453
Rysunek 16.12. Podkwerenda Middle Value zlicza wszystkie rekordy ze zbioru danych, a następnie dzieli uzyskaną liczbę przez 2
Rysunek 16.13. Przejdź do rekordu 336, aby zobaczyć medianę dla zbioru danych
Rysunek 16.14. Zastosowanie podkwerendy jako kryterium w polu Rank powoduje, że zwracana jest tylko mediana
454
Część IV Analizowanie danych w Accessie
Pobieranie losowej próbki ze zbioru danych Choć tworzenie losowej próbki danych niekoniecznie można uznać za zadanie z zakresu statystyki opisowej, takie próbki często są podstawą do analiz statystycznych. W Accessie losowe próbki danych można tworzyć na wiele sposobów. Jednym z najłatwiejszych jest zastosowanie funkcji Rnd w kwerendzie zwracającej najwyższe wartości. Funkcja ta na podstawie wyjściowej wartości zwraca losową liczbę. Chodzi o to, aby utworzyć wyrażenie, które stosuje funkcję Rnd do pola z wartościami liczbowymi, a następnie ograniczyć listę zwracanych rekordów za pomocą właściwości Najwyższe wartości kwerendy. Aby zastosować tę metodę, wykonaj następujące czynności: 1. W widoku projektu utwórz kwerendę używającą tabeli TransactionMaster. 2. Utwórz pole Random ID (zobacz rysunek 16.15), a następnie posortuj dane rosnąco lub malejąco według tego pola. Rysunek 16.15. Zacznij od utworzenia pola Random ID, wywołując funkcję Rnd dla pola Customer_Number
Funkcja Rnd nie zadziała dla pól zawierających tekst lub wartości Null. Co dziwne, działa ona dla pól z liczbami nawet wtedy, gdy pola te mają tekstowy typ danych. Jeśli tabela składa się z pól zawierających tylko tekst, możesz dodać pole typu Autonumerowanie, aby móc wykorzystać je w funkcji Rnd. Inna możliwość to przekazanie pola zawierającego tekst do funkcji Len, a następnie wykorzystanie tego wyrażenia w funkcji Rnd — np. Rnd(Len([Mytext])).
3. Otwórz zakładkę NARZĘDZIA KWEREND PROJEKTOWANIE i kliknij przycisk Arkusz właściwości. Pojawi się okno dialogowe Arkusz właściwości dla kwerendy. 4. Zmień wartość właściwości Najwyższe wartości na 1000, co pokazano na rysunku 16.16. 5. Wyłącz zaznaczenie w wierszu Pokaż dla pola Random ID i dodaj pola, które chcesz wyświetlić w zbiorze danych. 6. Uruchom kwerendę. Otrzymasz całkowicie losową próbkę danych, co pokazano na rysunku 16.17.
Rozdział 16. Statystyki opisowe
455
Rysunek 16.16. Ogranicz liczbę zwracanych rekordów, ustawiając właściwość Najwyższe wartości kwerendy
Rysunek 16.17. Kwerenda ta generuje próbkę 1000 losowych rekordów Gdy ponownie uruchomisz tę kwerendę, zmienisz widok lub posortujesz zbiór danych, wówczas otrzymasz inny zbiór losowych rekordów. Jeśli chcesz przeprowadzać rozbudowane analizy na niezmiennym zbiorze losowych rekordów, uruchom przedstawioną kwerendę jako kwerendę tworzącą tabelę. Pozwoli to utworzyć trwałą tabelę.
Zaawansowane statystyki opisowe W czasie stosowania statystyk opisowych niewielka ilość wiedzy może przynieść cenne efekty. Podstawowe analizy statystyczne często prowadzą do bardziej zaawansowanych. W tym podrozdziale wykorzystasz poznane wcześniej podstawy do przygotowania zaawansowanych statystyk opisowych.
Obliczanie percentyli Percentyl określa relację danego wyniku względem standardu dla grupy. Percentyle najczęściej stosuje się przy określaniu wyników w standaryzowanych testach. Jeśli wynik dziecka w takim teście odpowiada 90. percentylowi, jest wyższy od wyników 90% innych dzieci biorących udział w tym teście. Można też ująć to tak: taki wynik należy do 10% najwyższych wyników wszystkich dzieci zdających ten test. Percentyle często używa się w analizach danych do pomiaru wyniku badanego względem grupy. Można na przykład określić, w jakim percentylu znalazł się każdy pracownik ze względu na roczne wpływy uzyskane dla firmy.
456
Część IV Analizowanie danych w Accessie
Obliczanie percentyli dla zbioru danych to operacja matematyczna. Wzór na percentyle to: (liczba rekordów – pozycja) / liczba rekordów. Cały problem polega na uzyskaniu wszystkich zmiennych potrzebnych do wykonania tej operacji. Wykonaj następujące czynności: 1. Utwórz kwerendę z rysunku 16.18. Porządkuje ona wszystkich pracowników według rocznych wpływów. Koniecznie nadaj nowemu polu alias Rank.
Rysunek 16.18. Rozpocznij od utworzenia kwerendy, która porządkuje pracowników na podstawie wpływów
2. Dodaj pole, które zlicza rekordy ze zbioru danych. Na rysunku 16.19 widać, że wykorzystano do tego podkwerendę. Koniecznie nadaj nowemu polu alias RCount.
Rysunek 16.19. Dodaj pole, które zwraca łączną liczbę rekordów
3. Utwórz pole obliczeniowe z wyrażeniem (RCount–Rank)/RCount. Na tym etapie kwerenda powinna wyglądać jak ta z rysunku 16.20. 4. Uruchom kwerendę. Gdy posortujesz dane według pola Rev, uzyskasz wyniki przedstawione na rysunku 16.21. Wynikowy zbiór danych pozwala ocenić wyniki każdego pracownika względem całej grupy. Na przykład szósty pracownik ze zbioru danych znajduje się w 99. percentylu, co oznacza, że wygenerował więcej wpływów niż 99% pozostałych pracowników.
Rozdział 16. Statystyki opisowe
457
Rysunek 16.20. Ostatni krok polega na utworzeniu pola obliczeniowego określającego, w którym percentylu znajduje się każdy rekord Rysunek 16.21. Udało się z powodzeniem obliczyć, w którym percentylu znajduje się każdy pracownik
Ustalanie kwartyla dla rekordu Kwartyl to miara statystyczna oparta na podziale zbioru danych na cztery równe grupy (każda z nich zawiera 25% elementów z całego zbioru). Najwyższe 25% zbioru znajduje się w pierwszym kwartylu, natomiast najniższe 25% — w kwartylu czwartym. Kwartyle zwykle stosuje się do podziału danych na logiczne grupy, które można porównywać i niezależnie analizować. Na przykład jeśli chcesz określić minimalny standard dla generowanych miesięcznie wpływów, możesz ustalić go na poziomie średniej dla pracowników z trzeciego kwartyla. W ten sposób uzyskasz minimalny standard, który w przeszłości osiągnęło lub przekroczyło 50% pracowników. Ustalenie kwartylu, do którego należą poszczególne rekordy ze zbioru danych, nie wymaga wykonywania operacji matematycznych — wystarczy porównać wartości. Należy porównać ranking każdego rekordu z punktami wyznaczającymi kwartyle. Dlaczego? Załóżmy, że zbiór danych zawiera 100 rekordów. Gdy podzielisz 100 przez cztery, otrzymasz punkt wyznaczający pierwszy kwartyl (25). Oznacza to, że każdy rekord z pozycji 25 lub wyższej należy do pierwszego kwartyla. Aby uzyskać punkt wyznaczający drugi kwartyl, należy wykonać działanie 100/4*2. Punkt wyznaczający trzeci kwartyl można obliczyć za pomocą działania 100/4*3.
458
Część IV Analizowanie danych w Accessie
Na podstawie tych informacji łatwo zauważyć, że należy uporządkować rekordy w zbiorze danych i zliczyć je. Zacznij od utworzenia kwerendy z rysunku 16.22. Utwórz pole Rank w taki sam sposób jak na rysunku 16.18, a pole RCount — tak jak na rysunku 16.19. Rysunek 16.22. Zacznij od utworzenia pól Rank (w którym pracownicy są uporządkowani według wygenerowanych wpływów) i RCount (które zawiera łączną liczbę rekordów w zbiorze danych)
Po utworzeniu w kwerendzie pól Rank i RCount można je wykorzystać w funkcji Switch, która przypisuje do każdego rekordu odpowiedni kwartyl. Przyjrzyj się przez chwilę używanej funkcji Switch: Switch([Rank]<=[RCount]/4*1,"1st",[Rank]<=[RCount]/4*2,"2nd", [Rank]<= [RCount]/4*3,"3rd",True,"4th")
Funkcja Switch sprawdza tu cztery warunki i porównuje pozycję każdego rekordu z punktami wyznaczającymi kwartyle w używanym zbiorze danych. Więcej informacji na temat funkcji Switch znajdziesz w rozdziale 13.
Na rysunku 16.23 pokazano, jak wykorzystać przedstawioną funkcję Switch w kwerendzie. Zauważ, że używany jest tu alias Quartile.
Rysunek 16.23. Używanie funkcji Switch do tworzenia znaczników określających kwartyle
Jak widać na rysunku 16.24, można posortować wynikowy zbiór danych według dowolnego pola, a znaczniki określające kwartyle pozostaną prawidłowe.
Tworzenie rozkładu częstości Rozkład częstości to analiza specjalnego rodzaju, która kategoryzuje dane według liczby wystąpień elementów o określonych wartościach wyznaczanych przez zmienne. Na rysunku 16.25 pokazano rozkład częstości utworzony za pomocą funkcji Partition.
Rozdział 16. Statystyki opisowe
459
Rysunek 16.24. Wynikowy zbiór danych można posortować w dowolny sposób bez ryzyka utraty znaczników określających kwartyle
Rysunek 16.25. Ten rozkład częstości utworzono za pomocą funkcji Partition
W tym rozkładzie częstości pracownicy są grupowani na podstawie uzyskanych wpływów. Na przykład 183 pracowników należy do grupy 500: 5999. Oznacza to, że tych 183 pracowników zarobiło od 500 do 5999 dolarów każdy. Choć uzyskane tu wyniki można otrzymać na kilka sposobów, najłatwiejsza technika tworzenia rozkładu częstości oparta jest na funkcji Partition: Partition(Liczba, Wartość początkowa, Wartość końcowa, Skok)
Funkcja Partition określa przedział, do którego należy dana liczba. Informuje, w jakim miejscu wyznaczanej serii przedziałów znajduje się ta liczba. Funkcja Partition wymaga podania następujących czterech argumentów: (wymagany) — sprawdzana liczba. W kwerendzie jest to zwykle nazwa pola. Pozwala to określić, że należy sprawdzić wartości tego pola z wszystkich wierszy.
Liczba
(wymagany) — liczba całkowita, od której rozpoczyna się wyznaczanie przedziałów. Warto zauważyć, że liczba ta nie może być mniejsza od 0.
Wartość początkowa
(wymagany) — liczba całkowita, przy której kończy się wyznaczanie przedziałów. Warto zauważyć, że liczba ta musi być większa niż Wartość początkowa.
Wartość końcowa
460
Część IV Analizowanie danych w Accessie
(wymagany) — liczba całkowita określająca wielkość każdego przedziału z zakresu od Wartość początkowa do Wartość końcowa. Liczba ta nie może być mniejsza od 1.
Skok
Aby utworzyć rozkład częstości widoczny na rysunku 16.25, utwórz kwerendę z rysunku 16.26. W kwerendzie tej wykorzystano funkcję Partition. Za pomocą argumentów określono, że sprawdzane jest pole Revenue, wartością początkową jest 500, wartością końcową 100 000, a skok wynosi 5000. Rysunek 16.26. Ta prosta kwerenda tworzy rozkład częstości przedstawiony na rysunku 16.25
Rozkład częstości można też utworzyć dla grup. W tym celu należy dodać do kwerendy pole Grupuj według. Na rysunku 16.27 pokazano, jak to zrobić na podstawie pola Branch_Number. Rysunek 16.27. Ta kwerenda tworzy odrębny rozkład częstości dla każdego numeru oddziału ze zbioru danych
Wynik to zbiór danych (zobacz rysunek 16.28) obejmujący odrębny rozkład częstości dla każdego oddziału. W wynikach szczegółowo określona jest liczba pracowników z każdego przedziału rozkładu wpływów. Rysunek 16.28. Udało się za pomocą jednej kwerendy utworzyć zbiór rozkładów częstości
Część V
Formularze i raporty Accessa W tej części:
Rozdział 17. Tworzenie prostych formularzy
Rozdział 18. Praca z danymi w formularzach
Rozdział 19. Praca z formantami formularzy
Rozdział 20. Prezentowanie danych za pomocą raportów
Rozdział 21. Raporty w Accessie — techniki zaawansowane
Formularze i raporty to narzędzia Accessa dające niezwykle dużo możliwości. Formularze Accessa umożliwiają użytkownikom tworzenie interfejsów dla tabel baz danych i są niezawodnym mechanizmem do szybkiego rozwijania aplikacji używanym w organizacjach różnego rodzaju. Raporty Accessa pozwalają szybko połączyć analizy bazy danych z eleganckimi prezentacjami przypominającymi dokumenty w formacie PDF. Raporty obsługują grupowanie, sortowanie i warunkowe formatowanie danych. Z trzech pierwszych rozdziałów tej części dowiesz się wszystkiego, czego potrzebujesz, aby przekształcić prostą bazę w kompletną aplikację z atrakcyjnym interfejsem, który umożliwia przeglądanie, dodawanie, edytowanie i usuwanie danych. W dwóch ostatnich rozdziałach tej części omówiliśmy zadania wykonywane przy tworzeniu raportów Accessa. Z tych rozdziałów dowiesz się, jak zapewnić użytkownikom wygodny sposób przeglądania podsumowań informacji na pożądanym poziomie szczegółowości i jednocześnie umożliwić drukowanie danych w różnych formatach.
462
Część V Formularze i raporty Accessa
Rozdział 17.
Tworzenie prostych formularzy W tym rozdziale:
Tworzenie różnych typów formularzy
Dodawanie formantów w formularzu
Korzystanie z arkusza właściwości
Formularze to najbardziej elastyczny sposób przeglądania, dodawania, edytowania i usuwania danych. Wykorzystuje się je również jako panele przełączania (formularze z przyciskami nawigacyjnymi), jako okna dialogowe do zarządzania przepływem sterowania w systemie, a także do wyświetlania komunikatów. Formanty to obiekty umieszczane w formularzach, takie jak etykiety, pola tekstowe, przyciski itp. Z tego rozdziału dowiesz się, w jaki sposób tworzy się różne rodzaje formularzy. Poznasz też typy formantów wykorzystywanych w formularzach. W niniejszym rozdziale omówiono również właściwości formularzy i formantów. Pokazano też, w jaki sposób definiować wygląd i działanie interfejsu użytkownika za pomocą ustawiania bądź modyfikowania właściwości. Formularze dodawane do bazy danych Accessa to kluczowy element tworzonych aplikacji. W większości przypadków nie należy zezwalać użytkownikom na bezpośredni dostęp do arkuszy danych tabel lub kwerend, gdyż bardzo łatwo może dojść do usunięcia cennych informacji lub wprowadzenia nieprawidłowych danych do tabeli. Formularze są cennym narzędziem zapewniającym zachowanie integralności danych w bazie. Ponieważ w formularzach można zapisywać kod VBA i makra, mogą one służyć do weryfikowania poprawności wprowadzanych danych lub do potwierdzania zamiaru usunięcia rekordów przed faktycznym przeprowadzeniem operacji usuwania. Dobrze zaprojektowane formularze pozwalają także uniknąć konieczności szkolenia użytkowników, ponieważ umożliwiają wyświetlanie komunikatów, gdy użytkownik porusza się po formularzu. Formularze mogą również podpowiadać wartości domyślne lub przeprowadzać obliczenia na podstawie informacji wprowadzanych przez użytkownika lub pobieranych z tabel bazy danych. W tym rozdziale wykorzystano tabele tblProducts, tblCustomers oraz inne tabele z bazy danych Rozdział17.accdb.
464
Część V Formularze i raporty Accessa
Tworzenie formularzy Aby dodać formularz do bazy danych, można skorzystać z grupy Formularze z zakładki TWORZENIE wstążki. Za pomocą poleceń z grupy Formularze (zobacz rysunek 17.1) można utworzyć następujące typy formularzy:
Rysunek 17.1. Grupa Formularze z zakładki TWORZENIE na wstążce umożliwia dodawanie formularzy do bazy danych
Formularz — tworzy nowy formularz, umożliwiający wprowadzanie informacji dla jednego rekordu. Aby można było skorzystać z tego polecenia, należy wcześniej otworzyć lub zaznaczyć tabelę, kwerendę, formularz bądź raport. Jeśli zaznaczysz tabelę lub kwerendę w okienku nawigacji, a następnie klikniesz przycisk Formularz, Access powiąże nowy formularz ze źródłem danych i otworzy formularz w widoku układu.
Projekt formularza — tworzy nowy pusty formularz i wyświetla go w widoku projektu. Taki formularz nie jest powiązany ze źródłem danych. Trzeba określić odpowiednie źródło danych (tabelę lub kwerendę) i utworzyć formularz, dodając formanty na podstawie listy pól tego źródła.
Pusty formularz — tworzy pusty formularz, który nie zawiera żadnych formantów. Nowy formularz (podobnie jak w projekcie formularza) nie jest powiązany z żadnym źródłem danych i otwiera się w widoku układu.
Kreator formularzy — prosty kreator ułatwiający tworzenie formularzy. Wyświetla pytanie o źródło danych, umożliwia wybranie pól, które mają się znaleźć w formularzu, a także pozwala na wskazanie jednego z kilku prostych układów nowego formularza.
Formularz nawigacyjny — specjalny formularz dostarczający użytkownikom mechanizmów poruszania się po aplikacji. Więcej informacji na temat formularzy nawigacyjnych można znaleźć w dalszej części tego rozdziału.
Więcej formularzy — przycisk Więcej formularzy w grupie Formularze wyświetla rozwijaną listę zawierającą kilka innych typów formularzy:
Wiele elementów — prosty formularz w postaci tabelarycznej wyświetlający kilka rekordów związanych z wybranym źródłem danych.
Arkusz danych — tworzy formularz, który jest wyświetlany w widoku arkusza danych.
Rozdział 17. Tworzenie prostych formularzy
465
Formularz dzielony — tworzy formularz dzielony, w którym w górnej, dolnej, lewej lub prawej części wyświetla się arkusz danych, natomiast w drugiej części znajduje się formularz umożliwiający wprowadzanie informacji dotyczących rekordu wybranego w arkuszu.
Modalne okno dialogowe — szablon formularza w postaci modalnego okna dialogowego. Formularz tego typu (często określany po prostu jako okno dialogowe) pozostaje na ekranie do czasu, aż użytkownik wprowadzi informacje wymagane w oknie albo je zamknie.
Jeśli któryś z powyższych terminów jest dla Czytelnika niezrozumiały, nie należy się martwić — każdy z nich zostanie szczegółowo omówiony w niniejszym rozdziale. Trzeba pamiętać, że wstążka Accessa i jej zawartość zależy od kontekstu, zatem nie wszystkie z opisywanych opcji muszą być dostępne na zakładce TWORZENIE.
Tworzenie nowego formularza Tak jak w przypadku innych obiektów w Accessie, formularze można dodawać do aplikacji na wiele sposobów. Najłatwiejszy polega na wskazaniu źródła danych, na przykład tabeli, a następnie kliknięciu przycisku Formularz z zakładki TWORZENIE. Inny zaś wiąże się z wykorzystaniem kreatora formularzy, który przeprowadza użytkownika przez proces definiowania źródła danych i innych szczegółów nowego formularza. Użycie przycisku Formularz Aby automatycznie utworzyć nowy formularz na podstawie tabeli lub kwerendy wybranej w okienku nawigacji, należy skorzystać z polecenia Formularz z grupy Formularze na wstążce. W poprzednich wersjach Accessa ta funkcja była dostępna pod nazwą Autoformularz.
Aby utworzyć formularz na podstawie tabeli tblProducts, wykonaj następujące czynności: 1. Wybierz tabelę tblProdukty w okienku nawigacji. 2. Kliknij zakładkę TWORZENIE na wstążce. 3. Kliknij polecenie Formularz w grupie Formularze. Access utworzy nowy pusty formularz na podstawie tabeli tblProducts i wyświetli go w widoku układu (zobacz rysunek 17.2). Widok układu pozwala na modyfikację projektu formularza podczas przeglądania danych. (Formularz pokazany na rysunku 17.2 jest dostępny w przykładowej bazie danych Rozdział17.accdb pod nazwą frmProducts_AutoForm). Nowy formularz wyświetla się w widoku układu. Jest wypełniony formantami powiązanymi z wszystkimi polami ze wskazanego źródła danych. Widok układu daje użytkownikowi wyobrażenie o tym, w jaki sposób formanty (kontrolki) są rozmieszczone względem siebie, ale nie można go wykorzystywać do zmiany rozmiaru formantów lub do ich przemieszczania po formularzu. Aby zmienić układ formantów w formularzu, wystarczy kliknąć prawym przyciskiem myszy na pasku tytułu formularza, a następnie wybrać polecenie Widok projektu.
466
Część V Formularze i raporty Accessa
Rysunek 17.2. Użycie polecenia Formularz powoduje szybkie utworzenie nowego formularza zawierającego wszystkie pola z tabeli lub kwerendy
Przycisk Projekt formularza z grupy Formularze w gruncie rzeczy wykonuje to samo zadanie co przycisk Formularz. Różnica polega na tym, że do widoku projektu formularza nie są dodawane żadne formanty, a formularz otwiera się w widoku projektu. Przycisk Projekt formularza najbardziej przydaje się podczas tworzenia nowego formularza, w którym nie będą wykorzystywane wszystkie pola ze wskazanego źródła danych, a użytkownik potrzebuje większej kontroli nad rozmieszczeniem formantów. W podobny sposób działa opcja Pusty formularz, która otwiera nowy pusty formularz, ale w widoku układu. Formanty dodaje się do formularza poprzez przeciąganie pól z okna Lista pól, ale użytkownik ma niewielką kontrolę nad ich rozmieszczeniem. Opcja Pusty formularz najbardziej przydaje się wtedy, kiedy chcesz szybko stworzyć formularz ze związanymi formantami, a ich rozmieszczenie nie ma znaczenia. Dzięki tej opcji można w mniej niż minutę stworzyć nowy pusty formularz. Tworzenie formularzy za pomocą kreatora Aby utworzyć formularz za pomocą kreatora, należy skorzystać z polecenia Kreator formularzy z grupy Formularze na wstążce. Kreator formularzy wyświetla użytkownikom szereg zaprezentowanych wizualnie pytań dotyczących formularza, który ma zostać utworzony, a następnie generuje go automatycznie. Kreator formularzy pozwala na wybór pól występujących w formularzu, ich układu (Kolumnowy, Tabelaryczny, Arkusz danych, Wyjustowany) oraz tytułu formularza. Aby uruchomić kreator formularzy na podstawie tabeli tblCustomers, wykonaj następujące czynności:
Rozdział 17. Tworzenie prostych formularzy
467
1. Wybierz tabelę tblCustomers w okienku nawigacji. 2. Kliknij zakładkę TWORZENIE na wstążce. 3. Kliknij polecenie Kreator formularzy w grupie Formularze. Access uruchomi kreator formularzy pokazany na rysunku 17.3. Rysunek 17.3. Za pomocą Kreatora formularzy można utworzyć formularz na podstawie pól wybranych przez użytkownika
Kreator wstępnie wypełnia formularz polami z tabeli tblCustomers. Można jednak wybrać inną tabelę lub kwerendę, posługując się rozwijaną listą Tabele/Kwerendy nad obszarem wyboru pól. Za pomocą przycisków w środkowej części formularza można dodawać bądź usuwać pola do list Dostępne pola i Zaznaczone pola. Można także kliknąć dwukrotnie dowolne pole na liście Dostępne pola, aby przenieść je na listę Zaznaczone pola.
Grupa przycisków w dolnej części formularza umożliwia poruszanie się pomiędzy poszczególnymi etapami działania kreatora. Przyciski dostępne w tej części są wspólne dla większości okien dialogowych kreatorów:
Anuluj — anulowanie działania kreatora bez utworzenia formularza.
Wstecz — powrót do poprzedniego kroku kreatora.
Dalej — przejście do następnego kroku kreatora.
Zakończ — zakończenie działania kreatora i utworzenie formularza na podstawie bieżących ustawień. W przypadku kliknięcia przycisku Dalej lub Zakończ bez wybrania żadnego z pól Access poinformuje, że kontynuacja wymaga wybrania pól formularza.
468
Część V Formularze i raporty Accessa
Kliknięcie przycisku Dalej powoduje otwarcie drugiego okna dialogowego kreatora (pokazanego na rysunku 17.4). Można w nim określić ogólny układ i wygląd nowego formularza. Rysunek 17.4. Wybór układu nowego formularza
Układ Kolumnowy jest ustawieniem domyślnym, można jednak wybrać także jedną z pozostałych opcji: Tabelaryczny, Arkusz danych i Wyjustowany. Kliknięcie przycisku Dalej powoduje otwarcie ostatniego okna dialogowego kreatora (zobacz rysunek 17.5). W tym oknie należy podać nazwę nowego formularza. Rysunek 17.5. Zapisywanie nowego formularza
Największą zaletą korzystania z kreatora formularzy są ułatwienia w postaci powiązania nowego formularza ze źródłem danych oraz dodania formantów dla wybranych pól. Jednak w większości przypadków użytkownik musi wykonać sporo pracy już po zakończeniu działania kreatora formularzy.
Rozdział 17. Tworzenie prostych formularzy
469
Specjalne typy formularzy W środowisku Accessa słowo formularz, w zależności od kontekstu, może mieć różne znaczenia. W niniejszym punkcie zaprezentowano różne sposoby wykorzystywania formularzy w Accessie i przykłady użycia w każdym zastosowaniu. Formularze nawigacji W Accessie 2010 wprowadzono całkowicie nowy typ formularza, spełniający funkcję narzędzia nawigacyjnego dla użytkowników. Formularze nawigacji zawierają zbiór zakładek oferujących natychmiastowy dostęp do dowolnej liczby innych formularzy w układzie formularz/podformularz. Przycisk Nawigacja na wstążce daje dostęp do zbioru przycisków określających opcje rozmieszczenia zakładek (zobacz rysunek 17.6). Opcja domyślna to Karty poziome.
Rysunek 17.6. Przycisk Nawigacja daje dostęp do różnych opcji rozmieszczenia zakładek
Wybranie opcji rozmieszczenia zakładek z rozwijanej listy Nawigacja powoduje otwarcie nowego formularza nawigacji w widoku projektu (zobacz rysunek 17.7). Nowy formularz zawiera wiersz zakładek w górnej części okna oraz duży obszar pod nimi umożliwiający osadzanie podformularzy. Nazwę zakładki (np. Produkty) wpisuje się bezpośrednio na zakładce. Można też ją dodać za pomocą właściwości Tytuł. Po wprowadzeniu tytułu zakładki Access dodaje nową pustą zakładkę z prawej strony bieżącej zakładki. Na rysunku 17.7 wybrano opcję Karty poziome jako szablon formularza nawigacji i przypisano zakładce nazwę Produkty. W efekcie pojawiła się nowa zakładka Dodaj nowy. Alternatywy opcji Karty poziome (np. Karty pionowe, z lewej i Karty pionowe, z prawej) są widoczne na rysunku 17.6. Arkusz właściwości zakładki (zobacz rysunek 17.8) zawiera właściwość Nazwa elementu docelowego nawigacji. Służy ona do wskazania formularza Accessa, który będzie pełnił funkcję podformularza zakładki. Należy wybrać formularz z listy rozwijanej Nazwa elementu docelowego nawigacji, aby Access utworzył skojarzenie z podformularzem.
470
Część V Formularze i raporty Accessa
Rysunek 17.7. Formularz nawigacji zawiera duży obszar do osadzania podformularzy
Rysunek 17.8. Właściwość Nazwa elementu docelowego nawigacji służy do wskazywania podformularza powiązanego z zakładką
Rozdział 17. Tworzenie prostych formularzy
471
Kompletny formularz nawigacji pokazano na rysunku 17.9. Automatycznie wygenerowany formularz nawigacji zapewnia nowatorski sposób wykorzystania przestrzeni na ekranie. Można go ulepszyć, na przykład usuwając sekcję nagłówka, zmieniając nazwy pól albo zmniejszając puste miejsce otaczające podformularz. Formularz frmProducts pokazany na rysunku 17.9 jest dołączony do przykładowej bazy danych Rozdział17.accdb.
Rysunek 17.9. Formularz nawigacji to szybki i prosty sposób utworzenia mechanizmu do poruszania się po bazie danych
Formularze Wiele elementów Aby utworzyć formularz typu „wiele elementów” na podstawie tabeli lub kwerendy wybranej w okienku nawigacji, należy skorzystać z polecenia Wiele elementów dostępnego po kliknięciu przycisku Więcej formularzy z grupy Formularze na wstążce. Formularz w postaci tabelarycznej przypomina arkusz danych, choć jest znacznie bardziej atrakcyjny od prostego arkusza. Ponieważ formularz w postaci tabeli jest zwyczajnym formularzem Accessa, można przekształcić domyślne pola tekstowe w formularzu w pola kombi i inne zaawansowane formanty. Ze względu na to, że formularze „wiele elementów” wyświetlają jednocześnie wiele rekordów, są bardzo przydatne przy przeglądaniu bądź aktualizowaniu wielu rekordów jednocześnie. Aby utworzyć formularz „wiele elementów” na podstawie tabeli tblProducts, wykonaj następujące czynności: 1. Wybierz tabelę tblProducts w okienku nawigacji.
472
Część V Formularze i raporty Accessa
2. Kliknij zakładkę TWORZENIE na wstążce. 3. Kliknij przycisk Więcej formularzy, a następnie kliknij pozycję Wiele elementów. Access utworzy nowy formularz „wiele elementów” na podstawie tabeli tblProducts i wyświetli go w widoku układu (zobacz rysunek 17.10).
Rysunek 17.10. Aby przeglądać rekordy tak jak w arkuszu danych, można stworzyć formularz „wiele elementów”
Formularz dzielony Aby utworzyć formularz dzielony na podstawie tabeli lub kwerendy wybranej w okienku nawigacji, należy skorzystać z polecenia Formularz dzielony dostępnego po kliknięciu przycisku Więcej formularzy z grupy Formularze na wstążce. Formularz dzielony umożliwia użytkownikom przeglądanie danych w dwóch widokach jednocześnie. W dolnej części można wybrać rekord z arkusza danych i edytować informacje w formularzu wyświetlającym się w górnej części. Aby utworzyć formularz dzielony na podstawie tabeli tblCustomers, wykonaj następujące czynności: 1. Wybierz tabelę tblCustomers w okienku nawigacji. 2. Kliknij zakładkę TWORZENIE na wstążce. 3. Kliknij przycisk Więcej formularzy, a następnie kliknij pozycję Formularz dzielony. Access utworzy nowy formularz dzielony na podstawie tabeli tblCustomers i wyświetli go w widoku układu (zobacz rysunek 17.11). Aby dolna część formularza stała się całkowicie widoczna, można zmienić rozmiar formularza, a następnie skorzystać z paska podziału wyświetlającego się w środkowej części formularza.
Rozdział 17. Tworzenie prostych formularzy
473
Rysunek 17.11. Aby wybierać rekordy z listy i edytować w formularzu, należy utworzyć formularz dzielony. Pasek podziału służy do zmiany rozmiaru górnej i dolnej części formularza
Właściwość Orientacja arkusza dzielonego (dostępna w zakładce Format w Arkuszu właściwości) decyduje o tym, czy arkusz danych wyświetla się na górze, na dole, z lewej czy z prawej strony obszaru formularza. Ustawienie domyślne pokazano na rysunku 17.11 — arkusz danych wyświetla się u dołu. Formularz frmCustomers_SplitForm (zobacz rysunek 17.11) jest dołączony do przykładowej bazy danych Rozdział17.accdb. Formularze w postaci arkusza danych Aby utworzyć formularz typu „arkusz danych” na podstawie tabeli lub kwerendy wybranej w okienku nawigacji, należy skorzystać z polecenia Arkusz danych dostępnego po kliknięciu przycisku Więcej formularzy z grupy Formularze na wstążce. Formularz w postaci arkusza danych przydaje się w przypadku, gdy chcemy oglądać dane w formacie wierszy i kolumn, a jednocześnie ograniczyć listę pól wyświetlanych i udostępnionych do modyfikacji. Aby utworzyć formularz w postaci arkusza danych na podstawie tabeli tblProducts, wykonaj następujące czynności: 1. Wybierz tabelę tblProducts w okienku nawigacji. 2. Kliknij zakładkę TWORZENIE na wstążce. 3. Kliknij przycisk Więcej formularzy, a następnie kliknij pozycję Arkusz danych. W widoku formularza można przeglądać dowolny utworzony formularz. W tym celu należy wybrać polecenie Widok arkusza danych z rozwijanej listy Widok na wstążce. Formularz w postaci arkusza danych domyślnie otwiera się w widoku arkusza danych. W niektórych formularzach właściwość Allow Datasheet View ma domyślnie wartość Nie. Dla tych formularz lista rozwijana Widok nie zawiera opcji Widok arkusza danych. Więcej informacji na temat właściwości pól można znaleźć w punkcie „Właściwości” w dalszej części tego rozdziału.
474
Część V Formularze i raporty Accessa
Zmiana rozmiaru obszaru formularza Pole z siatką w formularzu to obszar, w którym pracujemy. Jest to rozmiar formularza w czasie, gdy jest on wyświetlany. Aby zmienić rozmiar pola z siatką formularza, należy umieścić kursor na dowolnej krawędzi obramowania formularza, a następnie przeciągnąć obramowanie tak, by formularz stał się większy bądź mniejszy. Pusty formularz w widoku projektu podczas zmiany jego rozmiaru pokazano na rysunku 17.12. Rysunek 17.12. Widok projektu pustego formularza. Aby zmienić rozmiar obszaru formularza, wystarczy przeciągnąć jego prawy dolny narożnik
Zapisywanie formularza W dowolnym momencie można zapisać formularz, klikając ikonę Zapisz na pasku narzędzi szybkiego dostępu. Kiedy pojawi się pytanie o nazwę formularza, należy wprowadzić opisową nazwę (np. frmProdukty, frmKlienci, frmListaProduktów). Jeśli formularzowi wcześniej nadano nazwę, to po kliknięciu przycisku Zapisz pytanie o nią nie wyświetli się ponownie. Podczas zamykania formularza Access zapyta o to, czy należy go zapisać. Jeśli nie zapisze się formularza, wszystkie zmiany wprowadzone od czasu otwarcia formularza (albo ostatniego kliknięcia ikony Zapisz) zostaną utracone. Podczas pracy z formularzem powinno się często go zapisywać, jeśli uzyskane wyniki są zadowalające. Jeśli zamierzasz wprowadzać wiele zmian w formularzu, możesz utworzyć jego kopię. Aby pracować z formularzem frmProdukty, można go skopiować i wkleić w okienku nawigacji oraz nadać mu nową nazwę, np. frmProduktyOryginał. Później, po wprowadzeniu i przetestowaniu zmian, można usunąć pierwotną kopię.
Rozdział 17. Tworzenie prostych formularzy
475
Formanty formularza Formanty i właściwości stanowią podstawę formularzy i raportów. Przed przystąpieniem do tworzenia własnych formularzy i raportów trzeba się zapoznać z najważniejszymi pojęciami związanymi z formantami i ich właściwościami. Choć rozdział ten jest poświęcony formularzom, łatwo się przekonać, że formularze i raporty mają wiele wspólnych cech, w tym formanty i sposób ich używania. Niemal wszystko, czego się dowiesz z tego rozdziału o formantach, przyda się później podczas tworzenia raportów.
Termin formant (inaczej kontrolka) ma w Accessie wiele definicji. Ogólnie rzecz biorąc, formantem jest dowolny obiekt w formularzu lub raporcie, np. etykieta lub pole tekstowe. Są to te same formanty, których używa się we wszystkich aplikacjach systemu Windows (takich jak Access czy Excel), w formularzach HTML i w takich językach programowania, jak .NET, Visual Basic, C++ lub C#. Choć każdy język lub produkt ma inny format pliku i inne właściwości, pole tekstowe w Accessie nie różni się niczym od pola tekstowego w innych programach przeznaczonych dla systemu Windows. Formanty służą do wprowadzania i wyświetlania danych. Formant może być związany z polem tabeli (wówczas wartość wprowadzona w formancie jest zapisywana w pewnym polu tabeli) albo niezwiązany (wyświetlany w formularzu, ale nie zapisywany po jego zamknięciu). Formantem może też być obiekt graficzny, taki jak linia lub prostokąt. Istnieją również formanty, które nie stanowią części Accessa i są pisane niezależnie — tzw. formanty ActiveX. Rozszerzają one podstawowy zbiór funkcji Accessa i są oferowane przez wielu niezależnych producentów. Niezależnie od tego, czy pracujesz z formularzem, czy z raportem, utworzenie formantu i korzystanie z niego wymaga zastosowania takiego samego procesu. W tym rozdziale opisano formanty w kontekście używania ich w formularzach
Typy formantów Formularze i raporty mogą zawierać wiele różnych typów formantów. Formanty można dodawać do formularzy, używając grupy Formanty z zakładki Projektowanie (zobacz rysunek 17.13). Naprowadzenie wskaźnika myszy nad formant powoduje wyświetlenie etykietki ekranowej z informacją o przeznaczeniu formularza.
Rysunek 17.13. Zakładka Projektowanie umożliwia dodawanie i modyfikowanie formantów w widoku projektu formularza
Dostępne formanty w zwięzły sposób opisano w tabeli 17.1.
476
Część V Formularze i raporty Accessa
Tabela 17.1. Formanty używane w formularzach Accessa Formant
Przeznaczenie
Pole tekstowe
Wyświetla dane, które użytkownik może modyfikować.
Etykieta
Wyświetla statyczny tekst, który zwykle się nie zmienia.
Przycisk
Nazywany także przyciskiem polecenia. Używa się go do uruchamiania makr lub kodu VBA.
Pole kombi
Rozwijana lista wartości. Pola kombi w górnej części zawierają pole tekstowe służące do wprowadzania wartości, których nie ma na liście rozwijanej.
Pole listy
Lista wartości zawsze wyświetlana w formularzu lub raporcie.
Podformularz/Podraport
Ten formant wyświetla inny formularz lub raport w głównym formularzu lub raporcie.
Linia
Graficzna linia o regulowanej grubości i kolorze, używana jako separator.
Prostokąt
Prostokąt o regulowanym rozmiarze i kolorze, pusty lub wypełniony, służący do grupowania powiązanych formantów.
Obraz
Wyświetla bitmapy. Zużywa mało zasobów.
Grupa opcji
Grupa opcji przechowuje wiele pól opcji, pól wyboru lub przycisków przełącznika.
Pole wyboru
Formant o dwóch stanach: w stanie włączonym wyświetlany jako kwadrat ze znacznikiem w środku, a w stanie wyłączonym — jako pusty kwadrat. Gdy stan nie został jeszcze określony, formant ma postać szarego kwadratu.
Pole opcji
Nazywane również przełącznikiem radiowym. Jest to pole w postaci kółka. Kiedy jest włączone, w środku wyświetla się kropka.
Przycisk przełącznika
Jest to przycisk o dwóch stanach: wciśnięty lub nie. Zwykle umieszcza się na nim obraz lub ikonę zamiast tekstu.
Formant karty
Ten formant może wyświetlać wiele stron z wykorzystaniem interfejsu przypominającego szafkę z aktami.
Strona
Kolejna strona w formularzu lub raporcie. Na stronie można umieścić dodatkowe formanty. Formularz może zawierać wiele stron.
Wykres
Wykres służy do wyświetlania danych w formacie graficznym.
Niezwiązana ramka obiektu
Ta ramka przechowuje obiekt OLE lub osadzony obraz niezwiązany z polem tabeli. Może wyświetlać wykresy, zdjęcia, pliki dźwiękowe i filmy.
Związana ramka obiektu
Ta ramka przechowuje obiekt OLE lub osadzony obraz związany z polem tabeli.
Podział strony
Zwykle używany w raportach — wskazuje fizyczny podział strony.
Hiperłącze
Formant, który tworzy łącze do strony WWW, obrazu, adresu e-mail lub programu.
Załącznik
Umożliwia zarządzanie załącznikami dla typu danych Załącznik. Pola typu Załącznik (zobacz rozdział 3.) służą do dołączania do tabel Accessa zewnętrznych plików (np. klipów dźwiękowych, filmowych lub dokumentów Worda).
Rozdział 17. Tworzenie prostych formularzy
477
Polecenie Użyj kreatorów formantów, które staje się dostępne po rozwinięciu grupy Formanty i kliknięciu przycisku Więcej opcji w prawym dolnym narożniku grupy, nie dodaje formantów do formularza, ale określa, czy podczas dodawania niektórych formantów należy automatycznie uruchomić kreator. Formanty Grupa opcji, Pole kombi, Pole listy, Podformularz/Podraport, Związana ramka obiektu i Niezwiązana ramka obiektu oraz Przycisk polecenia mają kreatory, które pomagają przy dodawania formantów. Polecenie Wstaw formant ActiveX (także umieszczone w prawym dolnym rogu grupy Formanty) wyświetla listę formantów ActiveX, które można dodać do Accessa. Istnieją trzy główne kategorie formantów: związane, niezwiązane i obliczeniowe.
Formanty związane — są to formanty połączone z polem źródła danych formularza. Kiedy wprowadzamy wartość do formantu związanego, Access automatycznie aktualizuje pole tabeli w bieżącym rekordzie. Można związać większość formantów, które umożliwiają wprowadzanie informacji. Formanty można wiązać z większością typów danych, w tym: Tekst, Data/Godzina, Liczba, Tak/Nie, Obiekt OLE i Nota.
Formanty niezwiązane — zachowują wprowadzoną wartość, ale nie aktualizują żadnych pól tabeli. Można ich używać do wyświetlania tekstu etykiet, do tworzenia obiektów takich jak linie i prostokąty albo do przechowywania niezwiązanych obiektów OLE (takich jak bitmapa z logo firmy), które nie są zapisane w tabeli, ale w samym formularzu. Bardzo często do pracy z danymi w niezwiązanych formantach używany jest kod VBA, który bezpośrednio aktualizuje źródła danych Accessa. W rozdziale 28. zamieszczono szczegółowe informacje dotyczące korzystania z języka VBA do wykonywania operacji na formularzach i formantach oraz pracy z niezwiązanymi danymi.
Formanty obliczeniowe — są oparte na wyrażeniach i wyświetlają wyniki funkcji lub obliczeń. Również są niezwiązane, ponieważ nie aktualizują pól tabeli. Przykładem formantu obliczeniowego może być =[CenaUmowna] – [Koszt]. Oblicza on wynik na podstawie danych z dwóch pól tabeli, aby wyświetlić go w formularzu, ale nie jest związany z żadnym polem tabeli. Wartość niezwiązanego formantu obliczeniowego można wykorzystać w innych formantach w formularzu. Można też używać takich wartości w wyrażeniach w innych formantach albo w kodzie VBA umieszczonym w module formularza.
Dodawanie formantów Istnieje wiele sposobów dodawania formantów do formularza:
Kliknij przycisk w grupie Formanty w zakładce PROJEKTOWANIE i przeciągnij nowy niezwiązany formant do formularza. Do powiązania nowego formantu z polem źródła danych formularza służy właściwość Źródło danych.
Przeciągnij pole z okna listy pól, aby dodać do formularza formant związany. Access automatycznie wybierze formant odpowiedni dla typu danych pola i zwiąże formant z wybranym polem.
478
Część V Formularze i raporty Accessa
Dwukrotnie kliknij pole na liście pól, aby dodać do formularza związany formant. Dwukrotne kliknięcie działa podobnie jak przeciągnięcie pola z listy pól do formularza. Jedyna różnica polega na tym, że w przypadku dodawania formantu poprzez dwukrotne kliknięcie pola Access decyduje o tym, w którym miejscu dodać do formularza nowy formant. Zazwyczaj nowy formant jest dodawany po prawej stronie ostatnio dodanego formantu, a czasami poniżej niego.
Kliknij pole na liście pól prawym przyciskiem myszy i wybierz opcję Dodaj pole do widoku. Spowoduje to umieszczenie formantu w tym samym miejscu co przy dwukrotnym kliknięciu wybranego pola.
Skopiuj istniejący formant i wklej go w innym miejscu na formularzu. Formanty można kopiować w standardowy sposób: za pomocą opcji Kopiuj z zakładki NARZĘDZIA GŁÓWNE, za pomocą opcji Kopiuj z menu otwieranego kliknięciem prawym przyciskiem myszy lub przy użyciu kombinacji klawiszy Ctrl + C. Wklejony formant jest związany z tym samym polem co pierwotny.
Używanie grupy Formanty Poprzez korzystanie z przycisków w grupie Formanty w celu dodawania formantów decydujemy o typie formantu używanego dla każdego z pól. Dodany formant jest niezwiązany (czyli nie jest powiązany z danymi w polu tabeli) i ma domyślną nazwę, np. Tekst21 lub Kombi11. Po utworzeniu formantu należy wybrać pole tabeli, z którym formant ma być związany, wprowadzić tekst etykiety oraz ustawić właściwości. Więcej informacji na temat ustawiania właściwości formularzy można znaleźć w dalszej części tego rozdziału. Za pomocą grupy Formanty można dodać tylko jeden formant za jednym razem. Aby utworzyć trzy różne niezwiązane formanty, wykonaj następujące czynności: 1. Otwórz wcześniej stworzony formularz w widoku projektu. Kliknij zakładkę PROJEKTOWANIE, a następnie przycisk Pole tekstowe (oznaczony ab|) w grupie Formanty. 2. Przenieś wskaźnik myszy do okna projektu formularza, a następnie kliknij i przeciągnij nowy formant w jego oryginalnym rozmiarze w docelowe położenie. 3. Kliknij Przycisk opcji w grupie Formanty. Kliknij myszą na formularzu i przeciągnij przycisk opcji do jego docelowego położenia. 4. Kliknij polecenie Pole wyboru w grupie Formanty i dodaj pole do formularza w analogiczny sposób, jak dodałeś pozostałe formanty. Po zakończeniu pracy ekran powinien wyglądać jak na rysunku 17.14. Kliknięcie w dowolnym miejscu formularza wyświetlającego się w widoku projektu przy zaznaczonym formancie powoduje utworzenie formantu o domyślnym rozmiarze. Aby dodać więcej niż jeden formant tego samego typu, należy kliknąć ikonę formantu w grupie Formanty prawym przyciskiem myszy i wybrać opcję Upuść wiele formantów, a następnie utworzyć w formularzu dowolną liczbę formantów. Aby odblokować formant i powrócić do normalnego działania, należy kliknąć formant selektora (strzałkę).
Rozdział 17. Tworzenie prostych formularzy
479
Rysunek 17.14. Niezwiązane formanty dodane za pomocą grupy Formanty
Aby usunąć linie siatki z obszaru formularza, otwórz formularz w widoku projektu, a następnie wybierz opcję Rozmiar/Odstęp/Siatka z grupy Zmienianie rozmiaru i porządkowanie w zakładce ROZMIESZCZANIE na wstążce. W większości rysunków w tym podrozdziale siatka jest ukryta, dzięki czemu krawędzie formantów są lepiej widoczne.
Korzystanie z narzędzia Lista pól W oknie Lista pól wyświetlają się pola z tabeli lub kwerendy będącej źródłem danych formularza. Aby otworzyć okno Lista pól, należy kliknąć polecenie Dodaj istniejące pola w grupie Narzędzia z zakładki PROJEKTOWANIE na wstążce (zobacz rysunek 17.13). Jeśli utworzyłeś formularz za pomocą techniki, która powoduje automatyczne powiązanie formularza z tabelą lub kwerendą, wyświetlana jest lista pól z danej tabeli lub kwerendy. Tu formularz utworzono za pomocą przycisku Pusty formularz. Technika ta nie powoduje automatycznego powiązania formularza ze źródłem danych. Wtedy na liście pól znajduje się tylko przycisk Pokaż wszystkie tabele. Kliknij go, aby wyświetlić listę tabel. Następnie kliknij znak plus obok tabeli tblProducts. Wyświetlą się pola z tej tabeli. Przeciągnij pole Model z listy pól i upuść je na formularzu, aby utworzyć format powiązany z polem Model tabeli tblProducts. Pola można zaznaczać i przeciągać pojedynczo. Można też zaznaczyć kilka pól naraz, używając klawiszy Ctrl i Shift.
W celu wybrania wielu sąsiadujących ze sobą pól przytrzymaj naciśnięty klawisz Shift i kliknij pierwsze i ostatnie spośród żądanych pól.
W celu wybrania wielu pól, które nie przylegają do siebie, przytrzymaj naciśnięty klawisz Ctrl i kliknij każde żądane pole.
Domyślnie okno Lista pól jest zadokowane po prawej stronie okna Accessa. Można je przesuwać i zmieniać jego rozmiar. Jeśli zawiera więcej pól, niż może się w nim zmieścić, wówczas wyświetla się pionowy pasek przewijania. Na rysunku 17.15 okno Lista pól jest oddokowane i znajduje się nad formularzem.
480
Część V Formularze i raporty Accessa
Rysunek 17.15. Aby wyświetlić okno Lista pól, należy kliknąć przycisk Dodaj istniejące pola w grupie Narzędzia
Ogólnie rzecz biorąc, przeciągnięcie pola z okna listy pól powoduje dodanie związanego pola tekstowego do okna projektu formularza. Przeciągnięcie pola typu Tak/Nie spowoduje dodanie pola wyboru. Można opcjonalnie określić typ formantu, wybierając go z przybornika i przeciągając do okna projektu formularza. W przypadku przeciągania pola z okna listy pól pierwszy formant jest umieszczany w miejscu, w którym zwolnimy przycisk myszy. Należy sprawdzić, czy po lewej stronie formantu jest miejsce na etykietę. Jeśli jest za mało miejsca, etykiety wsuwają się pod formanty.
Przeciąganie pól z okna listy pól ma kilka istotnych zalet:
Formant jest automatycznie wiązany z przeciągniętym polem.
Formant dziedziczy formaty określone na poziomie tabeli, tekst paska stanu oraz reguły i komunikaty sprawdzania poprawności danych.
Tworzony jest formant etykiety z nazwą pola.
Etykieta jest dołączana do pola, więc przesuwają się wspólnie.
Zaznacz i przeciągnij pola Description, Category, RetailPrice oraz Cost z okna Lista pól do formularza, tak jak pokazano na rysunku 17.16. Dwukrotne kliknięcie pola również dodaje je do formularza. W oknie projektu formularza widać cztery nowe formanty — każdy składa się z formantu etykiety i formantu pola tekstowego (Access automatycznie dołącza formant etykiety do formantu pola tekstowego). Można pracować z całą grupą tych formantów jednocześnie albo z każdym formantem niezależnie: zaznaczać je, przenosić, zmieniać ich rozmiar lub je usuwać. Zauważmy, że każdy formant ma etykietę z podpisem odpowiadającym nazwie kolumny tabeli, a w polu tekstowym wyświetla się nazwa związanego pola tabeli.
Rozdział 17. Tworzenie prostych formularzy
481
Rysunek 17.16. Przeciągnięcie pól z okna Lista pól powoduje dodanie do formularza związanych formantów
Aby zmienić rozmiar pola tekstowego, ale nie etykiety, należy pracować oddzielnie z każdym z tych formantów. Więcej o manipulowaniu etykietami powiązanymi z formantami dowiesz się z dalszej części rozdziału. Aby zamknąć okno Lista pól, należy kliknąć polecenie Dodaj istniejące pola w grupie Narzędzia na wstążce lub przycisk Zamknij w oknie Lista pól. W Accessie można zmienić typ formantu po jego utworzeniu, a następnie ustawić wszystkie właściwości formantu. Przypuśćmy, że po dodaniu pola tabeli jako pola tekstowego chcemy zmienić go na formant pola listy. Aby to zrobić, można kliknąć formant prawym przyciskiem myszy, a potem z menu podręcznego wybrać polecenie Zmień na. Istnieją jednak pewne ograniczenia co do zmiany typu formantu. Każdy formant można zmienić na pole tekstowe. Pola opcji, przyciski przełącznika i pola wyboru są zamienne, podobnie jak pola listy i pola kombi.
W punkcie „Właściwości” w dalszej części tego rozdziału wyjaśniono, jak zmieniać nazwy formantów, podpisy oraz inne właściwości. Korzystanie z właściwości przyspiesza nadawanie nazw formantom i wiązanie ich z polami tabeli. Aby zobaczyć różnice między formantami związanymi i niezwiązanymi, wystarczy wyświetlić formularz w widoku formularza za pomocą polecenia Widok z grupy Widoki na wstążce. W formantach Description, Category, RetailPrice i Cost wyświetlają się dane, ponieważ pola te są związane z tabelą tblProducts. Pozostałe trzy formanty niczego nie wyświetlają, gdyż nie są związane z żadnym źródłem danych. W miarę dodawania formantów z okna Lista pól Access buduje właściwość Źródło rekordów formularza jako instrukcję SQL-a. Właściwość Źródło rekordów po dodaniu powyższych czterech pól ma następującą postać: SELECT tblProducts.Model, tblProducts.Description, tblProducts.Category, tblProducts.RetailPrice, tblProducts.Cost FROM tblProducts;
482
Część V Formularze i raporty Accessa Gdyby formularz od początku był związany z tabelą lub kwerendą, do właściwości Źródło rekordów przypisana byłaby tabela lub kwerenda. Nie zmieniłoby się to po dodaniu lub usunięciu pól.
Zaznaczanie i anulowanie zaznaczenia formantów Kiedy umieści się formant w formularzu, można zmieniać jego rozmiar, przesuwać go lub kopiować. Najpierw trzeba zaznaczyć jeden lub więcej formantów. W zależności od rozmiaru formant może mieć od czterech do ośmiu uchwytów (małych kwadratów nazywanych uchwytami przenoszenia i zmiany rozmiaru) — w rogach i na środku krawędzi boków. Uchwyt w lewym górnym rogu jest większy od pozostałych i służy do przenoszenia formantu, a pozostałych uchwytów używa się do zmiany rozmiaru. Zaznaczone formanty oraz ich uchwyty przenoszenia i zmiany rozmiaru przedstawiono na rysunku 17.17. Rysunek 17.17. Zaznaczanie formantów oraz uchwyty przenoszenia i zmiany rozmiaru
Aby można było zaznaczać formanty, należy włączyć polecenie Zaznacz (oznaczone ikoną strzałki) z grupy Formanty. Kiedy dodajemy formanty za pomocą grupy Formanty, Access automatycznie wybiera to narzędzie. Zaznaczanie jednego formantu Aby zaznaczyć jeden formant, wystarczy kliknąć dowolny punkt formantu. Po kliknięciu formantu wyświetlają się wszystkie jego uchwyty. Jeśli do formantu dołączona jest etykieta, w jego lewym górnym rogu ukazuje się również uchwyt przenoszenia etykiety. W przypadku zaznaczenia etykiety dołączonej do innego formantu zostaną wyświetlone wszystkie uchwyty formantu etykiety, a spośród uchwytów dołączonego formantu wyświetli się tylko uchwyt przenoszenia.
Rozdział 17. Tworzenie prostych formularzy
483
Zaznaczanie wielu formantów Istnieją następujące sposoby zaznaczania wielu formantów:
kliknięcie każdego żądanego formantu z przytrzymanym wciśniętym klawiszem Shift;
przeciągnięcie wskaźnika przez środek lub wokół formantów, które chcemy zaznaczyć;
kliknięcie i przeciągnięcie na linijce w celu zaznaczenia grupy formantów.
Na rysunku 7.17 pokazano efekt graficzny zaznaczenia wielu związanych formantów. Podczas zaznaczania formantów przez przeciąganie myszy wyświetla się prostokąt. Należy uważać, aby zaznaczyć tylko te formanty, które rzeczywiście chcemy zaznaczyć. Każdy obiekt, który dotyka linii lub otoczony jest przez prostokąt, zostanie zaznaczony. Aby zaznaczyć tylko etykiety, należy zadbać o to, aby prostokąt zaznaczania obejmował wyłącznie etykiety. Jeśli się okaże, że formanty nie są zaznaczane, kiedy prostokąt przechodzi przez ich środek, prawdopodobnie globalna opcja Zachowanie podczas zaznaczania jest ustawiona na W pełni objęte. Oznacza to, że formant jest zaznaczany tylko wtedy, gdy zostanie całkowicie otoczony przez prostokąt. Aby zmienić tę opcję, należy kliknąć Plik/Opcje. Następnie w oknie Opcje programu Access należy wybrać polecenie Projektanci obiektu i ustawić opcję Zachowanie podczas zaznaczania na wartość Częściowo objęte. Przytrzymując wciśnięty klawisz Shift lub Ctrl, można zaznaczyć kilka formantów, które nie przylegają do siebie. W ten sposób można zaznaczyć formanty znajdujące się w zupełnie różnych częściach ekranu. Aby zaznaczyć wszystkie formanty w formularzu, należy kliknąć formularz w widoku projektu, a następnie wcisnąć klawisze Ctrl+A. Aby anulować zaznaczenie formantu, należy wcisnąć Shift lub Ctrl, a następnie kliknąć dowolny z zaznaczonych formantów.
Anulowanie zaznaczenia formantów Aby anulować zaznaczenie formantu, należy kliknąć niezaznaczony obszar formularza, na którym nie ma formantów. Kiedy się to zrobi, z zaznaczonych formantów znikną uchwyty. Aby anulować zaznaczenia formantu, można także zaznaczyć inny formant.
Wykonywanie operacji na formantach Tworzenie formularza to proces składający się z wielu etapów. Następnym omawianym zadaniem będzie nadanie formantom odpowiedniego rozmiaru i umieszczenie ich we właściwym miejscu. Zakładka Rozmieszczanie (zobacz rysunek 17.18) zawiera polecenia, które mogą pomóc w wykonywaniu operacji na formantach.
Rysunek 17.18. Zakładka Rozmieszczanie umożliwia przesuwanie i zmianę rozmiaru formantów, a także zarządzanie ogólnym układem formularza
484
Część V Formularze i raporty Accessa
Zmiana rozmiaru formantu Zmieniać rozmiar formantu można za pomocą dowolnego spośród mniejszych uchwytów formantu rozmieszczonych na górnej, dolnej i prawej krawędzi formantu. Uchwyty w rogach formantu pozwalają zwiększać lub zmniejszać rozmiar obiektu w poziomie i w pionie jednocześnie. Uchwyty na krawędziach zaś pozwalają zwiększać lub zmniejszać formant tylko w jednym kierunku. Uchwyty położone na górnym i dolnym boku służą do regulowania wysokości formantu, a uchwyty na lewym i prawym boku — do regulowania szerokości. Kiedy wskaźnik myszy znajdzie się nad narożnym uchwytem zaznaczonego formantu, zmienia się w ukośną strzałkę z dwoma grotami. Należy kliknąć i przeciągnąć uchwyt zmiany rozmiaru, aż formant przybierze żądany rozmiar. Kiedy wskaźnik myszy znajdzie się nad bocznym uchwytem zaznaczonego formantu, zmienia się w poziomą lub pionową strzałkę z dwoma grotami. Na rysunku 17.19 pokazano formant Description po zmianie jego rozmiaru. Zwróć uwagę na strzałkę z dwoma grotami w rogu formantu Description. Rysunek 17.19. Zmiana rozmiaru formantu
Aby precyzyjnie wyregulować rozmiar formantu, należy przytrzymać wciśnięty klawisz Shift i naciskać klawisze strzałek (w górę, w dół, w lewo i w prawo). Metoda ta działa także w przypadku zaznaczenia wielu formantów. Rozmiar formantu zmienia się wówczas tylko o jeden piksel (a jeśli w grupie Sterowanie układem zaznaczono opcję Przyciągaj do siatki, krawędź formantu przesuwa do najbliższej linii siatki).
Jeśli użytkownik kliknie dwukrotnie jeden z uchwytów zmiany rozmiaru, Access zwykle zmienia rozmiar formantu tak, aby jak najlepiej dopasować go do rozmiaru tekstu. Przydaje się to zwłaszcza wtedy, gdy podczas modyfikacji rozmiaru czcionki zauważysz, że tekst jest obcięty z dołu albo z prawej strony. W przypadku etykiet rozmiar jest regulowany w poziomie i w pionie, natomiast w przypadku pól tekstowych — tylko w pionie. Dzieje się tak dlatego, że w trybie projektu Access nie może przewidzieć szerokości pola tekstowego — nazwa pola i jego zawartość mogą znacznie się różnić. Zdarza się, że rozmiar etykiet nie zostanie poprawnie ustawiony i trzeba go wyregulować ręcznie.
Rozdział 17. Tworzenie prostych formularzy
485
Automatyczna zmiana rozmiaru formantów Lista rozwijana Rozmiar/odstęp w grupie Zmienianie rozmiaru i porządkowanie w zakładce ROZMIESZCZANIE ma kilka opcji, które pomagają wyregulować rozmieszczenie formantu:
Dopasuj — dopasowuje wysokość i szerokość formantu do czcionki zawartego w nim tekstu.
Do najwyższego — nadaje wszystkim zaznaczonym formantom wysokość najwyższego zaznaczonego formantu.
Do najniższego — nadaje wszystkim zaznaczonym formantom wysokość najniższego zaznaczonego formantu.
Według siatki — przemieszcza wszystkie boki zaznaczonych formantów do wewnątrz lub na zewnątrz, aby dopasować je do najbliższych punktów na siatce.
Do najszerszego — nadaje wszystkim zaznaczonym formantom szerokość najszerszego zaznaczonego formantu.
Do najwęższego — nadaje wszystkim zaznaczonym formantom szerokość najwęższego zaznaczonego formantu. Dostęp do wielu poleceń można uzyskać, klikając prawy przycisk myszy po zaznaczeniu wielu formantów. Po kliknięciu prawym przyciskiem myszy wielu zaznaczonych formantów wyświetla się menu podręczne, w którym znajdują się polecenia wyrównywania i zmiany rozmiaru formantów.
Przenoszenie formantu Po zaznaczeniu formantu można go przesuwać, używając dowolnej z następujących metod:
Kliknij formant i przytrzymaj przycisk myszy. Kursor zmieni się w strzałkę o czterech kierunkach. Przeciągnij myszą, aby przenieść formant do nowego położenia.
Kliknij jednokrotnie, aby zaznaczyć formant, i naprowadź kursor myszy nad dowolną z podświetlonych krawędzi. Kursor zmieni się w strzałkę skierowaną w cztery strony. Przeciągnij myszą, aby przenieść formant do nowego położenia.
Zaznacz formant i za pomocą klawiszy strzałek na klawiaturze przesuń formant. W przypadku wykorzystania tej techniki formant przesuwa się tylko o jeden piksel (lub przemieszcza się do najbliższej linii siatki, jeśli zaznaczono opcję Przyciągaj do linii siatki w grupie Sterowanie układem w zakładce ROZMIESZCZANIE).
Na rysunku 17.20 pokazano etykietę, którą niezależnie przesunięto ponad formant pola tekstowego. Aby anulować operację przesuwania bądź zmiany rozmiaru, należy wcisnąć Esc przed zwolnieniem przycisku myszy. Po zakończeniu operacji przesuwania (lub zmiany rozmiaru) można cofnąć zmiany poprzez kliknięcie przycisku Cofnij na pasku narzędzi szybkiego dostępu.
486
Część V Formularze i raporty Accessa
Rysunek 17.20. Przesuwanie formantu
Wyrównywanie formantów Czasem trzeba przenieść kilka formantów tak, aby były wyrównane. W grupie Zmienianie rozmiaru i porządkowanie na zakładce ROZMIESZCZANIE znajduje się kilka opcji opisanych na poniższej liście:
Według siatki — przenosi lewe górne rogi zaznaczonych formantów do najbliższych punktów siatki.
Do lewej — wyrównuje lewe krawędzie zaznaczonych formantów ze skrajnym lewym zaznaczonym formantem.
Do prawej — wyrównuje prawe krawędzie zaznaczonych formantów ze skrajnym prawym zaznaczonym formantem.
Do góry — wyrównuje górne krawędzie zaznaczonych formantów ze skrajnym górnym zaznaczonym formantem.
Do dołu — wyrównuje dolne krawędzie zaznaczonych formantów ze skrajnym dolnym zaznaczonym formantem.
Za pomocą polecenia wyrównania można wyrównać dowolnie wiele formantów. Po wybraniu jednej z opcji Access wybiera formant najbardziej zbliżony do żądanego ustawienia jako model wyrównania. Przypuśćmy, że masz trzy formanty i chcesz wyrównać je do lewej. Zostaną one wyrównane według formantu, który jest wysunięty najdalej w lewo spośród trzech zaznaczonych. Na rysunku 17.21 pokazano kilka zbiorów formantów: pierwszy jest niewyrównany, etykiety w drugim zostały wyrównane do lewej, natomiast pola tekstowe w trzecim zostały wyrównane do prawej.
Rozdział 17. Tworzenie prostych formularzy
487
Rysunek 17.21. Przykład niewyrównanych i wyrównanych formantów na siatce
Każde wyrównanie trzeba przeprowadzić oddzielnie. W tym przykładzie można wyrównać do lewej wszystkie etykiety albo wyrównać do prawej wszystkie pola tekstowe. Domyślnie Access wyświetla serię niewielkich kropek na całej powierzchni formularza w widoku projektu. Siatka pomaga w wyrównywaniu formantów. Aby wyświetlić (bądź ukryć) siatkę, należy wybrać polecenie Siatka z listy wyboru Rozmiar/odstęp grupy Zmienianie rozmiaru i porządkowanie w zakładce ROZMIESZCZANIE. Można również ukryć bądź wyświetlić linijkę za pomocą polecenia Linijka z tej samej listy. Gdy włączona jest opcja Przyciągaj do siatki z listy Rozmiar/odstęp, a użytkownik rysuje formant lub umieszcza go na formularzu, Access wyrównuje formant względem siatki. Powoduje to także wyrównanie istniejących formantów do siatki w momencie ich przesuwania bądź zmieniania rozmiaru. W czasie przenoszenia lub zmiany rozmiaru istniejących formantów Access pozwala przesuwać je tylko od punktu do punktu siatki. Jeśli wyłączono opcję Przyciągaj do siatki, Access zignoruje siatkę i pozwoli umieścić formant w dowolnym punkcie formularza lub raportu. Można tymczasowo wyłączyć przyciąganie do siatki, naciskając klawisz Ctrl przed utworzeniem formantu (albo podczas jego tworzenia lub przenoszenia). Można również zmienić rozdzielczość siatki (liczbę kropek) w danym formularzu za pomocą właściwości Siatka X i Siatka Y (większe liczby oznaczają większą rozdzielczość). Więcej informacji na temat właściwości formularzy można znaleźć w rozdziale 18.
Grupa Zmienianie rozmiaru i porządkowanie z zakładki ROZMIESZCZANIE zawiera polecenia służące do zarządzania odstępami między wieloma formantami. Polecenia te zmieniają odstęp między formantami według odstępu między pierwszymi dwoma zaznaczonymi formantami. Jeśli formanty są ułożone w poprzek ekranu, należy skorzystać z poleceń dotyczących odstępów w poziomie. Jeśli są ułożone od góry do dołu, należy posłużyć się poleceniami dotyczącymi odstępów w pionie. Dostępne są następujące polecenia:
Równo w poziomie — powoduje zastosowanie równych odstępów w poziomie między zaznaczonymi formantami. Aby można było skorzystać z tego polecenia, należy zaznaczyć trzy lub większą liczbę formantów.
Zwiększ w poziomie — zwiększa poziome odstępy między zaznaczonymi formantami o jedną jednostkę siatki.
488
Część V Formularze i raporty Accessa
Zmniejsz w poziomie — zmniejsza poziome odstępy między zaznaczonymi formantami o jedną jednostkę siatki.
Równo w pionie — powoduje zastosowanie równych odstępów w pionie między zaznaczonymi formantami. Aby można było skorzystać z tego polecenia, należy zaznaczyć trzy lub większą liczbę formantów.
Zwiększ w pionie — zwiększa pionowe odstępy między zaznaczonymi formantami o jedną jednostkę siatki.
Zmniejsz w pionie — zmniejsza pionowe odstępy między zaznaczonymi formantami o jedną jednostkę siatki. Wyrównywanie formantów powoduje tylko wyrównanie pól formantów. Aby wyrównać sam tekst (co określa się mianem justowania), należy użyć grupy Czcionka z zakładki FORMATOWANIE i kliknąć ikonę Wyrównaj tekst do lewej, Do środka w poziomie lub Wyrównaj tekst do prawej.
Modyfikowanie wyglądu formantu Aby zmodyfikować wygląd formantu, należy go zaznaczyć i kliknąć polecenia, które go modyfikują, np. z grupy Czcionka lub Formanty. Aby zmienić kolor tekstu i czcionkę etykiety Opis, wykonaj następujące czynności: 1. Kliknij etykietę Opis na formularzu. 2. W grupie Czcionka z zakładki FORMATOWANIE zmień rozmiar czcionki na 14. Kliknij polecenie Pogrubienie i zmień kolor czcionki na niebieski. 3. Zmień rozmiar etykiety Opis tak, aby zmieścił się na niej tekst pisany większą czcionką. Należy pamiętać, że dwukrotne kliknięcie dowolnego z uchwytów zmiany rozmiaru powoduje automatyczną zmianę rozmiaru etykiety. Aby zmodyfikować wygląd wielu formantów naraz, należy je zaznaczyć, a następnie kliknąć odpowiednie polecenia, np. z grupy Czcionka lub Formanty. Aby zmienić kolor tekstu i czcionkę etykiet Opis, Kategoria i Koszt wraz z ich polami tekstowymi, wykonaj następujące czynności: 1. Zaznacz trzy etykiety i trzy pola tekstowe poprzez przeciągnięcie przez nie ramki zaznaczenia (zobacz rysunek 17.11). 2. W grupie Czcionka z zakładki FORMATOWANIE zmień rozmiar czcionki na 14. Kliknij polecenie Pogrubienie i zmień kolor czcionki na niebieski. 3. Zmień rozmiar etykiet i pól tekstowych tak, aby zmieścił się na nich tekst pisany większą czcionką. Należy pamiętać, że dwukrotne kliknięcie dowolnego z uchwytów zmiany rozmiaru powoduje automatyczną zmianę rozmiaru etykiety. Każde kliknięcie polecenia powoduje zmianę wyglądu formantów zgodnie z wybranymi ustawieniami (zobacz rysunek 17.22). Czcionki poszczególnych formantów powiększają się, stają się pogrubione i zmieniają kolor na niebieski. Wszystkie wprowadzone zmiany dotyczą wszystkich zaznaczonych formantów.
Rozdział 17. Tworzenie prostych formularzy
489
Rysunek 17.22. Jednoczesna zmiana wyglądu kilku formantów
Jeśli zaznaczono wiele formantów, można je również razem przesuwać. Kiedy kursor zmieni się w strzałkę o czterech kierunkach, należy kliknąć i przeciągnąć wybrane formanty. Można też zmienić rozmiar wszystkich formantów jednocześnie — poprzez zmianę rozmiaru jednego z zaznaczonych formantów. Wszystkie zaznaczone formanty zwiększą bądź zmniejszą się o tę samą liczbę jednostek. Grupowanie formantów W przypadku częstego zmieniania właściwości wielu formantów warto je pogrupować. Aby to zrobić, należy zaznaczyć formanty poprzez przytrzymanie klawisza Shift, a następnie klikanie ich bądź przeciąganie ramki zaznaczenia. Po zaznaczeniu żądanych formantów należy wybrać polecenie Grupuj z grupy Rozmiar/odstęp z zakładki ROZMIESZCZANIE. Pogrupowane formanty pokazano na rysunku 17.23. Aby zaznaczyć tylko jeden formant, należy go kliknąć dwukrotnie. Po zaznaczeniu pojedynczego formantu w grupie kliknięcie dowolnego innego powoduje jego zaznaczenie. Aby zmienić rozmiar całej grupy, należy umieścić wskaźnik myszy na krawędzi, którą chcemy zmodyfikować. Kiedy wyświetli się strzałka skierowana w dwie strony, należy kliknąć myszą i przeciągnąć krawędź na żądaną pozycję. Zmiana rozmiaru będzie dotyczyć wszystkich formantów z grupy. Aby przesunąć całą grupę, należy ją kliknąć i przeciągnąć do nowego położenia. Dzięki pogrupowaniu formantów nie trzeba zaznaczać ich wszystkich za każdym razem, kiedy trzeba coś w nich zmienić. Aby usunąć grupę, należy ją zaznaczyć poprzez kliknięcie dowolnego pola wewnątrz niej, a następnie wybrać polecenie Rozgrupuj z grupy Sterowanie układem z zakładki ROZMIESZCZANIE. Zmiana typu formantu Choć pola tekstowe nadają się do prezentowania danych logicznych (Tak/Nie), istnieją inne sposoby wyświetlania tego rodzaju opcji. Jednym z nich jest użycie przycisku przełącznika, co pokazano na rysunku 17.24. Przycisk nie jest wciśnięty, jeśli ma wartość True, natomiast jest wciśnięty, jeśli ma wartość False.
490
Część V Formularze i raporty Accessa
Rysunek 17.23. Grupowanie formantów
Rysunek 17.24. Przekształcanie pola wyboru w przycisk przełącznika
Aby zmienić pole wyboru w przycisk przełącznika, wykonaj poniższe czynności: 1. Zaznacz etykietę Przedtem (tylko etykietę, nie pole wyboru). 2. Naciśnij klawisz Delete, aby usunąć etykietę, ponieważ nie będzie już potrzebna. 3. Kliknij prawym przyciskiem myszy pole wyboru Przedtem i z menu podręcznego wybierz polecenie Zmień na/Przycisk przełącznika.
Rozdział 17. Tworzenie prostych formularzy
491
4. Zmień rozmiar przycisku przełącznika i kliknij wewnątrz niego tak, aby kursor zaczął migać. Następnie wpisz Potem jako podpis przycisku (widoczny z prawej strony na rysunku 7.24). Kopiowanie formantu Aby utworzyć kopię dowolnego formantu, można utworzyć jego duplikat albo skopiować do schowka i wkleić kopię w odpowiednich miejscach. W przypadku formantu, w którym ustawiono wiele właściwości albo któremu nadano określony format, można skopiować go i poprawić tylko niektóre właściwości (np. nazwę formantu i nazwę związanego pola). Przydaje się to w formularzach składających się z wielu stron, kiedy chcemy wyświetlać te same wartości na różnych stronach i w różnych miejscach, albo podczas kopiowania formantów z jednego formularza do innego. Usuwanie formantu Aby usunąć formant, należy zaznaczyć go w widoku projektu formularza, a następnie wcisnąć klawisz Delete na klawiaturze. Formant i związane z nim etykiety znikną z formularza. Aby pojawiły się na nim z powrotem, należy kliknąć przycisk Cofnij na pasku narzędzi szybkiego dostępu. Aby usunąć formanty, można również wybrać polecenie Wytnij z grupy Schowek lub Usuń z grupy Rekordy z zakładki NARZĘDZIA GŁÓWNE. Aby usunąć więcej niż jeden formant, należy zaznaczyć kilka formantów i wcisnąć klawisz Delete. Można usunąć całą grupę formantów, zaznaczając grupę i naciskając klawisz Delete. Jeśli do formantu dołączono etykietę, można usunąć samą etykietę, klikając ją i używając jednej z metod usuwania formantów. Jeśli zaznaczysz formant, usuniesz go wraz z etykietą. Aby usunąć samą etykietę formantu Description, wykonaj poniższe czynności (zakładamy, że w oknie projektu formularza wyświetla się formant pola tekstowego Description): 1. Zaznacz samą etykietę pola Description. 2. Wciśnij Delete, aby usunąć etykietę z formularza. Dołączanie (lub ponowne dołączanie) etykiety do formantu Jeśli przypadkiem usuniemy etykietę formantu, możemy dołączyć ją ponownie. Aby utworzyć etykietę i dołączyć ją do formantu, wykonaj czynności wyszczególnione poniżej. W dalszej części tego rozdziału, w punkcie „Nadawanie nazw i tytułów formantom”, poznasz specjalne relacje zachodzące między formantami a dołączonymi do nich etykietami. Domyślnie, w momencie dodawania do formularza, formanty Accessa mają etykiety. Etykiety te są przemieszczane wraz z formantami podczas przemieszczania formantu po formularzu. W punkcie „Nadawanie nazw i tytułów formantom” opisano te zachowania oraz sposoby postępowania z etykietami formantów. 1. Kliknij przycisk Etykieta w grupie Formanty. 2. Umieść wskaźnik myszy w oknie projektu formularza. Wskaźnik zmieni się w ikonę pola tekstowego. 3. Kliknij miejsce, w którym ma się zaczynać etykieta, i przytrzymaj wciśnięty przycisk myszy. Przeciągnij myszą, aby określić rozmiar etykiety.
492
Część V Formularze i raporty Accessa
4. Wpisz Opis: i kliknij gdzieś poza etykietą. 5. Zaznacz etykietę Opis. 6. Wybierz polecenie Wytnij w grupie Schowek z zakładki NARZĘDZIA GŁÓWNE. 7. Zaznacz pole tekstowe Opis. 8. Wybierz polecenie Wklej w grupie Schowek z zakładki NARZĘDZIA GŁÓWNE, aby dołączyć etykietę do pola tekstowego. Innym sposobem dołączenia etykiety do formantu jest kliknięcie ikony informacyjnej obok etykiety (zobacz rysunek 17.25). Ikona ta informuje o tym, że etykieta nie jest związana z żadnym formantem. Należy kliknąć polecenie Skojarz etykietę z formantem z menu podręcznego, a następnie wybrać formant, z którym chcemy powiązać etykietę. Rysunek 17.25. Kojarzenie etykiety z formantem
Właściwości Właściwości to nazwane atrybuty formantów, pól lub obiektów bazy danych, które służą do modyfikowania cech formantu, pola lub obiektu. Przykładami takich cech są: rozmiar, kolor, wygląd lub nazwa obiektu. Właściwość może też sterować działaniem formantu, na przykład określać, czy formant jest przeznaczony tylko do odczytu, czy jest edytowalny, albo czy jest widoczny, czy też niewidoczny. Właściwości używa się często w formularzach i raportach w celu zmodyfikowania charakterystyki formantu. Każdy formant w formularzu ma swoje właściwości. Ma je również sam formularz, mają je też jego poszczególne sekcje. To samo dotyczy raportów: właściwości ma raport, każda sekcja raportu, a także poszczególne formanty. Właściwości ma również formant etykiety, nawet jeśli jest dołączony do innego formantu. Wszystkie operacje dostępne za pomocą poleceń na wstążce, począwszy od przemieszczania i zmiany rozmiaru formantów, a skończywszy na zmianie czcionek i kolorów, można zrealizować poprzez ustawienie właściwości. W rzeczywistości wszystkie te polecenia powodują modyfikowanie właściwości zaznaczonych formantów.
Rozdział 17. Tworzenie prostych formularzy
493
Wyświetlanie arkusza właściwości Właściwości są wyświetlane na arkuszu właściwości (nazywanym również oknem właściwości). Aby wyświetlić arkusz właściwości pola tekstowego Description, wykonaj poniższe czynności: 1. Przeciągnij pola Description, Category, RetailPrice i Cost z okna listy pól do okna projektu formularza. 2. Kliknij pole tekstowe Description, aby je zaznaczyć. 3. Aby wyświetlić arkusz właściwości, kliknij polecenie Arkusz właściwości z grupy Narzędzia w zakładce PROJEKTOWANIE albo wciśnij F4. Ekran powinien wyglądać tak, jak pokazano na rysunku 17.26, gdzie zaznaczono pole tekstowe Description. Zakładka Format w arkuszu właściwości została przewinięta w celu odnalezienia właściwości marginesów pola tekstowego. Rysunek 17.26. Zmiana właściwości obiektu za pomocą arkusza właściwości
Ponieważ arkusz właściwości jest oknem, można go oddokować, przesuwać i zmieniać jego rozmiar. Okno nie zawiera jednak przycisków Maksymalizacji i Minimalizacji. Aby ponownie zadokować w poprzedniej lokalizacji oddokowany arkusz właściwości, kliknij dwukrotnie pasek tytułu tego arkusza.
Jeśli arkusz właściwości formantu nie jest widoczny, można go wyświetlić kilkoma sposobami:
Zaznacz formant i kliknij polecenie Arkusz właściwości z grupy Narzędzia w zakładce PROJEKTOWANIE.
Kliknij dwukrotnie krawędź dowolnego formantu.
494
Część V Formularze i raporty Accessa
Kliknij formant prawym przyciskiem myszy i wybierz z menu podręcznego polecenie Właściwości.
Zaznacz formant, a następnie wciśnij klawisz F4.
Korzystanie z arkusza właściwości Po wyświetleniu arkusza właściwości kliknięcie dowolnego formantu w widoku projektu powoduje wyświetlenie właściwości tego formantu. Jeśli zaznaczymy więcej niż jeden formant, wyświetlą się podobne właściwości dla wybranych formantów. Pionowy pasek przewijania umożliwia poruszanie się pomiędzy różnymi właściwościami. Arkusz właściwości zawiera kartę Wszystkie, na której wyświetlają się wszystkie właściwości formantu. Można wybrać inną kartę, aby ograniczyć widok do określonej grupy właściwości. Oto poszczególne karty i grupy właściwości:
Format — te właściwości określają wygląd etykiety lub wartości: czcionkę, rozmiar, kolor, efekty specjalne, obramowanie i paski przewijania.
Dane — te właściwości mają wpływ na sposób wyświetlania wartości i określają powiązane źródło danych: źródło formantu, maski wprowadzania, reguły sprawdzania poprawności, wartość domyślną i inne właściwości dotyczące typu danych.
Zdarzenie — właściwości zdarzeniowe to nazwane zdarzenia, takie jak kliknięcie przycisku myszy, dodanie rekordu, naciśnięcie klawisza, któremu można przypisać reakcję (np. wywołanie makra lub procedury VBA), itp.
Inne — te właściwości określają dodatkowe atrybuty formantu, np. nazwę formantu albo opis wyświetlany na pasku stanu. Liczba właściwości dostępnych w nowym Accessie jest znacznie większa niż w jego starszych wersjach. Najważniejsze nowe właściwości są opisane w różnych rozdziałach tej książki. Omówienie właściwości i procedur zdarzeniowych można znaleźć w rozdziale 25.
Na rysunku 17.26 pokazano arkusz właściwości pola tekstowego Description. W pierwszej kolumnie wyświetlają się nazwy właściwości, w drugiej zaś można wprowadzić lub wybrać ustawienia właściwości lub inne opcje. Za pomocą pola kombi (na rysunku 17.26 znajduje się w nim napis Description) widocznego przy górnej krawędzi arkusza właściwości można wybrać formant, którego właściwości są wyświetlane. Pole to pozwala też wybrać inne obiekty z formularza, np. sekcję Detail, sekcję FormHeader, a nawet sam formularz.
Zmiana ustawień właściwości formantu Istnieje wiele metod zmieniania ustawień właściwości, w tym:
Wpisywanie lub wybieranie żądanej wartości w oknie właściwości.
W przypadku niektórych właściwości dwukrotne kliknięcie ich nazwy w arkuszu właściwości powoduje cykliczne podstawianie dozwolonych wartości.
Bezpośrednia zmiana właściwości przez modyfikowanie samego formantu, np. zmiana jego rozmiaru.
Rozdział 17. Tworzenie prostych formularzy
495
Używanie właściwości odziedziczonych po związanym polu albo domyślnych właściwości formantu.
Zmiana koloru formantu za pomocą poleceń dostępnych na wstążce.
Zmiana stylu, rozmiaru, koloru i wyrównania tekstu etykiety za pomocą poleceń dostępnych na wstążce.
Właściwość formantu można zmienić, klikając ją i wpisując żądaną wartość. Na rysunku 17.27 widać skierowaną w dół strzałkę i przycisk z trzema kropkami po prawej stronie obszaru wprowadzania danych właściwości Źródło formantu. Strzałka pojawia się po kliknięciu obszaru wprowadzania danych niektórych właściwości. Informuje ona, że Access dysponuje listą wartości do wyboru. Kliknięcie strzałki obok właściwości Źródło formantu powoduje wyświetlenie listy rozwijanej wszystkich pól pochodzących ze źródła danych (tabeli tblProducts). Ustawienie właściwości Źródło formantów na pole tabeli powoduje utworzenie formantu związanego. Rysunek 17.27. Ustawianie właściwości Źródło formantu
Niektóre właściwości mają listę standardowych wartości takich jak Tak i Nie, inne wyświetlają różnorodne listy pól, formularzy, raportów lub makr. Właściwości każdego obiektu są określone przez typ obiektu i jego przeznaczenie. Interesującą własnością Accessa jest cykliczna zmiana ustawień właściwości w przypadku kolejnego dwukrotnego klikania pokazywanej wartości. Jeśli na przykład będziemy dwukrotnie klikać właściwość Kiedy wyświetlać, na zmianę będą się pojawiać ustawienia Zawsze, Tylko wydruk i Tylko ekran. Przycisk z trzema kropkami to przycisk konstruktora otwierający jeden z wielu konstruktorów w Accessie, takich jak Konstruktor makr, Konstruktor wyrażeń albo Konstruktor kodu. Jeśli otworzymy konstruktor i wprowadzimy określone ustawienia, właściwość wypełni się automatycznie. Więcej informacji na temat konstruktorów można znaleźć w dalszej części tego rozdziału.
496
Część V Formularze i raporty Accessa
Z każdym typem obiektu jest związane inne okno właściwości oraz inny zbiór właściwości. Dotyczy to samego formularza, każdej jego sekcji oraz poszczególnych formantów. Aby wyświetlić okno właściwości określonego obiektu, należy najpierw kliknąć obiekt lub wybrać go z listy rozwijanej arkusza właściwości. Okno właściwości natychmiast się zmieni i wyświetli właściwości wybranego obiektu.
Nadawanie nazw i tytułów formantom Łatwo zauważyć, że każde pole danych ma formant etykiety i formant pola tekstowego. Zazwyczaj tytuł etykiety jest identyczny z właściwością Nazwa pola tekstowego. Właściwość Nazwa pola tekstowego zazwyczaj jest taka sama jak nazwa pola tabeli wyświetlającego się jako właściwość Źródło formantu. Czasami właściwość Tytuł etykiety jest inna z powodu wprowadzenia właściwości Tytuł dla pola tabeli. Podczas tworzenia formantów w formularzu warto pamiętać o używaniu standardowej konwencji nazw do nadawania wartości ich właściwości Nazwa. Nazwa każdego z formantów powinna być poprzedzona opisową, łatwą do rozpoznania nazwą (np. txtCałkowity Koszt, cboWojewództwo lub lblTytuł). Konwencje nazw dla formantów formularzy i raportów pokazano w tabeli 17.2. Więcej informacji na temat konwencji nazw można znaleźć w internecie, pod adresem www.xoc.net/standards. Właściwości wyświetlone na rysunku 17.27 to specyficzne właściwości pola tekstowego Description. Pierwsze dwie właściwości, Nazwa i Źródło formantu, ustawiono na Description. Nazwa to po prostu nazwa pola. Kiedy formant jest związany z polem tabeli, Access automatycznie nadaje mu nazwę związanego pola. Formanty niezwiązane otrzymują nazwy takie jak Pole11 albo Przycisk13. Można jednak nadać formantowi dowolną nazwę. W przypadku formantów związanych właściwość Źródło formantu zawiera nazwę pola tabeli, z którym związany jest formant. W tym przykładzie wartość Description odnosi się do pola o takiej samej nazwie w tabeli tblProducts. Formant niezwiązany nie ma źródła, natomiast źródłem formantu obliczeniowego jest wyrażenie obliczające wartość, takie jak =[SalePrice] – [Cost].
Rozdział 17. Tworzenie prostych formularzy Tabela 17.2. Konwencje nazewnictwa formantów w formularzach i raportach Przedrostek
Obiekt
frb
Związana ramka obiektu
cht
Wykres
chk
Pole wyboru
cbo
Pole kombi
cmd
Przycisk polecenia
ocx
Niestandardowy formant ActiveX
det
Szczegóły (sekcja)
gft[n]
Stopka (sekcja grupy)
fft
Sekcja stopki formularza
fhd
Sekcja nagłówka formularza
ghd[n]
Nagłówek (sekcja grupy)
hlk
Hiperłącze
img
Obraz
lbl
Etykieta
lin
Linia
lst
Pole listy
opt
Przycisk opcji
grp
Pole grupy
pge
Strona (karta)
brk
Podział strony
pft
Stopka strony (sekcja)
phd
Nagłówek strony (sekcja)
shp
Prostokąt
rft
Stopka raportu (sekcja)
rhd
Nagłówek raportu (sekcja)
sec
Sekcja
sub
Podformularz/podraport
tab
Karta
txt
Pole tekstowe
tgl
Przycisk przełącznika
fru
Niezwiązana ramka obiektu
497
498
Część V Formularze i raporty Accessa
Rozdział 18.
Praca z danymi w formularzach W tym rozdziale:
Przeglądanie i modyfikowanie danych w widoku formularza
Edycja danych w formularzach
Drukowanie formularzy
Właściwości formularzy
Wprowadzanie nagłówków i stopek w formularzach
Dostrajanie układu formularza
Dodawanie formantów obliczeniowych w formularzach
Przekształcanie formularza w raport
W rozdziale 17. poznałeś narzędzia potrzebne do tworzenia i wyświetlania formularzy — widok projektu, formanty związane i niezwiązane, narzędzie Lista pól oraz grupę Formanty na wstążce. W tym rozdziale nauczysz się pracy z danymi w formularzach, przeglądania i modyfikowania właściwości formularzy oraz korzystania z widoku układu. Interfejs użytkownika aplikacji Accessa składa się z formularzy. Służą one do wyświetlania i modyfikowania danych oraz do komunikacji z użytkownikiem. Nadają aplikacji „osobowość”, a dobrze zaprojektowany interfejs w znaczący sposób zmniejsza czas, jaki trzeba poświęcić na szkolenie nowych użytkowników. Dane wyświetlane w formularzach Accessa zazwyczaj są związane (bezpośrednio lub pośrednio) z tabelami Accessa. Modyfikacje wykonane na danych formularza wpływają na dane zapisane w powiązanych z nimi tabelach. W tym rozdziale jako źródła danych potrzebnych do zaprezentowania przykładów posłużą tabele tblProducts, tblSales i tblContacts z bazy danych Rozdział18.accdb.
500
Część V Formularze i raporty Accessa
Używanie widoku formularza Widok formularza jest miejscem, w którym można przeglądać i modyfikować dane. Praca z danymi w widoku formularza przypomina pracę z danymi w widoku arkusza danych tabeli lub kwerendy. Widok formularza prezentuje dane w postaci przyjaznej dla użytkownika, w układzie zaprojektowanym i utworzonym przez programistę. Więcej informacji na temat pracy w widoku arkusza danych można znaleźć w rozdziale 5.
Aby się zapoznać ze sposobem korzystania z widoku formularza, wykonaj poniższe czynności w celu stworzenia nowego formularza opartego na tabeli tblProducts: 1. Wybierz tabelę tblProducts w okienku nawigacji. 2. Kliknij zakładkę TWORZENIE na wstążce. 3. Kliknij polecenie Formularz w grupie Formularze. 4. Kliknij przycisk Widok formularza w grupie Widoki zakładki NARZĘDZIA GŁÓWNE, aby przełączyć się z widoku układu do widoku formularza. Okno Accessa z nowo utworzonym formularzem w widoku formularza zamieszczono na rysunku 18.1. Widok formularza ma wiele elementów charakterystycznych dla widoku arkusza danych. W górnej części ekranu wyświetla się pasek tytułu Accessa, pasek narzędzi szybkiego dostępu i wstążka. Na formularzu w środkowej części ekranu wyświetlają się dane — jeden rekord naraz. Rysunek 18.1. Formularz w widoku formularza
Rozdział 18. Praca z danymi w formularzach
501
Jeśli formularz zawiera więcej pól, niż może się jednorazowo zmieścić na ekranie, Access automatycznie wyświetla poziomy i (lub) pionowy pasek przewijania, który można wykorzystać, by obejrzeć pozostałe dane. Resztę danych można również zobaczyć po kliknięciu klawisza PgDn. Jeśli jesteś na końcu formularza lub jeśli cały formularz mieści się na ekranie, wciśnięcie klawisza PgDn powoduje przejście do następnego rekordu.
Na pasku stanu w dolnej części okna wyświetla się właściwość Opis pola zdefiniowana w momencie utworzenia tabeli (bądź formularza). Jeśli dla wybranego pola nie zdefiniowano właściwości Opis pola, Access wyświetla tekst Widok formularza. Zwykle komunikaty o błędach i ostrzeżenia zamiast na pasku stanu pojawiają się w oknach dialogowych wyświetlanych na środku ekranu. W dolnej części ekranu wyświetlają się przyciski nawigacyjne, pole wyszukiwania i skróty widoków. Mechanizmy te umożliwiają szybkie poruszanie się między rekordami, wyszukiwanie danych i przełączanie się między widokami.
Zakładka NARZĘDZIA GŁÓWNE Zakładka NARZĘDZIA GŁÓWNE (zobacz rysunek 18.2) umożliwia pracę z danymi. Zawiera kilka znanych obiektów, jest też kilka nowych. W tym punkcie znajdziesz opis zakładki NARZĘDZIA GŁÓWNE widoku formularza. Poszczególne polecenia zostały opisane bardziej szczegółowo w dalszej części tego rozdziału.
Rysunek 18.2. Wstążka widoku formularza, zakładka NARZĘDZIA GŁÓWNE Należy pamiętać, że wstążka Accessa i znajdujące się na niej formanty zależą od kontekstu. W zależności od bieżącego zadania niektóre polecenia mogą być nieaktywne lub niewidoczne. Chociaż takie zachowanie wstążki może być mylące, to intencją Microsoftu było maksymalne jej uproszczenie. Dążono do tego, by użytkownik mógł się skoncentrować na konkretnym zadaniu i by nie musiał podczas pracy zajmować się poleceniami nieistotnymi w kontekście wykonywanej pracy.
Grupa Widoki Najbardziej z lewej strony jest grupa Widoki, która umożliwia przełączanie się między różnymi widokami formularza. Można je zobaczyć po kliknięciu strzałki w dół skojarzonej z przyciskiem polecenia.
Widok formularza — umożliwia operacje na danych w formularzu.
Widok arkusza danych — powoduje wyświetlenie danych w formacie wierszy i kolumn. Więcej informacji na temat formatu wierszy i kolumn można znaleźć w rozdziale 5.
Widok układu — umożliwia modyfikację projektu formularza podczas przeglądania danych.
Widok projektu — umożliwia wprowadzanie modyfikacji w projekcie formularza.
502
Część V Formularze i raporty Accessa Nie wszystkie z powyższych poleceń są dostępne dla wszystkich formularzy. Dostępne widoki można ustawić za pomocą właściwości formularza. Więcej informacji na temat właściwości formularzy znajduje się w punkcie „Inne właściwości formularzy” w dalszej części tego rozdziału.
Grupa Schowek W grupie Schowek są dostępne polecenia Wytnij, Kopiuj, Wklej i Malarz formatów. Działają one podobnie jak analogiczne polecenia w innych aplikacjach (Wordzie, Excelu itp.). Schowek to zasób systemu Windows współdzielony przez niemal wszystkie aplikacje tego systemu. Dane skopiowane bądź wycięte, na przykład z Excela, można wkleić do Accessa, o ile kontekst tych informacji jest odpowiedni. Można na przykład skopiować procedurę VBA z arkusza Excela i wkleić ją do modułu kodu VBA Accessa, ponieważ konteksty tych danych pasują do siebie. Nie można natomiast skopiować całego arkusza Excela i wkleić go do Accessa, gdyż Access nie potrafi pracować z arkuszami Excela. Office korzysta z własnego schowka, który współdziała ze schowkiem systemu Windows, ale przechowuje kopiowane materiały w formatach dostosowanych do pakietu Office. Gdy skopiujesz zakres komórek z Excela, schowek pakietu Office zachowa ten zakres w formacie obsługiwanym przez ten pakiet. Na przykład gdy wkleisz zakres w formularzu otwartym w widoku projektu, automatycznie utworzony zostanie formant OLE.
Kliknięcie strzałki w dół polecenia Wklej daje dostęp do trzech opcji:
Wklej — wstawia w bieżącej lokalizacji w Accessie dane skopiowane do schowka systemu Windows. W zależności od wykonywanego zadania wklejane informacje mogą być zwykłym tekstem, formantem, tabelą, formularzem albo innym obiektem.
Wklej specjalnie — umożliwia wklejanie zawartości schowka w różnych formatach (tekst, CSV, rekordy itp.).
Dołącz i wklej — wkleja zawartość schowka w postaci nowych rekordów, pod warunkiem, że skopiowano wiersz o podobnej strukturze. Oczywiście polecenie Dołącz i wklej jest niedostępne dla wszystkich operacji, które nie polegają na kopiowaniu i wklejaniu rekordów tabeli bazy danych.
Inne formanty z grupy Schowek na wstążce to:
Wytnij — wycina element z bieżącego miejsca w aplikacji i umieszcza go w schowku systemu Windows. Wycięcie elementu i usunięcie go z jego bieżącej lokalizacji nie powoduje jego skasowania. Element ten musi być jednak wklejony, zanim kolejny element zostanie skopiowany do Schowka, ponieważ wycinane lub kopiowane elementy nadpisują bieżącą zawartość Schowka.
Kopiuj — powoduje skopiowanie do schowka elementu bądź obiektu. Operację kopiowania można zastosować do zwykłego tekstu, ale także do formantów w formularzach lub raportach (oczywiście o ile formularz lub raport wyświetla się w widoku projektu), rekordów bazy danych, całych tabel, kwerend, innych obiektów bazy danych itp. Do schowka systemu Windows można skopiować niemal wszystko.
Malarz formatów — jest to specjalne narzędzie wykorzystywane podczas pracy z formularzami i raportami Accessa w widoku projektu (ikona w postaci pędzla).
Rozdział 18. Praca z danymi w formularzach
503
Jego koncepcja jest dość prosta: kopiujemy format elementu (np. ustawienia czcionki), a następnie malujemy formatowanie na innym elemencie lub na całej grupie. Narzędzie Malarz formatów pozwala zaoszczędzić sporo czasu podczas pracy z formularzami lub raportami zawierającymi wiele formantów. Najpierw należy skonfigurować formant (np. pole tekstowe) w taki sposób, by wyglądał dokładnie tak, jak chcemy. Następnie trzeba zaznaczyć to pole tekstowe i kliknąć (lub kliknąć dwukrotnie) ikonę Malarza formatów. Kiedy teraz kliknie się na innym polu tekstowym, formatowanie pierwszego pola tekstowego zostanie zastosowane dla drugiego. Dwukrotne kliknięcie Malarza formatów blokuje ustawienie. Dzięki temu można zastosować format do wielu elementów (aby odblokować Malarza formatów, należy kliknąć go jeszcze raz).
Grupa Sortowanie i filtrowanie Grupa Sortowanie i filtrowanie umożliwia zmianę kolejności rekordów oraz ograniczenie wyświetlanych wierszy na podstawie zdefiniowanych kryteriów. Grupa Rekordy Polecenia z grupy Rekordy umożliwiają zapisywanie, usuwanie lub dodawanie nowych rekordów do formularza. Są tam również polecenia do wyświetlania podsumowań, sprawdzania pisowni, blokowania i ukrywania kolumn, a także do zmiany wysokości wiersza i szerokości komórki w widoku arkusza danych. Grupa Znajdowanie Grupa Znajdowanie pozwala wyszukiwać dane z zastępowaniem oraz przechodzić do wskazanych rekordów w arkuszu danych. Polecenie Zaznacz umożliwia wybór jednego lub wszystkich rekordów. Grupa Okno Grupa Okno zawiera dwa formanty:
Dopasuj do rozmiaru formularza — podczas pracy z formularzem w widoku projektu Access zapamiętuje wymiary (wysokość i szerokość) formularza w momencie jego zapisywania. W przypadku włączenia trybu nakładających się okien użytkownik może zmieniać rozmiary formularzy poprzez przeciąganie krawędzi do nowego rozmiaru i kształtu. Polecenie przywraca formularz do wymiarów ustawionych w czasie projektowania.
Przełącz okna — polecenie to zapewnia wygodny sposób wyświetlenia wszystkich obiektów Accessa (formularzy, raportów, tabel itp.) aktualnie otwartych w głównym oknie. Aby przełączyć się na inny obiekt, należy wybrać go z listy rozwijanej, która wyświetla się po kliknięciu przycisku Przełącz okna. Gdy ustawienie Opcje okna dokumentu bieżącej bazy danych ma wartość Dokumenty kartotekowe, zakładka NARZĘDZIA GŁÓWNE nie zawiera grupy Okno. Wtedy wszystkie otwarte obiekty Accessa są dostępne za pomocą zakładek, dlatego opcje przełączania okien są niepotrzebne. Aby zmienić ustawienie Opcje okna dokumentu, wybierz opcję Plik/Opcje, a następnie ustaw odpowiednią opcję w zakładce Bieżąca baza danych okna dialogowego Opcje programu Access.
504
Część V Formularze i raporty Accessa
Grupa Formatowanie tekstu Grupa Formatowanie tekstu umożliwia zmianę wyglądu arkusza w widoku arkusza lub widoku projektu. Za pomocą poleceń z tej grupy można ustawiać czcionkę, rozmiar, pogrubienie, kursywę, kolor itp. Polecenia Wyrównaj do lewej, Wyrównaj do prawej i Wyrównaj do środka umożliwiają wyrównywanie danych w wybranej kolumnie. Kliknięcie polecenia Linie siatki pozwala włączać i wyłączać linie siatki. Polecenie Naprzemienne kolory wierszy służy do zmiany kolorów sąsiadujących ze sobą wierszy lub wyboru dla nich jednakowego koloru. W przypadku modyfikowania tekstu w polach typu Długi tekst z właściwością Format tekstu ustawioną na Tekst sformatowany można użyć tych poleceń do zmiany czcionek, kolorów itp.
Nawigacja między polami Nawigacja po formularzu bardzo przypomina nawigację po arkuszu danych. Można z łatwością poruszać się po oknie formularza, klikając żądane pola, by zmienić lub uzupełnić dane. Ponieważ okno formularza wyświetla tylko tyle formantów, ile mieści się na ekranie, do poruszania się po formularzu lub między rekordami potrzebne są pomoce nawigacyjne. W tabeli 18.1 zamieszczono klawisze nawigacyjne służące do poruszania się między polami formularza. Tabela 18.1. Nawigacja po formularzu Kierunek nawigacji
Klawisze
Następne pole
Klawisz Tab, strzałka w prawo (→) lub w dół (↓) albo klawisz Enter
Poprzednie pole
Klawisz Shift+Tab, strzałka w lewo (←) lub w górę (↑)
Pierwsze pole bieżącego rekordu
Klawisz Home
Pierwsze pole pierwszego rekordu
Klawisz Ctrl+Home
Ostatnie pole bieżącego rekordu
Klawisz End
Ostatnie pole ostatniego rekordu
Klawisz Ctrl+End
Następna strona
Klawisz PgDn lub przycisk Następny rekord
Poprzednia strona
Klawisz PgUp lub przycisk Poprzedni rekord
Nawigacja między rekordami w formularzu Choć formularzy zwykle używa się do wyświetlania pojedynczych rekordów, nadal trzeba się poruszać między rekordami. Najprościej jest użyć w tym celu przycisków nawigacyjnych pokazanych na rysunku 18.3. Rysunek 18.3. Przyciski nawigacyjne widoku formularza
Przyciski nawigacyjne to sześć formantów umieszczonych w lewej dolnej części okna formularza. Dwa formanty położone najbardziej z lewej strony służą do przechodzenia odpowiednio do pierwszego i poprzedniego rekordu w formularzu. Trzy formanty z prawej
Rozdział 18. Praca z danymi w formularzach
505
powodują przejście do następnego, ostatniego i nowego rekordu. Jeśli znasz numer rekordu (numer wiersza określonego rekordu), możesz przejść do niego poprzez kliknięcie pola numeru rekordu, wpisanie numeru rekordu i wciśnięcie klawisza Enter. Numer rekordu wyświetlany między przyciskami nawigacyjnymi to jedynie wskaźnik pozycji bieżącego rekordu w zbiorze rekordów i zmienia się przy każdym filtrowaniu lub sortowaniu rekordów. Liczba po prawej stronie numeru rekordu pokazuje, ile rekordów jest w bieżącym widoku. Wyświetlana liczba rekordów może być różna od całkowitej liczby rekordów w tabeli bądź kwerendzie będących źródłem danych formularza. Wartość ta zmienia się w przypadku filtrowania danych w formularzu.
Modyfikowanie wartości w formularzu Wcześniej poznałeś techniki dodawania, zmieniania i usuwania danych w tabeli za pomocą arkusza danych. Takich samych technik używa się podczas pracy z formularzem. Zestawiono je w tabeli 18.2. Tabela 18.2. Techniki edycji Technika edycji
Klawisze
Przesuwanie punktu wstawiania w obrębie formantu
Naciśnij klawisz strzałki w prawo (→) lub w lewo (←)
Wprowadzanie wartości w obrębie formantu
Zaznacz punkt wstawiania i wpisz nowe dane
Zaznaczanie całego pola
Naciśnij klawisz F2
Zastępowanie istniejącej wartości nową wartością
Zaznacz całe pole i wpisz nową wartość
Zastępowanie wartości wartością poprzedniego pola
Naciśnij klawisze Ctrl+’ (apostrof)
Zastępowanie istniejącej wartości wartością domyślną
Naciśnij klawisze Ctrl+Alt+Spacja
Wstawianie bieżącej daty do formantu
Naciśnij klawisze Ctrl+; (średnik)
Wstawianie bieżącej godziny do formantu
Naciśnij klawisze Ctrl+: (dwukropek)
Wstawianie podziału wiersza w polu tekstowym
Naciśnij klawisze Ctrl+Enter
Wstawianie nowego rekordu
Naciśnij klawisze Ctrl++ (plus)
Usuwanie bieżącego rekordu
Naciśnij klawisze Ctrl+– (minus)
Zapisywanie bieżącego rekordu
Naciśnij klawisze Shift+Enter albo przejdź do innego rekordu
Przełączanie wartości w polach wyboru lub przełącznikach opcji
Naciśnij spację
Cofanie zmian w bieżącym formancie
Naciśnij klawisz Esc albo kliknij przycisk Cofnij
Cofanie zmian w bieżącym rekordzie
Naciśnij klawisz Esc albo kliknij przycisk Cofnij po raz drugi, po cofnięciu zmian w bieżącym formancie
506
Część V Formularze i raporty Accessa Strzałki w prawo (→) i w lewo (←) w trybie nawigacji działają inaczej niż w trybie edycji. Do przełączania się między tymi trybami służy klawisz F2. Jedyną wizualną wskazówką informującą o aktywnym trybie jest to, że w trybie edycji widoczny jest punkt wstawiania. Klawisze strzałek w trybie nawigacji służą do poruszania się między formantami, a w trybie edycji — do zaznaczania tekstu.
Formanty, których nie można modyfikować Niektórych formantów nie można modyfikować. Są to na przykład:
Formanty wyświetlające pola typu Autonumerowanie — Access obsługuje pola typu Autonumerowanie automatycznie. Wylicza ich wartość każdorazowo w momencie tworzenia nowego rekordu.
Formanty obliczeniowe — Access pozwala stosować formanty obliczeniowe w formularzach i kwerendach. Wartości w nich występujące nie są w rzeczywistości przechowywane w tabelach.
Pola zablokowane lub nieaktywne — w przypadku ustawienia pewnych właściwości nie można w określonych formantach edytować danych.
Formanty zablokowanych rekordów w środowisku z wieloma użytkownikami — jeżeli inny użytkownik zablokuje rekord, nie można edytować żadnego z jego pól.
Praca z obrazami i obiektami OLE Obiekty OLE (Object Linking and Embedding — łączenie i osadzanie obiektów) nie są częścią bazy danych Accessa. Najczęściej są to obrazy, ale pole typu OLE może również zawierać dane innych typów, np. dokumenty Worda, arkusze Excela i pliki dźwiękowe. Można także dołączać pliki wideo, takie jak .mpg lub .avi. W arkuszu danych nie da się obejrzeć obrazu ani żadnego innego obiektu OLE bez wywołania serwera OLE (takiego jak Word, Excel albo Windows Media Player). W widoku formularza można jednak zmienić rozmiar formantu OLE tak, aby zmieściło się w nim zdjęcie, wykres biznesowy albo dowolny inny wizualny obiekt OLE. Można też zmieniać rozmiar formantów tekstowych, aby widzieć więcej danych w polu — nie trzeba używać okna powiększenia, co jest konieczne w polach na arkuszu danych. W polach OLE Accessa można przechowywać obiekty wielu typów. Podobnie jak w arkuszu danych są dwa sposoby wypełniania pól OLE w formularzu:
Skopiuj obiekt (np. plik .mp3) do Schowka, a następnie wklej go, używając poleceń z grupy Schowek na wstążce.
Kliknij prawym przyciskiem myszy formant OLE, a następnie wybierz polecenie Wstaw obiekt. Spowoduje to wyświetlenie okna dialogowego Wstaw obiekt pokazanego na rysunku 18.4. Za pomocą okna dialogowego Wstaw obiekt można dodać nowy obiekt w polu OLE. Można też wstawić obiekt z pliku na dysku. Włączenie przełącznika Utwórz z pliku umożliwia dodanie zdjęcia lub innego obiektu OLE z pliku zapisanego na dysku.
Rozdział 18. Praca z danymi w formularzach
507
Rysunek 18.4. Okno dialogowe Wstaw obiekt
W przypadku wyświetlania obrazu za pomocą formantu OLE należy ustawić właściwość Tryb wymiarowania, która decyduje o sposobie jego wyświetlania. Opcje dostępne dla tej właściwości są następujące:
Obetnij — zachowuje oryginalny rozmiar obrazu i obcina te jego części, które nie mieszczą się w obrębie formantu.
Powiększ — dopasowuje obraz do rozmiarów formantu z zachowaniem proporcji, co może spowodować, że w obrębie formantu pozostanie wolne miejsce.
Rozciągnij — skaluje obraz w taki sposób, aby dokładnie wypełniał formant. Ustawienie to może prowadzić do zniekształcenia obrazu.
Wprowadzanie danych w polu typu Długi tekst Pole tekstowe Cechy pokazane na rysunku 18.1 zawiera dane typu Długi tekst. Ten typ pola umożliwia wprowadzenie do jednego gigabajta tekstu. W polu tekstowym wyświetlają się pierwsze trzy wiersze danych. Kliknięcie myszą w polu tekstowym powoduje wyświetlenie pionowego paska przewijania. Za pomocą tego paska można obejrzeć pozostałe dane w polu. Co więcej, jeśli chcemy wyświetlić dodatkowe dane, możemy zmienić rozmiar formantu w widoku projektu formularza. Należy zaznaczyć pole tekstowe z danymi typu Długi tekst, a następnie wcisnąć kombinację Shift+F2. Spowoduje to wyświetlenie okna dialogowego Powiększenie (zobacz rysunek 18.5). Tekst w oknie Powiększenie można edytować. Można dodawać nowy tekst bądź modyfikować obecny tekst formantu.
Wprowadzanie danych w polu typu Data Pole SaleDate w formularzu frmSales_Layout pokazanym na rysunku 18.5 jest typu Data/ Godzina. Sformatowano je w taki sposób, by można było w nim wprowadzać i wyświetlać daty. Kliknięcie tego pola tekstowego powoduje wyświetlenie obok niego narzędzia do wyboru daty (zobacz rysunek 18.6). Jeśli się je kliknie, wyświetli się kalendarz, z którego można wybrać datę. Jeśli narzędzie do wyboru daty się nie wyświetla, należy przełączyć się do widoku projektu i zmienić właściwość Pokaż okno wyboru dat na wartość Dla dat. Aby wyłączyć używanie okna wyboru dat, należy ustawić właściwość Pokaż okno wyboru dat na wartość Nigdy.
508
Część V Formularze i raporty Accessa
Rysunek 18.5. Okno dialogowe Powiększenie
Rysunek 18.6. Używanie okna wyboru dat
Używanie grup opcji Grupy opcji umożliwiają wybór wartości za pomocą przełączników (czasami nazywanych przyciskami radiowymi — ang. radio button). Włączenie jednej wartości przełącznika powoduje wyłączenie tej, która była dotychczas włączona. Grupy opcji najbardziej nadają się w przypadkach, kiedy należy wybrać jedną wartość z niewielkiego zbioru. Na rysunku 18.7 pokazano grupę opcji obok pola tekstowego Data komentarza. Grupy opcji można także wykorzystywać z przyciskami opcji i polami wyboru. Najłatwiejszym i najbardziej wydajnym sposobem tworzenia grup opcji jest skorzystanie z Kreatora grup opcji. Za jego pomocą można tworzyć grupy opcji zawierające wiele przycisków opcji, przełączników lub pól wyboru. Skorzystanie z kreatora zapewnia poprawne ustawienie wszystkich właściwości formantu. Aby utworzyć grupę opcji, należy przełączyć się do widoku projektu i wybrać polecenie Grupa opcji na zakładce PROJEKTOWANIE w grupie Formanty. Należy się upewnić, czy zaznaczono polecenie Użyj kreatorów formantów.
Rozdział 18. Praca z danymi w formularzach
509
Rysunek 18.7. Wykorzystanie grupy opcji do wyboru spośród wzajemnie wykluczających się wartości
W przypadku tworzenia grupy opcji dla pola Tak/Nie (które jest liczbowe) należy ustawić wartość Tak na –1, natomiast wartość Nie na 0.
Używanie pól kombi i list W Accessie są dwa typy formantów — pola list i pola kombi — umożliwiające wyświetlanie list danych, spośród których użytkownik może wybierać wartości. Pole listy jest zawsze otwarte, przygotowane do wyboru wartości, natomiast aby otworzyć listę związaną z polem kombi, trzeba je najpierw kliknąć. Pola kombi umożliwiają dodatkowo wprowadzanie wartości spoza listy i zajmują mniej miejsca na formularzu. Ponieważ pola kombi zapewniają bardzo wydajne wykorzystanie przestrzeni formularza, można je wykorzystać na przykład do wyświetlania wartości z tabeli tblCustomers (zobacz rysunek 18.8). Najprostszym sposobem, aby to zrobić, jest skorzystanie z kreatora pól kombi. Kreator ten przeprowadza użytkownika przez proces tworzenia pola kombi wyświetlającego wartości pobrane z innej tabeli. Aby utworzyć pole kombi, należy przełączyć się do widoku projektu i wybrać polecenie Pole kombi na zakładce PROJEKTOWANIE w grupie Formanty. Należy się upewnić, czy zaznaczono polecenie Użyj kreatorów formantów. Rysunek 18.8. Korzystanie z pola kombi do wybierania wartości z listy
510
Część V Formularze i raporty Accessa
Po utworzeniu pola kombi należy ustawić właściwości Typ źródła wierszy, Źródło wierszy, Liczba kolumn, Nagłówki kolumn, Szerokości kolumn, Kolumna związana, Liczba wierszy listy oraz Szerokość listy. Gdy wiesz już, jak ustawiać te właściwości, możesz kliknąć prawym przyciskiem myszy pole tekstowe, wybrać polecenie Zmień na/Pole kombi, a następnie ręcznie ustawić właściwości pola kombi.
Przełączanie się do widoku arkusza danych Podczas pracy z formularzem można się przełączyć do widoku arkusza danych za pomocą jednej z poniższych metod:
Kliknięcie polecenia Widok arkusza danych w grupie Widoki zakładki NARZĘDZIA GŁÓWNE.
Kliknięcie przycisku Widok arkusza danych w sekcji Skróty widoków w prawym dolnym narożniku okna Accessa.
Kliknięcie prawym przyciskiem myszy paska tytułu formularza — lub dowolnego pustego obszaru na formularzu — i wybranie opcji Widok arkusza danych z menu podręcznego.
Kiedy wyświetli się arkusz danych, kursor będzie się znajdował w tym samym polu i rekordzie, które zajmował na formularzu. Jeśli przejdziemy do innego rekordu lub pola i ponownie wyświetlimy formularz, kursor będzie się znajdował w polu i rekordzie, które ostatnio zajmował na arkuszu danych. Aby powrócić do widoku formularza — lub dowolnego innego widoku — należy wybrać żądany widok w grupie Widoki za pomocą skrótów widoków lub menu podręcznego. Domyślnie właściwość Allow Datasheet View nowego formularza ma wartość Nie. Aby umożliwić przełączanie do widoku arkusza danych, ustaw tę właściwość na Tak.
Zapisywanie rekordu Access automatycznie zapisuje każdy rekord w momencie przejścia do innego rekordu. Aby zapisać rekord bez przechodzenia do innego rekordu, należy wcisnąć kombinację klawiszy Shift+Enter lub wybrać polecenie Zapisz z grupy Rekordy na wstążce. Zamknięcie formularza również powoduje zapisanie rekordu. Ze względu na to, że Access automatycznie zapisuje zmiany przy przejściu do innego rekordu, może przypadkowo dojść do nieodwracalnej modyfikacji danych w tabelach bazy. Ponieważ nie można cofnąć zmian wprowadzonych w bazie danych Accessa, nie ma łatwego sposobu przywrócenia rekordów do poprzedniego stanu.
Drukowanie formularzy Jeden lub kilka rekordów w formularzu można wydrukować dokładnie w takim formacie, w jakim wyświetlają się one na ekranie (sposób tworzenia sformatowanych raportów opisano w rozdziale 20.). Najprostszym sposobem wydrukowania formularza jest
Rozdział 18. Praca z danymi w formularzach
511
wciśnięcie kombinacji Ctrl+P, co prowadzi do wyświetlenia okna dialogowego Drukowanie. Z poziomu tego okna dialogowego można dostosować wydruk do indywidualnych potrzeb poprzez wybór różnych opcji:
Zakres wydruku — drukuje cały formularz lub tylko wybrane strony bądź rekordy.
Liczba kopii — określa liczbę kopii, jakie mają zostać wydrukowane.
Sortuj — określa, czy poszczególne kopie mają być sortowane.
Można też kliknąć przycisk Właściwości i ustawić opcje dotyczące wybranej drukarki, a także wybrać z pola kombi inny rodzaj drukarki. Przycisk Ustawienia umożliwia zdefiniowanie marginesów oraz nagłówków. Drukowanie formularza niczym się nie różni od drukowania innych dokumentów. Access jest środowiskiem WYSIWYG (ang. What You See Is What You Get — dosł. otrzymujesz to, co widzisz), zatem dokładnie to, co widzisz na formularzu, uzyskasz także na wydruku. Jeśli dodasz nagłówki stron lub stopki, wyświetlą się one w górnej lub w dolnej części strony. Wydruk będzie zawierał wszystkie elementy formatowania zdefiniowane w formularzu (włącznie z liniami, ramkami i cieniowaniem), a w przypadku użycia czarno-białej drukarki kolory będą przekształcone do postaci odcieni szarości. Wydruk będzie zawierał tyle stron, ile potrzeba do wydrukowania wszystkich danych. Jeśli formularz jest szerszy od pojedynczej strony wydruku, do jego wydrukowania trzeba będzie użyć więcej niż jednej strony. Access odpowiednio podzieli wydruk tak, by zmieścił się na każdej ze stron. Polecenie Drukuj w menu Plik zapewnia dostęp do dodatkowych opcji drukowania:
Szybkie drukowanie — powoduje wydrukowanie aktywnego formularz za pomocą drukarki domyślnej bez możliwości zmiany opcji.
Drukuj — wyświetla okno dialogowe Drukowanie.
Podgląd wydruku — pokazuje, jak wydruk będzie wyglądał przy bieżących ustawieniach. W trybie podglądu wydruku na wstążce pojawia się zakładka PODGLĄD WYDRUKU (wszystkie inne zakładki zostają ukryte). Za pomocą poleceń ze wstążki można wybrać różne widoki, zmienić ustawienia drukowania, a także przybliżyć lub oddalić widok. Kliknięcie polecenia Drukuj powoduje wydrukowanie formularza na drukarce. Aby zamknąć podgląd wydruku i powrócić do widoku formularza, należy kliknąć polecenie Zamknij podgląd wydruku po prawej stronie wstążki.
Praca z właściwościami formularza Właściwości formularza określają sposób wyświetlania całego formularza. Za ich pomocą można ustawić jego kolor lub obraz tła, szerokość itd. W tabelach od 18.3 do 18.5 w dalszej części tego rozdziału opisano najważniejsze właściwości formularza. Zmiana właściwości domyślnych jest względnie łatwa — należy zaznaczyć właściwość w oknie właściwości i ustawić nową wartość.
512
Część V Formularze i raporty Accessa
W przykładach zamieszczonych w tym podrozdziale wykorzystano formularz frmProducts z przykładowej bazy danych Rozdział08.accdb.
Selektor formularza jest obszarem przecięcia się linijek. Jest widoczny w czasie, kiedy formularz wyświetla się w widoku projektu. Kiedy formularz jest zaznaczony, wyświetla się jako niewielki czarny kwadrat (zobacz rysunek 18.9). Rysunek 18.9. Wykorzystanie selektora formularza do wyświetlenia arkusza właściwości formularza
Aby ustawić właściwości formularza, trzeba wyświetlić jego arkusz właściwości. Należy przełączyć się do widoku projektu lub układu i skorzystać z jednej z poniższych metod:
Kliknąć selektor formularza, tak by wyświetlił się niewielki czarny kwadrat, a następnie kliknąć polecenie Arkusz właściwości w grupie Narzędzia zakładki PROJEKTOWANIE.
Kliknąć polecenie Arkusz właściwości zakładki PROJEKTOWANIE w grupie Narzędzia, a następnie wybrać Formularz w górnym wierszu arkusza właściwości.
Dwukrotnie kliknąć selektor formularza.
Kliknąć prawym przyciskiem myszy selektor formularza, dowolną z linijek lub pusty obszar formularza, a następnie wybrać polecenie Właściwości z menu podręcznego. Można też wcisnąć klawisz F4 w czasie, kiedy formularz wyświetla się w widoku projektu lub układu.
Domyślnie arkusz właściwości formularza jest zadokowany z prawej strony okna Accessa. Ponieważ arkusz właściwości jest oknem, można je oddokować, przesuwać i zmieniać rozmiar. Na rysunku 18.9 arkusz właściwości został oddokowany i przeciągnięty nad formularz frmProducts. Warto zwrócić uwagę, że arkusz właściwości nie zawiera przycisków Maksymalizacji i Minimalizacji, nie umożliwia sortowania ani wyszukiwania.
Rozdział 18. Praca z danymi w formularzach
513
Więcej informacji na temat pracy z arkuszem właściwości można znaleźć w rozdziale 17.
Modyfikacja tekstu na pasku tytułu za pomocą właściwości Tytuł Standardowo po zapisaniu formularza na pasku tytułu wyświetla się tytuł formularza. Modyfikacja właściwości Tytuł umożliwia wyświetlanie na pasku tytułu dowolnego tekstu w czasie wyświetlania formularza w widoku formularza. Aby zmienić tekst na pasku tytułu, wykonaj następujące czynności: 1. Kliknij selektor formularza, aby uzyskać pewność, że formularz jest zaznaczony. 2. Kliknij polecenie Arkusz właściwości w grupie Narzędzia zakładki PROJEKTOWANIE albo wciśnij klawisz F4, aby otworzyć arkusz właściwości. 3. Kliknij właściwość Tytuł w arkuszu właściwości i wpisz w polu tekstowym właściwości słowo Produkty, tak jak pokazano na rysunku 18.10. Rysunek 18.10. Modyfikacja właściwości Tytuł w arkuszu właściwości formularza
4. Kliknij dowolną inną właściwość lub wciśnij Enter, aby właściwość Tytuł przestała być aktywna. 5. Aby zobaczyć nowy tekst paska tytułu formularza, należy przełączyć się do widoku formularza. Tekst wpisany w arkuszu właściwości zastępuje nazwę zapisanego formularza. Wykorzystanie właściwości do zmiany tytułu formularza to oczywiście trywialne ćwiczenie. Zaprezentowano je po to, aby pokazać, jak łatwo można manipulować wyglądem formularza poprzez modyfikowanie jego właściwości. Podczas lektury tej książki Czytelnik napotka dosłownie setki przykładów wykorzystania narzędzi projektowych Accessa umożliwiających poprawienie wyglądu aplikacji tak, by stała się bardziej przydatna dla użytkowników.
514
Część V Formularze i raporty Accessa
Tworzenie formularza związanego Formularz związany to formularz bezpośrednio powiązany ze źródłem danych, np. tabelą lub kwerendą. Formularze związane zwykle automatycznie aktualizują dane w związanym źródle danych w chwili, gdy użytkownik przejdzie do nowego rekordu w formularzu. Aby utworzyć formularz związany, trzeba określić źródło rekordów we właściwości Źródło rekordów formularza. Na rysunku 18.10 zakładka Dane okna właściwości formularza zawiera właściwości decydujące o tym, co i jak wyświetla się na formularzu. Choć na rysunku 8.10 tego nie widać, to Źródło rekordów jest pierwszą właściwością na liście zakładki Dane arkusza właściwości. Źródłem danych może być jeden z trzech elementów:
Tabela — nazwa tabeli z bieżącego pliku bazy danych. Może to być tabela lokalna (przechowywana w bazie danych) albo tabela połączona Accessa lub zewnętrznego źródła danych, takiego jak baza danych SQL Server.
Kwerenda — nazwa kwerendy odwołującej się do jednej lub wielu tabel w bieżącym pliku bazy danych.
Instrukcja SQL-a — instrukcja SQL-a SELECT, która pobiera dane z tabeli albo kwerendy.
Jeśli formularz jest niezwiązany, właściwość Źródło rekordów jest pusta. Dane są wtedy pobierane za pomocą kodu VBA — w takim przypadku formularz nie może zawierać żadnych związanych formantów (dla formantów związanych właściwość Źródło formantu jest ustawiona na pole tabeli). Więcej informacji na temat dodawania związanych formantów za pomocą okna Lista pól można znaleźć w rozdziale 17.
Określanie sposobu wyświetlania formularza W Accessie sposób wyświetlania formularza określa się za pomocą kilku właściwości. Właściwość Widok domyślny określa sposób wyświetlania danych zaraz po uruchomieniu formularza.
Formularz pojedynczy — wyświetla jeden rekord. Jest to domyślny sposób wyświetlania formularza. Niezależnie od rozmiaru formularza wyświetla się jeden rekord na stronie.
Formularze ciągłe — wyświetla więcej niż jeden rekord. Ustawienie to instruuje Accessa, by wyświetlał tyle rekordów szczegółów, ile zmieści się na ekranie. Na rysunku 18.11 pokazano formularz ciągły, który wyświetla pięć rekordów.
Arkusz danych — wyświetla dane w wierszach i kolumnach, jak w arkuszu kalkulacyjnym albo standardowym widoku arkusza danych kwerendy.
Formularz dzielony — umożliwia użytkownikom przeglądanie danych w dwóch widokach jednocześnie. W górnej części można wybrać rekord z arkusza danych, a w formularzu wyświetlającym się w dolnej części — edytować informacje.
Rozdział 18. Praca z danymi w formularzach
515
Rysunek 18.11. Ustawienie właściwości Widok domyślny na Formularze ciągłe powoduje wyświetlanie wielu rekordów naraz
Istnieją trzy właściwości, dzięki którym projektant formularza może określić, czy użytkownik jest uprawniony do zmiany widoku domyślnego: Allow Form View, Allow Datasheet View oraz Zezwalaj na widok układu. Domyślne ustawienie dla właściwości Allow Form View i Zezwalaj na widok układu to Tak, natomiast dla właściwości Allow Datasheet View wartość domyślna to Nie. Jeśli ustawimy właściwość Allow Datasheet View na Tak, będzie można wybrać polecenie Widok arkusza danych (z grupy Widoki na wstążce, za pomocą przycisków skrótów widoków oraz z menu podręcznego). Dane będzie można oglądać także w widoku arkusza danych. Jeśli ustawimy właściwość Allow Form View na Nie, polecenie Widok formularza nie będzie dostępne.
Usuwanie paska selektora rekordów Właściwość Selektory rekordów określa, czy wyświetlany jest pasek selektora rekordów (pionowy pasek widoczny na rysunku 18.11 po lewej stronie formularza). Jest on bardzo ważny w formularzach wielorekordowych i arkuszach danych, ponieważ wskazuje bieżący rekord. Trójkąt określa bieżący rekord, a ikona ołówka oznacza, że rekord jest edytowany. Choć pasek selektora rekordów pełni istotną funkcję w arkuszach danych, w formularzu pojedynczym jest zwykle niepotrzebny. Aby go usunąć, wystarczy zmienić ustawienie właściwości Selektory rekordów z Tak na Nie.
Inne właściwości formularzy Tabele od 18.3 do 18.5 zawierają najczęściej używane właściwości formularza wraz z krótkim opisem. Więcej informacji na ich temat zamieszczono w tym i kolejnych rozdziałach, przy okazji użycia ich w przykładach.
516
Część V Formularze i raporty Accessa
Tabela 18.3. Właściwości formatowania formularza Właściwość
Opis
Opcje
Tytuł
Wyświetlany na pasku tytułu formularza
Do 2048 znaków Formularz pojedynczy — jeden rekord na stronę (ustawienie domyślne)
Widok domyślny
Określa typ widoku po uruchomieniu formularza
Formularze ciągłe — tyle rekordów na stronę, ile mieści się na ekranie Arkusz danych — standardowy widok arkusza danych z wierszami i kolumnami Formularz dzielony — wyświetla arkusz danych w górnej części okna i formularz w dolnej
Allow Form View
Widok formularza dozwolony
Tak/Nie
Allow Datasheet View
Widok arkusza danych dozwolony
Tak/Nie
Zezwalaj na widok układu
Widok układu dozwolony
Tak/Nie Żaden — paski przewijania nie są wyświetlane
Paski przewijania
Określa, czy wyświetlane są paski przewijania
Tylko poziomy — wyświetla tylko poziomy pasek przewijania Tylko pionowy — wyświetla tylko pionowy pasek przewijania Obydwa — wyświetla poziomy i pionowy pasek przewijania
Selektory rekordów
Określa, czy wyświetlany jest pionowy pasek selektora rekordów
Tak/Nie
Przyciski nawigacyjne
Określa, czy widoczne są przyciski nawigacyjne
Tak/Nie
Linie podziału
Określa, czy widoczne są linie podziału między sekcjami
Tak/Nie
Autowymiarowanie
Okno formularza jest automatycznie zwiększane w celu wyświetlenia całego rekordu
Tak/Nie
Autośrodkowanie
Formularz jest otwierany na środku ekranu
Tak/Nie
Rozdział 18. Praca z danymi w formularzach
517
Tabela 18.3. Właściwości formatowania formularza — ciąg dalszy Właściwość
Opis
Opcje Brak — brak obramowania i elementów obramowania (pasków przewijania, przycisków nawigacyjnych)
Styl obramowania
Określa styl obramowania formularza
Cienki — cienkie obramowanie, nie można zmieniać rozmiaru formularza Zmienny — zwykłe ustawienie formularza Dialog — grube obramowanie, tylko pasek tytułu, nie można zmieniać rozmiaru okna; używany w oknach dialogowych
Pole menu sterowania
Określa, czy menu sterowania (polecenia Przywróć, Przenieś, Tak/Nie Rozmiar) jest dostępne Żaden — w prawym górnym rogu formularza nie wyświetlają się żadne przyciski
Przyciski Min Maks
Określa, czy w pasku tytułu formularza wyświetlają się przyciski Min i Maks
Min włączony — wyświetla się tylko przycisk minimalizacji Max włączony — wyświetla się tylko przycisk maksymalizacji Oba włączone — wyświetlają się przyciski minimalizacji i maksymalizacji
Przycisk Zamknij
Określa, czy wyświetlany jest przycisk Zamknij w prawym górnym rogu okna i pozycja Zamknij w menu sterowania
Tak/Nie
Szerokość
Określa szerokość formularza; można wpisać wartość lub Access ustawi tę właściwość automatycznie po zmianie rozmiaru formularza
Wartość określająca liczbę centymetrów
Obraz
Nazwa pliku bitmapy będącego Dowolna poprawna nazwa pliku tłem całego formularza Osadzony — obraz jest osadzony na formularzu i staje się jego częścią
Typ obrazu
Określa, czy obraz jest osadzony czy połączony
Połączony — obraz jest połączony z formularzem; Access zapisuje położenie obrazu i pobiera go z pliku podczas każdego otwierania formularza Współdzielony — obraz jest przechowywany w Accessie i dostępny także w innych obiektach bazy danych
518
Część V Formularze i raporty Accessa
Tabela 18.3. Właściwości formatowania formularza — ciąg dalszy Właściwość
Opis
Opcje Obetnij — wyświetla obraz w rozmiarze rzeczywistym Rozciągnij — dopasowuje obraz do rozmiaru formularza (bez zachowania proporcji)
Tryb wymiarowania obrazu
Określa sposób wyświetlania obrazu
Powiększ — dopasowuje obraz do rozmiaru formularza (z zachowaniem proporcji); obraz może nie wypełniać całej szerokości lub wysokości formularza Rozciągnij w poziomie — dopasowuje obraz do szerokości formularza, ignorując wysokość Rozciągnij w pionie — dopasowuje obraz do wysokości formularza, ignorując szerokość Lewe górne — obraz jest wyświetlany w lewym górnym rogu formularza Prawe górne — obraz jest wyświetlany w prawym górnym rogu formularza Środkowe — obraz jest wyśrodkowany (domyślne)
Wyrównanie obrazu
Określa wyrównanie obrazu
Lewe dolne — obraz jest wyświetlany w lewym dolnym rogu formularza Prawe dolne — obraz jest wyświetlany w prawym dolnym rogu formularza Środek formularza — obraz jest wyśrodkowany w pionie i poziomie
Obrazy sąsiadująco
Używana, kiedy chcemy wypełnić formularz wieloma kopiami małej bitmapy, np. pojedyncze cegły mogą tworzyć mur
Tak/Nie
Siatka X
Określa liczbę punktów siatki na centymetr w poziomie
Liczba z przedziału od 1 do 64
Siatka Y
Określa liczbę punktów siatki na centymetr w pionie
Liczba z przedziału od 1 do 64
Układ wydruku
Określa, czy formularz używa czcionek ekranowych czy czcionek drukarki
Tak — czcionki drukarki
Wysokość podarkusza danych
Określa wysokość rozwiniętego podarkusza danych
Wartość określająca liczbę centymetrów (od 0 do 55)
Rozwinięty podarkusz danych
Określa stan wszystkich podarkuszy danych w tabeli lub kwerendzie
Tak — podarkusze danych są rozwinięte
Nie — czcionki ekranowe
Nie — podarkusze danych są zamknięte
Rozdział 18. Praca z danymi w formularzach
519
Tabela 18.3. Właściwości formatowania formularza — ciąg dalszy Właściwość
Paleta źródłowa
Opis
Paleta formularza lub raportu
Orientacja
Określa orientację widoku
Moveable
Określa, czy formularz można przenosić
Opcje Ustawienie (Domyślna) oznacza domyślną paletę kolorów Accessa Można też określić inne pliki palety Windows (.pal) oraz pliki .ico, .bmp, .db i .wmf Od prawej do lewej — elementy ekranowe są ułożone od strony prawej do lewej Od lewej do prawej — elementy ekranowe są ułożone od strony lewej do prawej Tak/Nie Arkusz danych u góry — arkusz danych wyświetla się w górnej części formularza
Orientacja arkusza dzielonego
Arkusz danych u dołu — arkusz danych wyświetla się w dolnej części formularza Określa wygląd formularza w widoku formularza dzielonego Arkusz danych z lewej — arkusz danych wyświetla się z lewej strony formularza Arkusz danych z prawej — arkusz danych wyświetla się z prawej strony formularza
Arkusz danych formularza dzielonego
Decyduje o tym, czy można edytować dane w arkuszu danych formularza dzielonego
Pasek podziału formularza dzielonego
Decyduje o tym, czy w formularzu dzielonym wyświetla się pasek podziału
Zapisz położenie paska Określa, czy należy zapisać podziału pozycję paska podziału
Edycja dozwolona — edycja danych jest dozwolona Tylko do odczytu — dane są w trybie tylko do odczytu i nie wolno ich modyfikować Tak/Nie Tak/Nie Wartość Automatyczna pozwala Accessowi określić wielkość formularza; można też wprowadzić liczbę, aby samodzielnie określić rozmiar
Rozmiar formularza dzielonego
Rozmiar części formularza dzielonego, w którym wyświetla się formularz
Drukowanie arkusza dzielonego
Określa część formularza dzielonego, która ma być wydrukowana
Podpis nawigacji
Zastępuje słowo „Rekord” obok przycisków nawigacyjnych Do 255 znaków formularza
Tylko formularz — drukuje tę część, w której wyświetla się formularz Tylko arkusz danych — wyświetla część z arkuszem danych
520
Część V Formularze i raporty Accessa
Tabela 18.4. Właściwości danych formularza Właściwość
Opis
Opcje
Źródło rekordów
Określa, skąd pochodzą dane wyświetlane w formularzu
Filtr
Używana do określania podzbioru rekordów, Dowolny łańcuch znaków będący który będzie wyświetlany po zastosowaniu poprawną klauzulą WHERE SQL-a (samego filtru; filtr można ustawić we właściwościach słowa WHERE nie należy wpisywać) formularza, za pomocą makra lub kodu VBA
Filtruj przy ładowaniu
Decyduje o tym, czy filtr będzie zastosowany przy uruchomieniu formularza (raportu)
Tak/Nie
Uporządkuj według
Określa pole lub pola używane do porządkowania danych w widoku
Dowolny łańcuch znaków będący poprawną klauzulą ORDER BY SQL-a (wraz ze słowami ORDER BY)
Porządkuj przy ładowaniu
Decyduje o zastosowaniu sortowania przy uruchomieniu formularza (raportu)
Tak/Nie
Filtry dozwolone
Określa, czy użytkownik może wyświetlać filtrowany formularz
Tak/Nie
Edycja dozwolona
Określa, czy użytkownik może edytować dane; formularz staje się edytowalny albo tylko do odczytu
Tak/Nie
Usuwanie dozwolone
Określa, czy użytkownik może usuwać rekordy
Tak/Nie
Dodawanie dozwolone
Określa, czy użytkownik może dodawać rekordy
Tak/Nie
Wprowadzanie danych
Określa, czy formularz otwiera się na nowym pustym rekordzie, bez wyświetlania zapisanych rekordów
Tak/Nie
Niezwiązane — brak Związane — nazwa tabeli lub kwerendy albo instrukcja SQL-a
Dynamiczny — można aktualizować tylko pola tabeli domyślnej Typ zestawu rekordów
Określa, czy dozwolone jest aktualizowanie formularzy składających się z wielu tabel
Dynamiczny (niespójne aktualizacje) — edytowalne są wszystkie tabele i pola Migawka — żadne pola nie są edytowalne (dane tylko do odczytu) Bez blokowania — rekord jest blokowany tylko podczas zapisu
Blokowanie rekordów
Określa blokowanie rekordów formularzy związanych w środowisku wielodostępnym
Wszystkie rekordy — blokuje wszystkie rekordy formularza podczas korzystania z formularza Edytowany rekord — blokuje tylko aktualnie edytowany rekord
Fetch Defaults
Określa, czy mają być pobrane wartości domyślne
Tak/Nie
Rozdział 18. Praca z danymi w formularzach
521
Tabela 18.5. Inne właściwości formularza Właściwość
Opis
Definicja opcji
Podręczny
Formularz podręczny, wyświetlany ponad wszystkimi Tak/Nie innymi obiektami
Modalny
Przydaje się, kiedy użytkownik musi zamknąć formularz, zanim zrobi cokolwiek innego; wyłącza inne Tak/Nie okna; jeśli właściwość Podręczny jest ustawiona na Tak, wyłącza menu i pasek narzędzi, tworząc okno dialogowe Wszystkie rekordy — naciśnięcie klawisza Tab w ostatnim polu rekordu powoduje przejście do następnego rekordu
Cykliczny
Określa, jak działa klawisz Tab w ostatnim polu rekordu
Bieżący rekord — naciśnięcie klawisza Tab w ostatnim polu rekordu powoduje przejście do pierwszego pola tego rekordu Bieżąca strona — naciśnięcie klawisza Tab w ostatnim polu rekordu powoduje przejście do pierwszego pola bieżącej strony
Pasek menu
Określa alternatywny pasek menu
Poprawna nazwa paska menu
Pasek narzędzi
Za pomocą tej właściwości można określić pasek narzędzi formularza
Poprawna nazwa paska narzędzi
Nazwa wstążki
Nazwa załadowanej niestandardowej wstążki, która ma się wyświetlić po otwarciu formularza
Poprawna nazwa wstążki
Menu skrótów
Określa, czy aktywne są menu podręczne dostępne po kliknięciu prawym przyciskiem myszy
Tak/Nie
Pasek menu skrótów
Określa alternatywny pasek menu skrótów
Poprawna nazwa paska menu skrótów
Szybki wydruk laserowy
Drukuje znaki tekstowe zamiast linii i prostokątów
Tak/Nie
Plik pomocy
Nazwa skompilowanego pliku pomocy, który zawiera niestandardową pomoc na temat formularza
Brak
Identyfikator kontekstu pomocy
Identyfikator pozycji w pliku pomocy, którą należy wyświetlić
Brak
Metka
Ta właściwość przechowuje dodatkowe informacje o formularzu
Brak
Ma moduł
Ta właściwość wskazuje, czy formularz ma moduł klasy; ustawienie Nie usuwa powiązany z formularzem moduł z kodem VBA
Tak/Nie
Użyj domyślnego rozmiaru papieru
Użycie domyślnego rozmiaru papieru podczas drukowania
Tak/Nie
522
Część V Formularze i raporty Accessa
Dodawanie nagłówka lub stopki formularza Choć większość formantów wyświetlających dane zwykle znajduje się w sekcji szczegółów, można dodać do formularza inne opcjonalne sekcje:
Nagłówek formularza — wyświetla się u góry każdej strony i jest umieszczany na wydruku formularza.
Stopka formularza — wyświetla się u dołu każdej strony i jest umieszczana na wydruku formularza.
Nagłówki i stopki formularza pozostają na ekranie, kiedy użytkownik przewija formanty w sekcji szczegółów. Opcje nagłówka i stopki można ustawić w grupie Nagłówek/Stopka w zakładce PROJEKTOWANIE (oczywiście formularz musi się wyświetlać w widoku projektu).
Korzystanie z właściwości sekcji Omówione wcześniej właściwości formularzy dotyczą całego formularza. Każda sekcja formularza ma odrębne właściwości wpływające na wygląd i działanie poszczególnych sekcji. Dla trzech z tych sekcji (Detail, FormHeader i FormFooter, czyli Szczegóły, Nagłówek formularza i Stopka formularza) zestaw właściwości jest prawie taki sam.
Właściwość Widoczny Właściwość Widoczny przyjmuje wartości Tak/Nie i określa, czy dana sekcja jest widoczna czy ukryta. We wszystkich trzech wspomnianych sekcjach właściwość ta domyślnie ma wartość Tak. Sekcja Detail w prawie wszystkich formularzach powinna być widoczna, ponieważ zawiera większość formantów. Sekcje FormHeader i FormFooter można ukryć, jeśli są niepotrzebne. Nagłówek formularza zwykle służy do wyświetlania tytułu i grafiki. Wyświetlanie nagłówka w ciągłych formularzach pomaga użytkownikowi ustalić, co ogląda. Stopka formularza przydaje się do wyświetlania podsumowań lub statusu i może zawierać na przykład bieżącą datę i godzinę.
Właściwość Wysokość Właściwość Wysokość określa w centymetrach wysokość sekcji. Najczęściej właściwość tę modyfikuje się, przeciągając krawędź sekcji za pomocą myszy w dół lub w górę (prowadzi to do zmniejszenia lub zwiększenia wysokości). Gdy otwarty jest arkusz właściwości, można zobaczyć, jak właściwość Wysokość zmienia się przy przeciąganiu krawędzi i zwalnianiu jej w nowym miejscu. Jeśli chcesz ustawić określoną wysokość, zmień wartość właściwości Wysokość zamiast przeciągać krawędź sekcji.
Właściwość Kolor tła Właściwość Kolor tła określa kolor tła formantów. Można zmienić jej wartość za pomocą listy rozwijanej z arkusza właściwości. Access umożliwia wybór spośród wielu wbudowanych kolorów.
Rozdział 18. Praca z danymi w formularzach
523
W arkuszu właściwości znajduje się też przycisk konstruowania, który wyświetla znaną paletę kolorów z polami Kolory motywu i Kolory standardowe. Przycisk Więcej kolorów w dolnej części palety umożliwia określenie dowolnego koloru. Można też wprowadzić kod koloru. Właściwość Kolor tła pozwala wpisać sześciocyfrową liczbę szesnastkową. Liczby szesnastkowe składają się z cyfr od 0 do 9 i liter od A do F (w sumie daje to 16 możliwości). Liczbę szesnastkową należy poprzedzić znakiem kratki (#), np. #000000 oznacza biały, a #FFFFFF — czarny. Ten sposób określania koloru tła jest przydatny, jeśli chcesz zastosować konkretny kolor i znasz jego kod w formacie szesnastkowym. Wielu programistów woli, gdy właściwość Kolor tła sekcji szczegółów jest ustawiona na kolor biały. Ważne jest, aby kolor tła tej sekcji nie odciągał uwagi użytkowników od głównych danych z formularza. Jednak zastosowanie innego konserwatywnego koloru tła pozwala wzbogacić formularz i zapewnić spójny styl we wszystkich formularzach.
Właściwość Efekt specjalny Właściwość Efekt specjalny przyjmuje wartości: Płaski, Wypukły i Wklęsły. Wartość domyślna to Płaski. Ustawienia Wypukły i Wklęsły nadają efekt trójwymiarowości krawędziom sekcji.
Właściwość Kiedy wyświetlać Właściwość Kiedy wyświetlać można ustawić na wartości: Zawsze, Tylko wydruk lub Tylko ekran. Dzięki temu można ukrywać i wyświetlać sekcję w trakcie drukowania. Możliwe, że chcesz wyświetlać sekcje nagłówka i stopki formularza na ekranie, ale na wydruku zamierzasz umieszczać tylko sekcję szczegółów. Aby uzyskać ten efekt, należy ustawić właściwość Kiedy wyświetlać dla sekcji nagłówka i stopki formularza na Tylko ekran oraz pozostawić domyślnie ustawienie Zawsze dla sekcji szczegółów.
Właściwości związane z drukowaniem Większość pozostałych właściwości sekcji (np. Automatyczna wysokość, Można powiększać i Można zmniejszać) dotyczy w większym stopniu raportów niż formularzy. Właściwości te pozwalają dynamicznie kontrolować wysokość sekcji na podstawie zawartych w nich danych, natomiast nie wpływają na wygląd formularzy na ekranie i są rzadko stosowane.
Zmiana układu formularza W tym podrozdziale dowiesz się, w jaki sposób można modyfikować układ formularza za pomocą widoku układu. Widok ten umożliwia dodawanie, przenoszenie i zmianę rozmiaru formantów, a także modyfikowanie pewnych innych własności w trakcie przeglądania danych w formularzu. W czasie, gdy formularz jest otwarty w widoku projektu, wybierz zakładkę ROZMIESZCZANIE w obszarze NARZĘDZIA PROJEKTOWANIA FORMULARZY na wstążce. Zakładka ta zawiera formanty umożliwiające wybór wstępnego układu formularza (obejmuje
524
Część V Formularze i raporty Accessa
to, między innymi, domyślne pozycje formantów w formularzu). Dostępność formantów w zakładce ROZMIESZCZANIE zależy od kontekstu. Widok zaprezentowany na rysunku 18.12 jest rezultatem zaznaczenia kilku formantów w formularzu. W przypadku zaznaczenia innych formatów lub sekcji formularza (nagłówka, stopki itp.) istnieje możliwość uzyskania innego widoku.
Modyfikacja właściwości formantów W poprzednich wersjach Accessa zmiany w formularzu trzeba było wprowadzać w widoku projektu. Widok układu pozwala modyfikować właściwości podczas przeglądania danych. Aby wyświetlić arkusz właściwości wybranego formantu, należy kliknąć polecenie Arkusz właściwości w grupie Narzędzia zakładki PROJEKTOWANIE. Więcej informacji na temat modyfikacji właściwości za pomocą polecenia Arkusz właściwości można znaleźć w rozdziale 17.
Określanie kolejności dostępu Można zauważyć, że klikanie klawisza Tab w celu poruszania się między formantami powoduje przeskakiwanie kursora po ekranie. Trasa poruszania się po formantach może wydawać się dziwna, ale odzwierciedla pierwotną kolejność dodawania pól do formularza. Kolejność dostępu w formularzu to kolejność poruszania się od formantu do formantu po wciśnięciu klawisza Tab. Domyślną kolejnością dostępu jest zawsze kolejność, w jakiej dodawano pola do formularza. Po przesunięciu pola w obrębie formularza zazwyczaj trzeba zmienić kolejności dostępu. Mimo że podczas projektowania formularzy intensywnie korzysta się z myszy, przeciętny użytkownik wprowadzający dane porusza się między polami za pomocą klawiatury. Aby zmienić kolejność dostępu w formularzu, należy wybrać polecenie Kolejność klawisza Tab z grupy Narzędzia zakładki PROJEKTOWANIE. Spowoduje to wyświetlenie okna dialogowego Kolejność dostępu (zobacz rysunek 18.13). W tym oknie dialogowym wyświetlają się formanty w bieżącej kolejności dostępu. W oknie dialogowym Kolejność dostępu nie wyświetlają się formanty niezwiązane z danymi, np. etykiety lub linie. W oknie dialogowym Kolejność dostępu można zaznaczyć jeden wiersz albo wiele wierszy jednocześnie. Aby zaznaczyć kilka sąsiadujących ze sobą wierszy, należy kliknąć pasek zaznaczania pierwszego z nich i przeciągnąć myszą w dół. Zaznaczone wiersze można przeciągnąć w nowe położenie. U dołu okna dialogowego Kolejność dostępu znajduje się kilka przycisków. Jeden z nich, Kolejność automatyczna, porządkuje pola w kolejności od lewej do prawej i od góry do dołu, według ich położenia na formularzu. Warto zacząć od kliknięcia tego przycisku po
Rozdział 18. Praca z danymi w formularzach
525
Rysunek 18.13. Okno dialogowe Kolejność dostępu
istotnej zmianie układu pól. Kliknięcie przycisku OK powoduje zatwierdzenie zmian w formularzu. Kliknięcie przycisku Anuluj powoduje zamknięcie okna dialogowego bez zmiany kolejności dostępu w formularzu. Każdy formant ma dwie właściwości, które są związane z oknem dialogowym Kolejność dostępu. Właściwość Przechodzenie tabulatorami określa, czy naciśnięcie klawisza Tab powoduje przejście do pola. Ustawienie domyślne to Tak. Jeśli zmieni się je na Nie, nie będzie można przejść do pola za pomocą klawisza Tab. Określenie kolejności dostępu polega na ustawieniu właściwości Indeks kolejności dostępu formantów. Przesuwanie pól w oknie dialogowym Kolejność dostępu powoduje zmianę właściwości Indeks kolejności dostępu tych (i innych) formantów.
Modyfikowanie formatu tekstu w formancie Aby zmodyfikować sposób formatowania tekstu w obrębie formantu, należy kliknąć go, a następnie wybrać styl formatowania. Dodatkowe polecenia umożliwiające zmianę formatowania formantów są dostępne w zakładce FORMATOWANIE na wstążce w widoku układu (zobacz rysunek 18.14).
Aby zmienić czcionkę dla formantu Category, przejdź do widoku układu, a następnie wykonaj następujące czynności: 1. Zaznacz pole tekstowe Category poprzez kliknięcie go.
526
Część V Formularze i raporty Accessa
2. Zmień rozmiar czcionki na 14, a następnie kliknij przycisk Pogrubienie w grupie Czcionka zakładki FORMATOWANIE. Po zmianie właściwości czcionki rozmiar formantu nie zmienia się automatycznie. Jeśli w formancie jest widoczny tylko fragment pola tekstowego, możliwe, że trzeba będzie zmienić jego rozmiar tak, aby wyświetlał się cały tekst.
Używanie narzędzia Lista pól do dodawania formantów W oknie Lista pól wyświetlają się pola z tabeli lub kwerendy będącej źródłem danych formularza. Aby wyświetlić okno Lista pól, należy kliknąć polecenie Dodaj istniejące pola w grupie Formanty zakładki FORMATOWANIE. Przeciągnięcie pól z okna Lista pól powoduje dodanie do formularza związanych formantów. Można je zaznaczać i przeciągać pojedynczo. Można też zaznaczyć kilka pól naraz, używając klawiszy Ctrl i Shift. Okno Lista pól w widoku układu działa tak samo jak okno Lista pól w widoku projektu. Szczegółowo opisano je w rozdziale 17. Aby wyświetlić okno Lista pól, należy kliknąć polecenie Dodaj istniejące pola w grupie Formanty zakładki PROJEKTOWANIE. Domyślnie okno Lista pól jest zadokowane po prawej stronie okna Accessa (zobacz rysunek 18.15). Można je przesuwać i zmieniać jego rozmiar. Jeśli zawiera więcej pól, niż może się w nim zmieścić, wyświetla się pionowy pasek przewijania. Rysunek 18.15. Dodawanie pól z okna Lista pól w widoku układu formularza
Access dodaje formant odpowiedni dla typu danych związanego pola. Na przykład przeciągnięcie pola typu tekstowego na obszar formularza spowoduje dodanie pola tekstowego, natomiast pole typu Obiekt OLE dodaje związaną ramkę obiektu.
Rozdział 18. Praca z danymi w formularzach
527
Aby dodać pola z okna Lista pól do nowego formularza, wykonaj następujące czynności: 1. Wybierz tabelę tblProducts w okienku nawigacji. 2. Kliknij zakładkę TWORZENIE na wstążce, a następnie kliknij polecenie Pusty formularz w grupie Formularze, aby wyświetlić nowy formularz w widoku układu. Nowy formularz jest powiązany z tabelą tblProducts. 3. Jeśli okno Lista pól się nie wyświetli, należy kliknąć zakładkę PROJEKTOWANIE, a następnie kliknąć polecenie Dodaj istniejące pola z grupy Formanty. 4. Przytrzymaj klawisz Shift, a następnie kliknij pola ProductID i Cost w oknie Lista pól. 5. Przeciągnij zaznaczone pola z okna Lista pól do formularza tak, jak pokazano na rysunku 18.15. Aby wybrać na liście pola, które ze sobą nie sąsiadują, należy klikać poszczególne pola przy wciśniętym klawiszu Ctrl. Każde podświetlone pole można przeciągnąć (jako grupę) do widoku układu formularza.
Przekształcanie formularza w raport Jeśli otworzysz formularz w widoku projektu i wybierzesz polecenie Plik/Zapisz jako, wówczas możesz zapisać formularz jako raport. Jeśli formularz zawiera nagłówki lub stopki formularza, zostaną one umieszczone w nagłówkach lub stopkach raportu. Jeśli formularz zawiera nagłówki lub stopki strony, zostaną one umieszczone w nagłówkach lub stopkach strony w raporcie. Można teraz wykorzystać raport w widoku projektu i dodawać grupy i inne własności bez konieczności tworzenia całego układu od początku. Więcej informacji na temat raportów znajduje się w dalszych rozdziałach tej książki.
528
Część V Formularze i raporty Accessa
Rozdział 19.
Praca z formantami formularzy W tym rozdziale:
Ustawianie właściwości formularzy i formantów
Tworzenie formantów obliczeniowych
Stosowanie podformularzy
Przegląd podstawowych technik projektowania formularzy
Zaawansowane techniki dotyczące formularzy
Stosowanie zakładek w formularzach
Pobieranie informacji za pomocą okna dialogowego
Tworzenie formularzy od podstaw
Interfejs użytkownika to pojęcie, które często można usłyszeć w trakcie dyskusji na temat oprogramowania. W niemal wszystkich aplikacjach tworzonych za pomocą programu Microsoft Access interfejs użytkownika składa się z zestawu formularzy. Jeśli chcesz tworzyć udane aplikacje Accessa, musisz dobrze poznać techniki korzystania z formularzy. Ten rozdział pomoże Ci wzbogacić wiedzę na temat formularzy. Najpierw zapoznasz się z popularnymi formantami i ich właściwościami. Formanty te to cegiełki, z których tworzy się formularze. Znajdziesz tu także ciekawe sposoby korzystania z podformularzy. Jeden z podrozdziałów poświęcony jest rozmaitym technikom programowania formularzy. Metody te pomogą Ci optymalnie wykorzystać możliwości Accessa i komputera. Dalej zaprezentowaliśmy krok po kroku, jak utworzyć formularz od podstaw. W tym rozdziale został wykorzystany przykładowy kod z bazy danych Rozdział19.accdb oraz inne pliki, które można pobrać z witryny poświęconej tej książce.
530
Część V Formularze i raporty Accessa
Ustawianie właściwości formantów Elementy konstrukcyjne, z których składają się formularze w Accessie, noszą nazwę formantów (ang. controls). Grupa Formanty z zakładki PROJEKTOWANIE zawiera kilkanaście typów formantów, z których można budować formularze. Formanty te to: etykiety, pola tekstowe, grupy opcji, przyciski przełączników, przyciski opcji, pola wyboru, pola kombi, pola listy itd. Rozdział ten nie zawiera szczegółowego omówienia wszystkich formantów formularzy Accessa, ale znajdziesz tu opis większości formantów często stosowanych w aplikacjach Accessa. Każdy formant w formularzu Accessa ma zestaw właściwości, które decydują o jego wyglądzie i działaniu. W widoku projektu można skonfigurować ustawienia właściwości dowolnego obiektu, zaznaczając go i wyświetlając jego arkusz właściwości. Aby wyświetlić arkusz właściwości, należy wykonać jedną z następujących operacji:
Kliknąć obiekt prawym przyciskiem myszy i z menu podręcznego wybrać Właściwości.
Zaznaczyć obiekt i kliknąć na wstążce przycisk Arkusz właściwości.
Wcisnąć klawisz F4 po zaznaczeniu elementu.
Po otwarciu arkusza właściwości wystarczy kliknąć dowolny formant w formularzu, by wyświetlić ustawienia właściwości formantu. Rysunek 19.1 ilustruje arkusz właściwości przycisku cmdNew w formularzu klientów (frmCustomers) aplikacji Rozdział19.accdb. Rysunek 19.1. Arkusz właściwości przycisku polecenia cmdNew
Sam formularz również ma własny zestaw właściwości. Jeśli wyświetlisz arkusz właściwości w widoku projektu, zanim zaznaczysz którykolwiek formant, Access wyświetli arkusz właściwości całego formularza, na co będzie wskazywać tytuł „Formularz” na pasku
Rozdział 19. Praca z formantami formularzy
531
tytułowym arkusza właściwości (zobacz rysunek 19.2). Aby wyświetlić w arkuszu właściwości formularza już po wyświetleniu właściwości któregoś formantu, należy kliknąć całkowicie pusty obszar w oknie projektu formularza (na zewnątrz zdefiniowanego obszaru formularza). Rysunek 19.2. Arkusz właściwości formularza klientów
Modyfikowanie właściwości domyślnych Za każdym razem, gdy tworzysz formant za pomocą wstążki, formant ten jest definiowany z domyślnym zestawem wartości właściwości. Jest to dość oczywiste, lecz możesz nie zdawać sobie sprawy, że sam też możesz ustawiać wartości domyślne. Gdybyś chciał na przykład, aby wszystkie pola list w formularzu były płaskie, a nie zagłębione, mniej czasu zajmie zmiana wartości domyślnej właściwości Efekt specjalny na Płaski przed zaprojektowaniem formularza niż zmienianie indywidualnie właściwości Efekt specjalny każdego pola listy. Aby ustawić wartość domyślną dla formantu, należy zaznaczyć formant i ustawić właściwości w arkuszu właściwości (bez dodawania formantu do formularza). Jak widać, arkusz ten jest teraz zatytułowany Typ zaznaczenia: Domyślny: . Zmieniając właściwości formantu, w rzeczywistości ustawiasz domyślne właściwości danego typu formantu. Zamiast dodać formant do formularza, możesz teraz zaznaczyć inny formant na karcie (np. używając opcji Zaznacz w prawym górnym rogu grupy Formanty), aby zachować domyślne ustawienie. Gdy później ponownie wybierzesz poprzedni formant, jego właściwości domyślne będą ustawione tak, jak chciałeś. Po zapisaniu formularza właściwości domyślne ustawione dla jego formantów także zostaną zachowane.
532
Część V Formularze i raporty Accessa
Modyfikowanie właściwości domyślnych nie tylko oszczędza czas podczas projektowania formularza, ale też może przyspieszyć zapisywanie i otwieranie formularzy. Gdy większość formantów w formularzu ma domyślne ustawienia właściwości, zapisany formularz ma mniejszą objętość, a ponadto szybciej się zapisuje i wczytuje, gdy używa go aplikacja (lecz nie zajmuje mniej miejsca w pamięci).
Często używane formanty i właściwości W tym punkcie opisujemy najczęściej stosowane formanty potrzebne przy tworzeniu aplikacji Accessa, a także właściwości określające wygląd i działanie tych formantów. Nie omówiliśmy tu każdego formantu i wszystkich właściwości. Jednak formanty i właściwości opisane w tym miejscu pomogą Ci dobrze zrozumieć proces tworzenia formularzy. Ponadto wiele właściwości jest dostępnych także w innych formantach. Liczne właściwości współdziałają ze sobą i prowadzą do uzyskania określonych efektów. W arkuszu właściwości tego rodzaju właściwości są wyświetlane obok siebie. Formant Pole tekstowe Formant Pole tekstowe to najważniejszy spośród formantów do wyświetlania danych. Dane w tym formancie to zawsze łańcuchy znaków (nawet gdy wyglądają jak liczba lub data). Najważniejsze właściwości formantów tego rodzaju określają sposób wprowadzania i wyświetlania danych. Właściwość Format
Właściwość Format określa format wyświetlanych danych. Dostępne tu opcje zależą od typu danych powiązanego pola. Na przykład jeśli dane pole tekstowe jest powiązane z polem daty, to dostępne są formaty daty, a w polu tekstowym powiązanym z polem liczbowym znajdują się formaty liczbowe. W niezwiązanych polach tekstowych dostępne są wszystkie formaty. Gdy ustawiony jest odpowiedni format, za pomocą właściwości Miejsca dziesiętne można określić, ile cyfr ma być wyświetlanych po przecinku. Właściwości określające wygląd
Właściwości Styl tła i Kolor tła wyznaczają wygląd tła pola tekstowego. Ustawienie stylu tła na Przezroczysty sprawia, że widoczne są elementy pod formantem. Ustawienie Normalny powoduje, że jako tło wyświetlany jest kolor wybrany we właściwości Kolor tła. Właściwości Styl obramowania, Szerokość obramowania i Efekt specjalny określają wygląd krawędzi pola tekstowego. Można ustawić Styl obramowania na Przezroczysty, aby ukryć obramowanie, lub wybrać jedną z kombinacji linii ciągłych, linii przerywanych i linii kropkowanych. Gdy właściwość Styl obramowania ma wartość inną niż Przezroczysty, za pomocą właściwości Szerokość obramowania można ustawić grubość krawędzi. Właściwość Efekt specjalny udostępnia opcje, które pozwalają wzbogacić wygląd pól tekstowych.
Rozdział 19. Praca z formantami formularzy
533
Właściwości określające wygląd danych
Właściwości Nazwa czcionki i Rozmiar czcionki służą do ustawiania czcionki danych z pól tekstowych. Choć można je ustawić w arkuszu właściwości, częściej zmienia się je za pomocą zakładki FORMATOWANIE na wstążce. Właściwość Wyrównanie tekstu przyjmuje wartości: Ogólne, Do lewej, Do środka, Do prawej i Rozłóż. Opcja Ogólne powoduje wybór wyrównania najlepiej dostosowanego do wyświetlanych danych. Przy opcji Rozłóż Access próbuje zapełnić całą szerokość pola tekstowego, zwiększając w razie potrzeby odstępy między znakami. Właściwości Podkreślenie czcionki i Kursywa przyjmują wartości Tak/Nie oraz określają, czy dane mają być wyświetlane z podkreśleniem lub kursywą. Najczęściej wybierane ustawienie właściwości Grubość czcionki to Pogrubienie, jednak dostępnych jest też kilka innych opcji, które zapewniają dużą kontrolę nad pogrubieniem danych. Właściwość Kolor treści służy do kontrolowania koloru czcionki. Nie jest to jednak zwykła nazwa koloru. Należy wpisać tu liczbę, która reprezentuje kolor tekstu w formancie. Najłatwiejszy sposób ustawienia tej właściwości to zastosowanie polecenia Kolor czcionki z zakładki FORMATOWANIE na wstążce. Właściwości związane z wprowadzaniem danych
Właściwość Format tekstu przyjmuje wartości Zwykły tekst lub Tekst sformatowany. Opcja Tekst sformatowany umożliwia formatowanie znaków w trakcie wprowadzania danych. W czasie wpisywania tekstu w polu z właściwością Format tekstu ustawioną na Tekst sformatowany dostępne są niektóre opcje wstążki, których nie można używać przy ustawieniu Zwykły tekst. Dane są wtedy zapisywane ze znacznikami HTML-a, które określają zastosowane formatowanie. Za pomocą właściwości Maska wprowadzania można wymusić format wpisywanych danych. Istnieje kilka wbudowanych masek wprowadzania (np. dla numeru telefonu lub NIP-u), które można zastosować, aby skłonić użytkowników do wpisywania poprawnych danych. Można też utworzyć własną maskę (np. jeśli firma stosuje numery części w określonym formacie). Właściwość Wartość domyślna służy do zapełniania pola tekstowego określoną wartością w momencie tworzenia nowego rekordu. Oprócz stosowania zapisanych na stałe wartości można przeprowadzać obliczenia, aby w zależności od zawartości innych formantów ustawiać inną wartość domyślną. Właściwości Reguła poprawności i Tekst spr. reguły poprawności można wykorzystać do upewnienia się, czy użytkownik wprowadził w polu tekstowym odpowiednie dane. Możesz na przykład umożliwić wpisywanie w danym polu tekstowym tylko dat z określonego przedziału. Gdy wprowadzone dane nie należą do przedziału określonego we właściwości Reguła poprawności, wyświetlany jest komunikat. Jeżeli reguła została naruszona, właściwość Tekst spr. reguły poprawności służy do wyświetlenia użytkownikowi dodatkowych informacji na temat oczekiwanych danych.
534
Część V Formularze i raporty Accessa
Formant Przycisk polecenia Pole tekstowe to podstawowy formant do wprowadzania danych, natomiast Przycisk polecenia to najważniejszy formant do uruchamiania operacji przez użytkowników. Przyciski polecenia najczęściej służą do uruchamiania makr i kodu VBA. Typowe operacje wiązane z przyciskami polecenia to wyświetlanie innego formularza, przechodzenie do następnego rekordu lub automatyzowanie zadań w innej aplikacji pakietu Office. Właściwości do kontrolowania wyglądu
Liczne właściwości przycisku polecenia związane z wyglądem są takie same jak dla pola tekstowego i działają w bardzo podobny sposób. Przycisk polecenia ma dodatkowo właściwości Typ obrazu i Obraz, które umożliwiają określenie grafiki wyświetlanej jako przycisk. Właściwości Kolor aktywowania, Kolor pierwszego planu po aktywowaniu, Kolor naciśniętego elementu i Kolor pierwszego planu naciśniętego elementu wyznaczają wygląd przycisku polecenia, gdy użytkownik umieści nad nim kursor lub gdy kliknie dany przycisk. Za pomocą tych właściwości można dodać wizualną wskazówkę informującą o lokalizacji kursora myszy. Dzięki temu użytkownik ma pewność, że kliknął właściwy przycisk. Właściwości związane z domyślną operacją
Właściwość Domyślny przyjmuje wartości Tak/Nie. Gdy wartość tej właściwości to Tak, użytkownik może wcisnąć klawisz Enter, gdy kursor znajduje się w dowolnym miejscu formularza, a przyniesie to ten sam efekt co kliknięcie danego przycisku polecenia. Taki przycisk to przydatne narzędzie przyspieszające wprowadzanie danych na formularzu. Także właściwość Anuluj przyjmuje wartości Tak/Nie. Jest ona ściśle związana z właściwością Domyślny. Jeśli jest ustawiona na Tak, użytkownik może wcisnąć klawisz Esc, gdy kursor znajduje się w dowolnym miejscu formularza, a przyniesie to ten sam efekt co kliknięcie danego przycisku polecenia. Zwykle przycisk polecenia z właściwością Anuluj ustawioną na Tak powinien anulować bieżącą operację lub zamykać formularz. Tylko jeden przycisk polecenia można ustawić jako domyślny i tylko jeden można powiązać z operacją anulowania. Gdy dla jednej z omawianych właściwości ustawisz wartość Tak, dla wszystkich pozostałych przycisków polecenia na formularzu zostanie ona ustawiona na Nie.
Formanty Pole kombi i Pole listy Te dwa formanty służą do wyświetlania użytkownikom list w celu ułatwienia wprowadzania danych. Formant Pole listy wyświetla tyle elementów, ile zmieści się w formancie, natomiast formant Pole kombi trzeba kliknąć, aby zobaczyć listę. Nazwa „pole kombi” związana jest z tym, że formant ten to kombinacja pola tekstowego i pola listy. Użytkownik może albo wprowadzić tekst bezpośrednio w części odpowiadającej polu tekstowemu, albo wybrać element z części działającej jak pole listy. Właściwości charakterystyczne dla pól kombi i pól listy określają sposób wyświetlania danych i operacje, jakie użytkownicy mogą wykonywać na liście.
Rozdział 19. Praca z formantami formularzy
535
Właściwości dotyczące zawartości listy
Właściwość Źródło wierszy określa, jakie dane będą wyświetlane na liście. Dane te zwykle pochodzą z tabeli, kwerendy lub instrukcji SQL-a. Mogą też być listą wartości wprowadzonych bezpośrednio we właściwości Źródło wierszy w trakcie projektowania formularza lub w czasie wykonywania programu. Właściwość Typ źródła wierszy określa, jakie opcje są dostępne we właściwości Źródło wierszy. Gdy właściwość Typ źródła wierszy jest ustawiona na Lista wartości, autor formularza może wpisać we właściwości Źródło wierszy listę wartości. Gdy właściwość Typ źródła wierszy ma wartość Tabela/Kwerenda, we właściwości Źródło wierszy można podać nazwę tabeli, nazwę kwerendy lub instrukcję SQL-a. Trzecia możliwa wartość właściwości Typ źródła wierszy to Lista pól. Wtedy w źródle wierszy można podać nazwę tabeli, nazwę kwerendy lub instrukcję SQLa, tak jak przy ustawieniu Tabela/Kwerenda. Różnica polega na tym, że formant wyświetla wtedy listę nazw pól, a nie wartości. Właściwość Kolumna powiązana określa „wartość” formantu. Pola list i pola kombi mogą wyświetlać na liście więcej niż jedną kolumnę danych. Gdy pokazywane są dwie kolumny (lub większa ich liczba), właściwość Kolumna powiązana określa kolumnę, z której dane są zapisywane w polu formantów związanych lub zachowywane do użytku w formantach niezwiązanych. Właściwości związane z wyświetlaniem listy
Właściwość Liczba kolumn określa, ile kolumn lista ma wyświetlać. Jeśli wartość ta jest różna o liczby kolumn w danych (określonych we właściwości Źródło wierszy), niektóre dane mogą się nie pojawić lub część kolumn może być pusta. We właściwości Szerokości kolumn można wpisać rozdzieloną średnikami listę wartości, które reprezentują szerokość każdej kolumny. Jeżeli właściwość ta jest pusta lub gdy podano szerokość dla mniejszej liczby kolumn niż określona we właściwości Liczba kolumn, Access szacuje szerokość kolumn o nieokreślonej wielkości. Właściwość Nagłówki kolumn przyjmuje wartości Tak/Nie i określa, czy w górnej części listy mają pojawiać się nagłówki kolumn. We właściwości Liczba wierszy listy można wpisać wartość określającą, ile wierszy listy ma być widocznych. Jeśli elementów na liście jest więcej niż podano w tej właściwości, pojawia się pionowy pasek przewijania, dzięki któremu użytkownik może przejść w dół, aby zobaczyć dalsze pozycje. Właściwość Szerokość listy określa szerokość listy. Można zastosować szeroką listę i wąskie pole kombi, aby wydajnie wykorzystać przestrzeń na formularzu. Właściwości Liczba wierszy listy i Szerokość listy są niedostępne dla pól listy. W polach listy wyświetlanych jest tyle wierszy, ile się zmieści, a lista jest tak szeroka jak sam formant. Właściwości dotyczące wybierania pozycji z list
W polach kombi właściwości Reguła poprawności, Tekst spr. reguły poprawności i Maska wprowadzania działają tak samo jak w polach tekstowych. Dla pól listy właściwości te są niedostępne, ponieważ użytkownik może tylko wybierać elementy dostępne na liście. Właściwość Ogranicz do listy (dostępna tylko dla pól kombi) przyjmuje wartości Tak/Nie. Wartość Tak zmusza użytkowników do wprowadzania lub wybierania tylko tych wartości, które znajdują się na liście. Pole kombi działa wtedy podobnie jak pole listy. Wartość Nie umożliwia użytkownikom wybór elementu z listy lub wprowadzenie wartości spoza niej.
536
Część V Formularze i raporty Accessa
Właściwość Wybór wielokrotny (dostępna dla pól listy) określa, czy użytkownik może zaznaczyć na liście więcej niż jeden element. Wartość Brak oznacza, że nie jest to możliwe. Przy wartości Prosty można zaznaczyć element lub usunąć zaznaczenie dla poszczególnych elementów po kolei, klikając je. Wartość Rozszerzony sprawia, że można zaznaczyć elementy jeden po drugim przy wciśniętym klawiszu Ctrl lub wybrać blok elementów, przytrzymując klawisz Shift i klikając ostatni element bloku. Formanty Pole wyboru i Przycisk przełącznika Formanty te najczęściej są powiązane z polami typu Tak/Nie. Zaznaczenie w polu wyboru i wciśnięty przycisk przełącznika odpowiadają wartości Tak. Puste pole wyboru i podniesiony przycisk przełącznika to wartość Nie. Wyjątkową właściwością tych formantów jest Stan potrójny. Gdy ma ona wartość Tak, formanty mogą reprezentować trzy wartości: Tak, Nie i Null. Właściwość ta jest przydatna, gdy chcesz sprawdzać, czy użytkownik ustawił w danym polu wartość Tak lub Nie. Formant Grupa opcji Grupa opcji tak naprawdę nie jest formantem. Jest to grupa odrębnych, ale powiązanych ze sobą formantów. Składa się ona z formantu ramki i przynajmniej jednego formantu Przycisk opcji. Przy tworzeniu grup opcji zamiast przycisków opcji można zastosować pola wyboru lub przyciski przełącznika. Pola wyboru i przyciski przełącznika w grupach opcji działają inaczej niż te same formanty poza grupami. W grupach opcji można wybrać tylko jeden formant. Zaznaczenie jednego z formantów powoduje, że z pozostałych automatycznie usuwane jest zaznaczenie. Formant ramki określa wartość zapisywaną w bazie danych. Formant ten ma właściwość Źródło formantu, która określa powiązane pole. Dostępna jest też właściwość Wartość domyślna, która działa tak samo jak w innych formantach. Formanty opcji w ramce nie mają tych właściwości. W formantach opcji dostępna jest natomiast właściwość Wartość opcji. Określa ona wartość przekazywaną do formantu ramki i zapisywaną w polu lub zachowywaną w celu późniejszego zastosowania. Domyślnie Access przypisuje do formantów opcji liczby 1, 2, 3 itd. zgodnie z kolejnością pojawiania się tych formantów w ramce. Właściwość Wartość opcji można zmodyfikować, przy czym należy uważać, aby nie przypisać tej samej liczby do dwóch różnych formantów.
Formant Kontrolka przeglądarki sieci Web Ten formant to mała przeglądarka wyświetlana na formularzu. Można w niej pokazywać dane przydatne dla użytkownika wypełniającego formularz (np. prognozę pogody lub ceny akcji). Najważniejszą właściwością tego formantu jest Źródło formantu. Należy w niej wpisać pewnego rodzaju wyrażenie. Poprawną wartością tej właściwości jest znak równości, po którym następuje ujęty w cudzysłów adres URL witryny. Na przykład wartość ="http://helion.pl" powoduje wyświetlenie podanej strony w formancie Kontrolka przeglądarki sieci Web. Zwykle właściwość ta jest modyfikowana w kodzie VBA na podstawie innych danych wprowadzonych w formularzu.
Rozdział 19. Praca z formantami formularzy
537
Tworzenie formantów obliczeniowych W formantach niezwiązanych właściwość Źródło formantu może być podawana w formie wyrażenia. Podczas ładowania formularza Access oblicza wartość wyrażenia, a następnie odpowiednio wypełnia formant. Aby stworzyć niezwiązany formant obliczeniowy, wykonaj poniższe czynności: 1. Wybierz tabelę tblProducts w okienku nawigacji. 2. Kliknij zakładkę TWORZENIE na wstążce, a następnie kliknij polecenie Pusty formularz w grupie Formularze. Pojawi się nowy formularz w widoku układu. 3. Przeciągnij pola Cost i RetailPrice z okna Lista pól do formularza. 4. Przełącz się do widoku projektu. 5. Kliknij polecenie Pole tekstowe w grupie Formanty i wykreśl je w formularzu. 6. Ustaw właściwość Nazwa na txtCalculatedProfit, a następnie ustaw właściwość Źródło formantu na =[RetailPrice]-[Cost]. 7. Zmień właściwość Format na wartość Waluta oraz właściwość Miejsca dziesiętne na 2. 8. Zmień właściwość Tytuł etykiety na Zysk:. 9. Przełącz się do widoku formularza, aby przetestować obliczenia. Ekran powinien przypominać okno pokazane na rysunku 19.3. W formancie txtCalculatedProfit wyświetla się różnica między wartościami pól RetailPrice i Cost. Rysunek 19.3. Tworzenie formantów obliczeniowych
Praca z podformularzami Podformularze są niezastąpionym narzędziem do wyświetlania razem na jednym ekranie informacji z dwóch różnych tabel lub kwerend. Zazwyczaj stosowane są, gdy rekord głównego formularza ma relacje jeden do wielu ze źródłem rekordów podformularza. Większa liczba rekordów w podformularzu jest kojarzona z jednym rekordem w formularzu głównym. Access używa właściwości Nadrzędne pola łączące i Podrzędne pola łączące formantu podformularza do określania wyświetlanych w nim rekordów, które są powiązane z rekordami formularza głównego. Gdy wartość w polu łączącym formularza głównego się zmienia, Access automatycznie odświeża zawartość podformularza.
538
Część V Formularze i raporty Accessa
Tworząc podformularz, możesz chcieć wyświetlić jego zbiorcze informacje w formularzu nadrzędnym — na przykład podać liczbę rekordów podformularza gdzieś na formularzu głównym. Przykładem tej techniki może być formant txtItemCount w formularzu frmCustomerSales z bazy Rozdział19.accdb. W tym przypadku wyrażenie Źródło formantu formantu txtItemCount wygląda tak: ="(" & [subfPurchases].[Form]![txtItemCount] & ")"
Warto zauważyć, że znak równości jest niezbędny. Wynik działania tego wyrażenia został przedstawiony na rysunku 19.4. Rysunek 19.4. Dane zbiorcze z podformularza mogą zostać wyświetlone na formularzu głównym
Zanim będzie można umieścić dane zbiorcze na formularzu głównym, ich wartość musi zostać znaleziona w podformularzu. W tym celu umieść pole tekstowe w dowolnym miejscu podformularza i ustaw w jego właściwości Widoczny wartość Nie (False), aby ukryć formant. Wyrażenie zbiorcze, na przykład = Policz([ProductID]), należy zapisać we właściwości Źródło formantu. W głównym formularzu należy teraz wstawić nowe pole tekstowe z następującą wartością właściwości Źródło formantu: =[Podformularz1].Form![Formant zbiorczy]
Podformularz1 jest tutaj nazwą formantu w formularzu głównym zawierającego osadzony podformularz, a Formant zbiorczy to nazwa formantu w podformularzu zawierającego dane zbiorcze. Nazwa formantu formularza głównego (tu jest to Podformularz1) nie musi być nazwą zawartego w formancie obiektu formularza. Gdy dodasz człon .Form do nazwy formantu, oznacza to, że wskazujesz powiązany formularz. Nazwa obiektu nie jest wtedy konieczna.
Formant w głównym formularzu jest aktualizowany przy każdej zmianie wartości w podformularzu.
Rozdział 19. Praca z formantami formularzy
539
Wskazówki z zakresu projektowania formularzy Niniejszy podrozdział zawiera garść wskazówek, które mogą przydać się podczas projektowania formularzy. Mamy nadzieję, że zainspirują Cię do wymyślenia wielu innych.
Wykorzystanie właściwości Tab Stop Od czasu do czasu zachodzi potrzeba umieszczenia w formularzu formantu, którego zadaniem jest uruchomienie poważnej operacji, na przykład usunięcie rekordu lub wydrukowanie długiego raportu. Aby zmniejszyć ryzyko przypadkowego użycia formantu, możemy skorzystać z właściwości Tab Stop. Określa ona, czy można aktywować formant za pomocą klawisza Tab. Załóżmy na przykład, że umieściłeś w formularzu przycisk polecenia o nazwie cmdDelete, który usuwa bieżący rekord. Nie chcesz, by użytkownik kliknął ten przycisk przez pomyłkę. Zmieniając wartość właściwości Tab Stop przycisku cmdDelete na Nie (wartość domyślna to Tak), można usunąć przycisk z kolejności tabulacji formularza. Użytkownik będzie musiał bezpośrednio kliknąć przycisk, aby go aktywować, a nie będzie mógł przypadkowo wybrać przycisku podczas wprowadzania danych.
Zliczanie pól wyboru Jeśli kiedykolwiek zajdzie potrzeba ustalenia liczby wartości True w polach wyboru, możemy posłużyć się wyrażeniem: Suma(Abs([CheckBoxControl]))
Funkcja Abs przekształca wszystkie wartości -1 na 1, a funkcja Sum dodaje je do siebie. Aby policzyć wartości False, należy użyć wyważenia: Suma([CheckBoxControl] + 1)
W ten sposób przed zsumowaniem wartości True (-1) zostaną przekształcone na 0, a False (0) na 1.
Szybsze odświeżanie z użyciem SQL-a Szybsze odświeżanie pól kombi w formularzu można osiągnąć, używając jako źródła wiersza formantu instrukcji SQL-a zamiast nazwy kwerendy. Proces wygląda następująco: 1. Zaznacz pole kombi i otwórz arkusz właściwości. 2. Kliknij przycisk Konstruuj przy właściwości Źródło wierszy formantu. 3. W konstruktorze kwerend utwórz kwerendę pobierającą wiersze pola kombi. 4. Wybierz widok arkusza danych, aby się upewnić, czy pobierane są właściwe dane. Gdy zamkniesz konstruktor kwerend, instrukcja SQL-a z utworzonej właśnie kwerendy zostanie ustawiona jako wartość właściwości Źródło wierszy.
540
Część V Formularze i raporty Accessa
Techniki związane z polami kombi i polami list Pola kombi i pola list są bardzo efektywnymi narzędziami do budowy formularzy, lecz ich konfigurowanie może być skomplikowane. Podczas tworzenia pól kombi i pól list należy pamiętać o różnicy pomiędzy właściwością Źródło formantu, wskazującą kwerendę lub tabelę, do i z której formant zapisuje i odczytuje dane, a właściwością Źródło wierszy, która jest źródłem danych wyświetlonych na liście. Pola list i kombi mogą zawierać więcej niż jedną kolumnę, więc pozwalają z łatwością pobierać powiązane dane z innej tablicy bez konieczności stosowania w formularzu kwerendy, która będzie złączać tabele. Ta technika, wykorzystująca związany formant pola kombi lub listy, przechowująca numery identyfikacyjne, lecz na liście wyświetlająca nazwiska, została użyta w polu kombi Organization w formularzu frmContacts_Northwind z bazy danych Rozdział19.accdb, jak również w kilku innych formularzach przykładowej bazy danych firmy Northwind. Załóżmy, że chcesz utworzyć formularz do wyświetlania informacji o klientach i osobach kontaktowych („kontaktach”). Chcesz identyfikować organizację, z którą kontakt jest powiązany. W dobrze zaprojektowanej bazie danych każdy rekord kontaktu powinien zawierać tylko numer identyfikacyjny organizacji, natomiast nazwy organizacji i inne związane z nimi dane powinny znajdować się w osobnej tabeli. Chcesz, by formularz zawierał pole kombi wyświetlające na liście nazwy i adresy organizacji, lecz przechowujące w polu numery identyfikacyjne (przykład zastosowania tej techniki zawiera formularz frmContacts_Northwind z bazy Rozdział19.accdb). Aby osiągnąć taki cel projektowy, należy utworzyć pole kombi złożone z kilku kolumn. We właściwości Źródło formantu ustaw pole OrgID (pole tabeli Contacts, zawierające numery identyfikacyjne organizacji dla wszystkich osób kontaktowych). We właściwości Typ źródła wierszy pola kombi ustaw wartość Tabela/kwerenda. Można oprzeć listę na tabeli, lecz tu lista nazwisk powinna być posortowana, więc zamiast tego we właściwości Źródło wierszy ustaw kwerendę, która w pierwszym polu zawiera numery OrgID, a w drugim — posortowane rosnąco nazwy organizacji. Najlepiej będzie posłużyć się do utworzenia instrukcji SQL-a narzędziem Konstruktor kwerend we właściwości Źródło wierszy; można też w celu otrzymania listy utworzyć i zapisać kwerendę. W przykładowym formularzu frmContacts_Northwind pole kombi Organization we właściwości Źródło wierszy ma zapisaną następującą kwerendę: SELECT Organizations.OrgID, Organizations.Name, Organizations.AddressLine1, Organizations.AddressLine2, Organizations.City, Organizations.State, Organizations.ZipCode, Organizations.Country FROM Organizations ORDER BY Organizations.Name
Wszystkie te dane mają się pojawiać w polu kombi, więc we właściwości Liczba kolumn należy ustawić wartość 8. Za chwilę ukryjesz kolumnę OrgID, lecz będzie ona potrzebna we właściwości Źródło wierszy pola kombi, ponieważ zawiera dane, które zostają zapisane, gdy użytkownik wybiera wiersz. Kolumnę tę zidentyfikuje właściwość Kolumna związana pola kombi (mająca domyślnie wartość 1). Kolumna związana, zawierająca numery identyfikacyjne, nie musi być widoczna dla użytkownika. Właściwość Szerokości kolumn zawiera w menu rozwijanym listę oddzielonych od siebie średnikami szerokości kolumn. Access do ustalenia szerokości wszystkich kolumn, dla których nie podano szerokości wprost, używa algorytmów domyślnych. Jeśli dla dowolnej kolumny
Rozdział 19. Praca z formantami formularzy
541
podasz szerokość 0, kolumna taka będzie na ekranie niewidoczna dla użytkownika, lecz dostępna dla innych formularzy, kodu VBA i makr. W tym przykładzie ustaw następującą wartość właściwości: 0cm;3,556cm;3,048cm;1,778cm;1,778cm;0,762cm;1,27cm;0,762cm
W ten sposób wskażesz, że pierwsza kolumna ma być niewidoczna, i bezpośrednio ustawisz szerokości pozostałych kolumn. Do drugiej kolumny, która tu zawiera nazwę organizacji, jest dopasowywany tekst wprowadzany przez użytkownika. Do tego celu zawsze używana jest pierwsza kolumna w polu kombi. Rysunek 19.5 ilustruje otrzymaną listę rozwijaną. Wprawdzie taki przykład zapełniania pola kombi danymi jest dość ekstremalny, lecz dobrze ilustruje duże możliwości formantu pola kombi w Accessie.
Rysunek 19.5. Lista rozwijana w polu kombi Organizacja
Jeśli dla pola kombi ustawisz we właściwości Ogranicz do listy wartość Tak, użytkownik będzie mógł jedynie wybierać pozycje dostępne na liście rozwijanej. Będzie można wtedy zbudować dla zdarzenia formantu Przy wartości spoza listy procedurę zdarzenia obsługującą sytuację, gdy użytkownik wprowadzi wartość nieobecną na liście. Można wtedy otworzyć formularz, do którego użytkownik będzie mógł wpisać nowe dane, albo wyświetlić okno komunikatu, informujące użytkownika, jaką procedurą powinien się posłużyć, by dodać dane. Szczegółowe omówienie zdarzenia Przy wartości spoza listy znajdziesz w rozdziale 25.
542
Część V Formularze i raporty Accessa
Techniki zaawansowane Access zawiera wiele rozbudowanych i interesujących funkcji związanych z projektowaniem formularzy i interfejsu użytkownika. Jak wiadomo, formularze w aplikacji są głównym elementem interfejsu użytkownika. Postrzeganie przez użytkowników łatwości korzystania z aplikacji i jej możliwości jest w dużym stopniu zdeterminowane przez atrakcyjność i skuteczność interfejsu. Dobrą wiadomością jest to, że Microsoft wyposażył formularze Accessa w bogate funkcje kontroli interfejsu użytkownika. Sporo z tych funkcji jest dostępnych w Accessie od dawna, lecz przez wielu autorów aplikacji nie zostały jeszcze odkryte.
Formanty numeru strony i daty/godziny Bardzo często formularze zawierają bieżącą datę i godzinę. Wielu programistów dodaje te informacje do formularzy i raportów jako niezwiązane pole tekstowe i używa funkcji Date() do zwracania informacji do takiego pola tekstowego. Access upraszcza ten proces poprzez polecenie Data i godzina w grupie Nagłówek/stopka zakładki PROJEKTOWANIE na wstążce (zobacz rysunek 19.6).
Rysunek 19.6. Widoczne tu polecenia upraszczają dodawanie dat i numerów stron do formularzy i raportów
Rysunek 19.6 przedstawia wstążkę widoczną po otwarciu formularza w widoku projektu. Po wybraniu polecenia dodania daty Access wyświetla okno dialogowe Data i godzina (zobacz rysunek 19.7), w którym można określić format daty i godziny. Gdy użytkownik wybierze odpowiednie ustawienia i kliknie przycisk OK, Access doda nagłówek formularza z datą i godziną sformatowanymi w żądany sposób. Data i godzina widoczne w nagłówku odzwierciedlają czas otwarcia formularza (nie musi to być aktualna godzina). Rysunek 19.7. Informowanie Accessa o pożądanym wyglądzie daty
Rozdział 19. Praca z formantami formularzy
543
Grupa Nagłówek/stopka obejmuje też inne polecenia. Pozwalają one dodać logo (niemal dowolny plik graficzny) i tytuł do nagłówka formularza. Zastosowanie w aplikacji formantów z grupy Nagłówek/stopka zapewnia spójny wygląd wszystkich formularzy (zobacz rysunek 19.8 — przedstawiono na nim formularz frmDialog z przykładowej bazy danych). Rysunek 19.8. Formanty nagłówka i stopki zapewniają spójny wygląd formularzy Accessa
Stosowanie formantu Obraz Subtelny i często niezauważany problem z wydajnością występuje w aplikacjach Accessa, gdy do formularzy dodawane są statyczne obrazy. Obrazy te często umieszczane są w formularzach Accessa jako obiekty OLE, co oznacza, że utrzymanie połączenia obrazu z nadrzędną aplikacją wymaga pewnej ilości pamięci operacyjnej i miejsca na dysku. Takie dodatkowe zużycie zasobów występuje nawet wtedy, gdy obrazem jest logo firmy lub inna grafika, która nie będzie ulegać zmianom podczas wykonywania programu. Access upraszcza ten proces i zapewnia znacznie większą elastyczność poprzez formant Obraz. Formant ten umieszcza ramkę z obrazem w formularzu lub raporcie, przy czym obiekt obrazu nie zużywa zasobów związanych z obiektami OLE. Formant Obraz przyjmuje praktycznie wszystkie typy plików graficznych rozpoznawane przez system Windows (.bmp, .pcx, .ico, .dib, .gif, .wmf, .jpg, .png, .tif itd.) i pozwala wskazać ścieżkę do pliku graficznego podczas wykonywania programu we właściwości Obraz. Formant ten przyjmuje również dane obrazów przechowywane w tabelach Accessa, aczkolwiek nie pozwala na edycję grafiki w miejscu.
Morfing formantów Jednym ze zdecydowanie najbardziej frustrujących problemów podczas tworzenia formularzy Accessa jest konieczność określenia typu formantu, gdy zostaje on dodany do formularza. Wyobraź sobie na przykład, że dodajesz do formularza Accessa pole listy, definiujesz dla niego Źródło formantu, Typ źródła wierszy, Źródło wierszy i inne właściwości, po czym orientujesz się, że na formularzu nie ma wystarczająco dużo miejsca na pole listy. W takim przypadku jedynym rozwiązaniem wydaje się być usunięcie pole listy, dodanie pola kombi i ponowne zdefiniowanie wszystkich właściwości, nawet jeśli będą identyczne jak właściwości pola listy, które właśnie usunięto. W Accessie istnieje możliwość zmiany formantu na dowolny inny, zgodny z nim (ten proces czasem nazywa się morfingiem formantu). Pole tekstowe na przykład można zmienić na etykietę, pole listy lub pole kombi. Wystarczy kliknąć formant prawym przyciskiem myszy i wybrać z menu podręcznego opcję Zmień na, aby zobaczyć listę dostępnych opcji. Rysunek 19.9 przedstawia opcje zmiany dla formantu pola tekstowego.
544
Część V Formularze i raporty Accessa
Rysunek 19.9. Access pozwala zmienić typ formantu bez utraty właściwości, które zostały już ustawione
Opcje dostępne w menu podręcznym są zależne od typu zmienianego formantu. Na przykład przycisk opcji można zmienić w pole wyboru lub przełącznik, lecz nie w pole tekstowe.
Malarz formatów Access zawiera narzędzie Malarz formatów, które działa niemal identycznie jak analogiczna funkcja programu Word. Podczas tworzenia formularza można ustawić wygląd formantu (obramowanie, czcionkę, efekty specjalne — np. wypukły lub wklęsły), a następnie kliknąć przycisk Malarz formatów w sekcji Czcionka zakładki FORMATOWANIE na wstążce, aby skopiować właściwości formantu do specjalnego wewnętrznego bufora. Po kliknięciu innego formantu tego samego typu właściwości wyglądu wybranego formantu zostaną do niego przeniesione. Na rysunku 19.10 właściwości formantu pola tekstowego są właśnie przenoszone na pole tekstowe City (ikona pędzla obok wskaźnika myszy informuje, że program działa w trybie „malowania”). Malarz formantów może zostać „zablokowany” przez dwukrotne kliknięcie jego przycisku na wstążce Accessa. Należy pamiętać, że nie wszystkie właściwości zostają przeniesione na drugi formant. Malarz formantów nie wpływa na rozmiary, położenie i dane zawarte w formancie — ma wpływ jedynie na najbardziej podstawowe właściwości tekstu.
Rozdział 19. Praca z formantami formularzy
545
Rysunek 19.10. Malarz formatów pozwala z łatwością skopiować wygląd formantu na inne formanty w formularzu
Dodatkowa pomoc dla użytkowników Począwszy od pakietu Office 4.x, wszystkie produkty Microsoftu zawierają pomoc w postaci etykietek ekranowych (ToolTip) — żółtych ramek z tekstem, które pojawiają się, gdy najedziemy kursorem myszy na formant lub przycisk (Microsoft nazywa te podpowiedzi wskazówką formantu). Do formularzy Accessa wskazówki ekranowe można dodawać, wpisując tekst pomocy do właściwości Tekst etykietki formantu (zobacz rysunek 19.11). Domyślnie tekst we wskazówce ekranowej nie jest zawijany, lecz można dodać do niego znak nowego wiersza przez naciśnięcie Ctrl+Enter w miejscu, w którym tekst wskazówki powinien zostać złamany. Zaleca się konsekwentne stosowanie etykietek ekranowych w całej aplikacji. Użytkownicy, którzy przyzwyczaili się do etykietek ekranowych, będą ich oczekiwać we wszystkich formantach, z wyjątkiem najbardziej oczywistych.
Dodawanie obrazów tła Atrakcyjne formularze są zawsze cennym dodatkiem do aplikacji Accessa. Trudno jest dodawać kolory lub grafikę do formularza bez utraty czytelności danych zawartych w formularzu. Access pozwala z łatwością dodawać grafikę do tła formularza — coś w rodzaju znaku wodnego, jak na papierach wartościowych. Obraz może zawierać logo
546
Część V Formularze i raporty Accessa
Rysunek 19.11. Etykietki ekranowe ułatwiają korzystanie z aplikacji
firmy, tekst lub dowolne inne elementy graficzne. Obraz jest definiowany we właściwości Obraz formularza i może być osadzony w formularzu lub dołączony z zewnętrznego pliku graficznego. W przypadku pliku zewnętrznego grafika na formularzu zmienia się po zmodyfikowaniu danego pliku. Obraz może też być przysunięty do dowolnego z czterech rogów formularza lub wyśrodkowany. Wprawdzie grafika może zostać przycięta, rozciągnięta lub powiększona tak, by pasowała do rozmiarów formularza, nie można jej zmniejszyć (oczywiście nie licząc bezpośredniej edycji pliku obrazu). Rysunek 19.12 przedstawia mały obraz tła (samochód) umieszczony w prawym górnym rogu formularza frmCustomerSales. Rysunek 19.12. Mały plik .bmp został dodany do formularza frmCustomerSales we właściwości Obraz
Rozdział 19. Praca z formantami formularzy
547
Można nawet skonfigurować formanty jako przezroczyste, dzięki czemu będzie przez nie widoczny obraz tła (zobacz rysunek 19.13). W tym przykładzie (frmEmployees_Background) dla wszystkich formantów etykiet został ustawiony styl tła Przezroczysty, co pozwala zobaczyć przez nie obraz tła. Rysunek 19.13. Przezroczyste formanty pozwalają zobaczyć obraz tła
Oczywiście łatwo jest przesadzić z obrazami tła dodawanymi do formularzy Accessa, lecz grafika użyta z rozwagą może ułatwić użytkownikom zrozumienie formularza. Ostrzegamy jednak, że obrazy tła dodane do formularzy znacznie spowalniają wyświetlanie formularzy na ekranie. Obraz tła należy stosować wtedy, gdy korzyści z dodania grafiki są ważniejsze niż nieuniknione pogorszenie wydajności spowodowane obecnością obrazu.
Ograniczanie liczby rekordów wyświetlanych w formularzu Zwykle zbiór rekordów wyświetlany w formularzu zależy od właściwości Źródło rekordów. Aby wyświetlić mniejszą liczbę rekordów, należy zmodyfikować używaną kwerendę lub instrukcję SQL-a. Czasem jednak programista chce, aby formularz domyślnie pokazywał tylko podzbiór rekordów, ale umożliwiał użytkownikom wyświetlenie wszystkich danych. Za pomocą właściwości Filtr formularza można utworzyć filtr, który ogranicza listę wyświetlanych rekordów. Na przykład w formularzu z informacjami o zamówieniach można wyświetlać tylko niewysłane jeszcze zamówienia i jednocześnie umożliwiać zobaczenie pełnej listy. Jeśli ustawisz właściwość Filtr na [Shipped Date] Is Null, a właściwość Filtruj przy ładowaniu — na Tak, formularz po otwarciu będzie wyświetlał tylko rekordy bez daty wysyłki. Na rysunku 19.14 pasek stanu formularza informuje, że zastosowano filtr.
548
Część V Formularze i raporty Accessa
Rysunek 19.14. Pasek stanu informuje, że w formularzu zastosowano filtr
Użytkownik może kliknąć przycisk Filtrowane na pasku stanu, aby wyłączyć filtr i wyświetlić wszystkie rekordy. Nazwa przycisku zmieni się wtedy na Nieodfiltrowany. Następne kliknięcie przycisku spowoduje ponowne zastosowanie filtra.
Korzystanie z formantu Karta Formant Karta pozwala umieścić w formularzu kilka stron, z których każda jest dostępna przez zakładkę na górze, dole lub z boku okna dialogowego. Rysunek 19.15 przedstawia formularz frmCustomers, który jest doskonałym przykładem formularza Accessa z kilkoma kartami. Zawiera on trzy karty, dzięki czemu może pomieścić o wiele więcej formantów niż bez zastosowania kart. Każda zakładka na górze formularza otwiera osobną stronę danych. Każda strona zawiera szereg formantów. Rysunek 19.15 przedstawia przyciski, etykiety i pola tekstowe. Każdy formant na stronie zachowuje się niezależnie od wszystkich pozostałych formantów formularza i może być dostępny z kodu VBA Accessa jako niezależna jednostka. Jak można się domyślić, formant Karta jest dość złożony. Ma własne właściwości, zdarzenia, metody i zbiory obiektów. Skuteczne wykorzystanie kart w aplikacji wymaga znajomości i zrozumienia tych elementów. Programiści często używają słowa „zakładka”, gdy mają na myśli stronę w oknie dialogowym z zakładkami. W tym rozdziale pojęcia „karta” i „zakładka” są stosowane zamiennie.
Rozdział 19. Praca z formantami formularzy
549
Rysunek 19.15. Formant Karta pozwala pomieścić dużą ilość danych w formularzu
Formant Karta składa się z szeregu stron. W interfejsie użytkownika najszybszą i najprostszą metodą dodania lub usunięcia strony jest kliknięcie formantu prawym przyciskiem myszy i wybranie odpowiedniego polecenia z menu podręcznego (zobacz rysunek 19.16). Rysunek 19.16. Menu podręczne formantu Karta zawiera odpowiednie polecenia
Formant Karta udostępnia kilka specjalnych właściwości. Część z nich opisaliśmy w tabeli 19.1. Pozwalają one dostosować karty w aplikacji do potrzeb użytkowników.
550
Część V Formularze i raporty Accessa
Tabela 19.1. Ważne właściwości formantu Karta Właściwość
Opis
Tytuł
Dotyczy każdej strony formantu i określa tekst, który pojawi się na zakładce.
Wiele wierszy
Dotyczy formantu Karta. Decyduje, czy zakładki pojawią się w jednym rzędzie, czy w kilku. Nie można wybrać, ile zakładek pojawi się w każdym rzędzie. Access wyświetla tyle rzędów, ile potrzeba, aby wyświetlić wszystkie zakładki, uwzględniając ich szerokości.
Styl
Domyślnie karty wyświetlane są jako zakładki. Alternatywne ustawienie (przyciski) wymusza wyświetlenie kart jako przycisków poleceń.
Stała wysokość karty
Ta wartość ustala wysokość (w calach lub centymetrach, zależnie od jednostek wybranych w Panelu sterowania systemu Windows) zakładek formantu. Gdy Stała wysokość karty ma wartość 0, o wysokości zakładki decyduje rozmiar czcionki.
Ta wartość ustala szerokość (w calach lub centymetrach) zakładek formantu. Tekst zbyt Stała szerokość długi, by zmieścił się na zakładce, gdy wartość Stała szerokość karty jest zdefiniowana, karty zostaje okrojony. Gdy Stała szerokość karty ma wartość 0, o szerokości zakładki decyduje rozmiar czcionki i długość tekstu podanego we właściwości Tytuł karty. Obraz
Stosuje się do wszystkich kart formantu. Określa obraz (.bmp, .ico lub wbudowany), który ma zostać wyświetlony na zakładce.
Formant Karta może zawierać formanty praktycznie dowolnego typu, w tym pola tekstowe, pola kombi i list, przyciski opcji i pola wyboru oraz obiekty OLE. Może nawet mieścić inne formanty Karta! Wprawdzie jeden formularz może zawierać kilka formantów Karta, lecz przytłaczanie użytkownika poprzez umieszczenie na formularzu więcej niż jednego formantu tego typu nie jest najlepszym pomysłem. W końcu zadaniem formantu Karta w aplikacji jest uproszczenie formularza przez umieszczenie kilku stron formantów w jednym formancie. W większości przypadków męczenie użytkownika przez udostępnienie w formularzu więcej niż jednego formantu Karta nie ma większego sensu.
Pobieranie informacji za pomocą okien dialogowych Okna dialogowe są jednym z najcenniejszych składników interfejsu użytkownika w aplikacjach systemu Windows. Poprawnie zaimplementowane pozwalają rozszerzyć dostępną powierzchnię ekranu komputera. Zamiast umieszczać wszystkie pola tekstowe, przyciski opcji i inne formanty służące do wprowadzania informacji na głównym formularzu, używając okien dialogowych można przenieść część formantów do wygodnych elementów wyskakujących, pojawiających się na ekranie tylko wtedy, gdy będą potrzebne. Okna dialogowe zwykle służą do pobierania określonych typów informacji, na przykład atrybutów czcionki lub parametrów wydruku. Są cennym narzędziem do wstępnego filtrowania lub kwalifikowania danych wprowadzanych przez użytkownika, bez „zaśmiecania” głównego formularza. Można też posłużyć się oknem dialogowym, by pozwolić użytkownikowi wprowadzić kryteria kwerendy przed wykonaniem kwerendy, która zapełni formularz lub raport, albo zgromadzić informacje, które zostaną dodane do obszaru nagłówka lub stopki raportu.
Rozdział 19. Praca z formantami formularzy
551
Wprawdzie okna dialogowe są formularzami, lecz nie powinny wyglądać ani zachowywać się jak inne formularze aplikacji. Okna dialogowe są wyświetlane ponad obszarem pracy użytkownika. Poprawnie zaimplementowane okna dialogowe powinny umożliwić również proste anulowanie kwerendy bez utraty czegokolwiek w przestrzeni roboczej użytkownika. Rysunek 19.8 ilustruje typowy formularz kwerendy, zaimplementowany jako okno dialogowe. Taki prosty formularz gromadzi informacje, które posłużą do pobrania z bazy danych informacji związanych z zamówieniem. Kilka istotnych właściwości tego okna dialogowego przedstawia tabela 19.2. Tabela 19.2. Ustawienia właściwości dla formularzy okien dialogowych Właściwość
Ustawienie
Przeznaczenie
Paski przewijania
Żaden
Paski przewijania nie są potrzebne w oknie dialogowym.
Przyciski nawigacyjne
Nie
Przyciski nawigacji są niepotrzebne.
Podręczny
Tak
Umieszcza formularz nad innymi formularzami aplikacji.
Modalny
Tak
Uniemożliwia użytkownikowi pracę z innymi obszarami aplikacji, dopóki okno dialogowe nie zostanie zamknięte.
Selektory rekordów
Nie
Niepotrzebne.
Styl obramowania
Dialog
Ustawia szerokie obramowanie, którego nie można przeskalować, oraz usuwa przyciski Minimalizuj i Maksymalizuj.
Menu skrótów
Nie
Niepotrzebne.
Po wprowadzeniu tych zmian otrzymasz formularz, który zawsze będzie znajdować się na wierzchu i nie zniknie z ekranu, dopóki użytkownik nie kliknie przycisku Wykonaj kwerendę lub Anuluj. Podczas tworzenia okien dialogowych należy trzymać się kilku zasad, które zapewnią, że otrzymane okno dialogowe będzie zachowywać się zgodnie z ogólnie przyjętym zachowaniem okien dialogowych systemu Windows.
Projektowanie kwerend Gdy użytkownik kliknie przycisk Wykonaj kwerendę przy otwartej przykładowej kwerendzie qryDialog, Access ją uruchomi. W kwerendzie tej znajduje się specjalne kryterium, które wykorzystuje wartość z jedynego pola tekstowego formularza do ograniczenia liczby wyświetlanych rekordów. Oto instrukcja SQL-a dla kwerendy qryDialog: SELECT Contacts.FirstName, Contacts.LastName Contacts.City, Contacts.State, Contacts.ZipCode FROM Contacts WHERE (((Contacts.ZipCode)=[Forms]![frmDialog] ![tbxZipCode]));
W klauzuli WHERE używane jest pole tbxZipCode. Jeśli formularz jest otwarty, kwerenda ta może pobrać wartość z tego pola i wykorzystać ją jako kryterium.
552
Część V Formularze i raporty Accessa
Konfigurowanie przycisków poleceń Gdy programista dodaje przycisk polecenia do formularza, Access wyświetla kreator, który pomaga zdefiniować operacje uruchamiane za pomocą tego przycisku. Na rysunku 19.17 dla przycisku Uruchom kwerendę wybrano operację Uruchom kwerendę. Rysunek 19.17. Przypisywanie operacji do przycisku polecenia
Na następnym ekranie kreatora wybrano qryDialog jako uruchamianą kwerendę. Gdy użytkownik kliknie nowy przycisk, kwerenda zostanie uruchomiona i wykorzysta zawartość pola tekstowego z formularza jako kryterium. Podobnie można skonfigurować przycisk Anuluj. Dla niego w kreatorze należy wybrać zadanie Zamknij formularz z kategorii Operacje na formularzach.
Wybór przycisku domyślnego Formularz powinien zawierać przycisk, który zostanie automatycznie wybrany, jeśli użytkownik naciśnie klawisz Enter, mając otwarte okno dialogowe. Użytkownik nie musi wybierać przycisku domyślnego, by go aktywować; Access robi to automatycznie, zgłaszając zdarzenie Click po naciśnięciu klawisza Enter. Załóżmy, że użytkownik wprowadził wartość 22152 w polu tekstowym z kodem pocztowym i nacisnął Enter. Jeśli nie zdefiniowano przycisku domyślnego, kursor po prostu przejdzie do następnego formantu. Jeśli ustawiono przycisk Wykonaj kwerendę jako domyślny dla okna dialogowego, Access zinterpretuje naciśnięcie klawisza Enter jako zdarzenie Click dla wspomnianego przycisku. Aby wybrać przycisk Wykonaj kwerendę jako domyślny dla tego okna dialogowego, należy ustawić we właściwości Domyślny tego przycisku wartość Tak. Tylko jeden przycisk formularza może mieć we właściwości Domyślny wartość Tak — jeśli teraz zmienisz na Tak właściwość przycisku Anuluj, Access automatycznie zmieni wartość Domyślny przycisku Wykonaj kwerendę na Nie. Standardowo wyznaczony przycisk domyślny znajduje się po lewej stronie formularza. Jeśli przyciski poleceń są na formularzu rozmieszczone w pionie, domyślnym powinien być przycisk znajdujący się na górze.
Rozdział 19. Praca z formantami formularzy
553
Jako domyślny przycisk formularza należy wybrać taki, który nie sprawi problemów w razie przypadkowego naciśnięcia. Na przykład, aby uniknąć ryzyka utraty danych, nie należy wybierać jako domyślnego przycisku, który uruchamia kwerendę usuwającą dane. W takim przypadku lepiej jako domyślny wybrać przycisk Anuluj.
Konfiguracja przycisku Anuluj Przycisk Anuluj na formularzu jest wybierany automatycznie, jeśli użytkownik naciśnie klawisz Esc, gdy formularz jest otwarty. W większości przypadków programista chce po prostu, by w takim przypadku okno dialogowe zniknęło z ekranu. Aby wyznaczyć przycisk Anuluj formularza, należy ustawić właściwość Anuluj wybranego przycisku. W przykładzie jako przycisk Anuluj został wybrany cmdCancel. Podobnie jak w przypadku przycisku domyślnego, tylko jeden przycisk na formularzu może pełnić funkcję Anuluj. Access wyzwala zdarzenie On Click przycisku Anuluj, gdy użytkownik naciśnie klawisz Esc.
Usunięcie menu sterowania Po wyznaczeniu przycisków domyślnego i Anuluj nie jest już potrzebny przycisk menu sterowania w lewym górnym rogu formularza. Aby go ukryć, należy we właściwości Pole menu sterowania formularza ustawić wartość Nie. Po usunięciu pola menu sterowania użytkownik będzie musiał użyć przycisku Anuluj lub Wykonaj kwerendę, aby usunąć formularz z ekranu.
Projektowanie formularza od podstaw W tym podrozdziale opisaliśmy proces tworzenia od podstaw formularza do wprowadzania faktur. Wykorzystasz tu wiele informacji z tego rozdziału i z wcześniejszych. Rozwijany formularz ma służyć przede wszystkim do rejestrowania transakcji, dlatego wiele pól będzie pochodziło z tabeli tblSales.
Tworzenie prostego formularza Aby utworzyć formularz, wykonaj następujące czynności: 1. Kliknij przycisk Projekt formularza z zakładki TWORZENIE na wstążce. 2. Kliknij przycisk Dodaj istniejące pola z zakładki NARZĘDZIA PROJEKTOWANIA FORMULARZY PROJEKTOWANIE. Pojawi się okno dialogowe Lista pól. 3. Na liście pól tabeli tblSales kliknij dwukrotnie pola InvoiceNumber, SaleDate, InvoiceDate, CustomerID, SalespersonID, PaymentMethod i TaxRate, aby dodać je do formularza. Na razie nie zwracaj uwagi na rozmieszczenie formantów. Na tym etapie formularz powinien wyglądać podobnie do tego z rysunku 19.18. Teraz możesz zamknąć okno dialogowe Lista pól. 4. Zapisz formularz pod nazwą frmInvoiceEntry.
554
Część V Formularze i raporty Accessa
Rysunek 19.18. Umieszczanie formantów na nowym formularzu
Nowy formularz frmInvoiceEntry działa i jest związany z tabelą tblSales. Możesz wyświetlić go w widoku formularza i przejrzeć wszystkie rekordy z tabeli tblSales. To dobrze, że można tak szybko przygotować działające rozwiązanie, jednak aby nowy formularz był bardziej przyjazny dla użytkowników, trzeba poświęcić mu jeszcze trochę pracy. Najpoważniejszym brakiem jest to, że nie można zidentyfikować sprzedawanych produktów. Ponadto wprowadzanie identyfikatorów klienta i sprzedawcy wymaga od użytkowników niezwykłej pamięci (pracę może też ułatwić bardzo niewielka liczba klientów i sprzedawców). Warto zauważyć, że formularz frmInvoiceEntry z pliku Rozdział19.accdb to ostateczna wersja formularza, bogatsza w funkcje od formularza dostępnego na tym etapie.
Tworzenie podformularza Następnie należy dodać podformularz, aby użytkownicy mogli wprowadzać produkty i liczbę sztuk. Najłatwiejszy sposób dodawania podformularza wymaga utworzenia takiego obiektu przed dodaniem go do głównego formularza. Aby utworzyć podformularz, wykonaj następujące czynności: 1. Wybierz opcję Projekt formularza z zakładki TWORZENIE na wstążce. 2. Dodaj do podformularza pola SalesLineItemID, InvoiceNumber, ProductID, Quantity, DiscountPercent i SellingPrice z tabeli tblSalesLineItems. Podformularz będzie wyświetlany jako arkusz danych w głównym formularzu, dlatego nie musi być atrakcyjny. Ważne jest, aby pola znajdowały się w kolejności, w jakiej mają się pojawiać w arkuszu danych. 3. Kliknij prawym przyciskiem myszy pole tekstowe ProductID i wybierz opcję Pole kombi z menu Zmień na. To spowoduje przekształcenie formantu ProductID na pole kombi, co ułatwi użytkownikom wybieranie produktów.
Rozdział 19. Praca z formantami formularzy
555
4. Zmień wartość właściwości Źródło wierszy pola ProductID na poniższą instrukcję SQL-a: SELECT ProductID, Description FROM tblProducts ORDER BY Descripton;
5. Zmień wartość właściwości Liczba kolumn na 2, właściwości Szerokości kolumn na 0";1", a właściwości Kolumna powiązana na 1. Właściwość Szerokości kolumn określa, jak szerokie mają być kolumny na liście rozwijanej. Ustawienie szerokości pierwszej kolumny na zero prowadzi do ukrycia tej kolumny. Właściwość Kolumna powiązana określa, które pole jest zapisywane w tabeli. Tu zapisywane ma być pierwsze pole (ProductID). Jest to typowy sposób pobierania wartości w formularzach. Użytkownik widzi wartość zrozumiałego dla siebie pola Description, natomiast zapisywana jest przyjazna dla bazy danych wartość pola ProductID. 6. Zmień etykietę z ProductID na Produkt. Możesz też zmodyfikować pozostałe etykiety. 7. Zmień wartość właściwości Widok domyślny formularza na Arkusz danych. To w tym widoku podformularz ma się wyświetlać w formularzu głównym. 8. Zapisz formularz pod nazwą sfrmInvoiceEntryLines i porównaj uzyskany efekt z formularzem z rysunku 19.19. Rysunek 19.19. Podformularz z wierszami faktury
Dodawanie podformularza Aby dodać podformularz do głównego formularza, wykonaj następujące czynności: 1. Otwórz formularz frmInvoiceEntry w widoku projektu. 2. Dodaj formant Podformularz/podraport tak, aby rozciągał się wzdłuż dolnej krawędzi formularza. Otworzy się kreator podformularzy widoczny na rysunku 19.20. 3. Wybierz opcję Użyj istniejącego formularza i wybierz formularz sfrmInvoiceEntryLines. Następnie kliknij przycisk Dalej.
556
Część V Formularze i raporty Accessa
Rysunek 19.20. Ustawianie istniejącego formularza jako podformularza
4. Na następnym ekranie kreatora wybierz pierwszą opcję łączenia formularzy, jak pokazano to na rysunku 19.21. Rysunek 19.21. Łączenie podformularza z głównym formularzem
5. Na ostatnim ekranie kreatora zachowaj pierwotną nazwę podformularza, a następnie kliknij przycisk Zakończ. 6. Usuń etykietę automatycznie utworzoną dla podformularza. W trakcie dodawania podformularza Access dobrze odgaduje połączenia między formularzem głównym a podformularzem. W czwartym kroku i na rysunku 19.21 zaakceptowano ustawienia wybrane przez Accessa. Na tym etapie kreator ustawia dwie właściwości podformularza: Nadrzędne pole łączące i Podrzędne pole łączące. Właściwość Nadrzędne pole łączące zawiera nazwę powiązanego z podformularzem pola z głównego formularza. Właściwość Podrzędne pole łączące zawiera nazwę powiązanego pola z podformularza. W tym przykładzie obie właściwości zawierają nazwę pola InvoiceNumber. Pole to występuje zarówno w formularzu głównym, jak i w podformularzu i łączy oba te obiekty.
Rozdział 19. Praca z formantami formularzy
557
Jeśli Access źle odgadnie pola łączące formularze, można łatwo zmodyfikować obie właściwości. Należy wpisać poprawne nazwy pól lub kliknąć przycisk konstruowania obok jednej z właściwości i wybrać odpowiednie pole z listy.
Po dodaniu podformularza do formularza głównego projekt wygląda dość chaotycznie. Nie przejmuj się — wkrótce go uporządkujesz. Podformularz widoczny jest w widoku projektu, choć przy wyświetlaniu formularza głównego będzie pokazywany jako arkusz danych. Podformularz w formularzu głównym udostępnia wszystkie funkcje edycji. Zwykle najlepszy sposób tworzenia formularzy w Accessie obejmuje trzy kroki: 1. Dodaj wszystkie formanty i podformularze, jakie chcesz umieścić na formularzu. 2. Ustaw właściwości formularza i formantów wpływające na działanie formularza. 3. Rozmieść formanty na formularzu i ustaw właściwości wpływające na wygląd formularza. Dwa ostatnie kroki można wykonać w odwrotnej kolejności, jednak często lepiej jest pozostawić dopracowywanie wyglądu formularza na koniec, gdy wszystko już działa poprawnie.
Modyfikowanie działania formularza Następny krok w procesie projektowania formularza polega na zapewnieniu poprawnego działania rozwiązania. Aby zrealizować ten cel, trzeba zmienić niektóre właściwości formularza i formantów. Ustawianie właściwości formularza Zmień następujące właściwości formularza na podane wartości:
Tytuł: Wprowadzanie nowej faktury,
Allow Datasheet View: Nie,
Zezwalaj na widok układu: Nie,
Selektory rekordów: Nie,
Przyciski nawigacyjne: Nie,
Pole menu sterowania: Nie,
Wprowadzanie danych: Tak,
Cykliczny: Bieżący rekord.
Są to typowe ustawienia właściwości dla formularzy przeznaczonych do wprowadzania danych. Formularz ma służyć do wpisywania nowych faktur, dlatego można ukryć mechanizmy do poruszania się po rekordach. Właściwość Wprowadzanie danych gwarantuje, że formularz po otwarciu będzie wyświetlał nowy rekord. Ustawienie właściwości Cykliczny na bieżący rekord zmienia działanie domyślne, które polega na przechodzeniu do następnego rekordu po wyjściu użytkownika z ostatniego pola. Dzięki wyłączeniu tego mechanizmu można kontrolować moment zapisywania rekordu.
558
Część V Formularze i raporty Accessa
Wyszukiwanie wartości w trakcie wprowadzania danych W podformularzu przekształcono pole tekstowe ProductID na pole kombi, aby użytkownik mógł wybierać elementy na podstawie opisów, a nie według numerów. W formularzu głównym znajduje się więcej pól, do których można zastosować tę samą technikę. Są to pola: CustomerID, SalespersonID, PaymentMethod i TaxRate. Użytkownikowi dodającemu fakturę łatwiej będzie wybierać pozycje na podstawie nazwisk lub opisów niż według identyfikatorów. Aby przekształcić pole tekstowe CustomerID na pole kombi, wykonaj następujące czynności: 1. Kliknij prawym przyciskiem myszy pole tekstowe CustomerID i wybierz opcję Pole kombi z menu Zmień na. 2. Zmień wartość właściwości Źródło wierszy na SELECT CustomerID, Company FROM tblCustomers ORDER BY Company;. 3. Zmień wartość właściwości Ogranicz do listy na Tak. 4. Zmień wartość właściwości Liczba kolumn na 2, a właściwości Szerokości kolumn na 0";1". Odpowiednio zmień także właściwości innych formantów. Wartości właściwości Źródło wierszy przedstawia tabela 19.3. Pamiętaj, aby zmienić wartość właściwości Liczba kolumn odpowiednio do liczby wierszy zwracanych przez poszczególne instrukcje SQL-a. Tabela 19.3. Wartości właściwości Źródło wierszy Nazwa formantu
Wartość właściwości Źródło wierszy
CustomerID
SELECT CustomerID, Company FROM tblCustomers ORDER BY Company;
SalespersonID
SELECT SalespersonID, SalespersonName FROM tblSalesperson ORDER BY SalespersonName;
PaymentMethod
SELECT PaymentType FROM tblPaymentType;
TaxRate
SELECT TaxLocation, TaxRate from tblTaxRates ORDER BY TaxRate DESC;
Pola CustomerID i SalespersonID zawierają klucz obcy z innej tabeli (podobnie jak pole ProductID z podformularza). Pola PaymentMethod i TaxRate nieco się od nich różnią. Na przykład formant PaymentMethod nie zawiera klucza obcego z tabeli tblPaymentType. Zamiast tego przechowuje tekst, a w tabeli tblPaymentType znajdują się typowe rodzaje płatności. Podobnie tabela tblTaxRates zawiera używane stawki podatkowe. W polach PaymentMethod i TaxRate właściwość Ogranicz do listy należy ustawić na Nie, aby użytkownik mógł wpisać dowolną odpowiednią wartość. Warto zauważyć, że zapisywana w tabeli tblSales wartość z tabeli tblTaxRates pochodzi z drugiej kolumny. Aby zachować tę wartość, należy ustawić właściwość Kolumna powiązana pola TaxRate na 2. Ponieważ pole PaymentMethod zawiera tylko jedną kolumnę, a w polu TaxRate mają pojawiać się dwie kolumny z powiązanej tabeli, właściwość Szerokości kolumn w obu formantach może pozostać pusta. Gdy właściwość ta jest pusta, Access wyświetla wszystkie kolumny i dostosowuje ich szerokość do danych.
Rozdział 19. Praca z formantami formularzy
559
Zapisywanie rekordów Ostatnie zagadnienie związane z działaniem formularza dotyczy zapisywania rekordów. Wcześniej właściwość Cykliczny formularza ustawiono na Bieżący rekord, co zapobiega modyfikacji rekordu po wyjściu z ostatniego pola. Działanie formularza można kontrolować za pomocą przycisków poleceń. Aby utworzyć taki przycisk służący do zapisywania rekordów, wykonaj następujące czynności: 1. Z grupy Formanty zakładki PROJEKTOWANIE na wstążce wybierz formant Przycisk i umieść go na formularzu. 2. Na pierwszym ekranie kreatora przycisków poleceń wybierz opcje Nawigowanie między rekordami i Przejdź do następnego rekordu, a następnie kliknij przycisk Dalej. 3. Na następnym ekranie kreatora zaznacz pole wyboru Pokaż wszystkie obrazy i wybierz obraz Zapisz rekord. Następnie kliknij przycisk Dalej. 4. Na ostatnim ekranie kreatora nazwij przycisk cmdSave i kliknij przycisk Zakończ. Użycie przycisku polecenia do przechodzenia do następnego rekordu sprawia, że bieżący rekord będzie wtedy zapisywany automatycznie. Dzięki temu sposób zapisywania rekordu jest bardziej intuicyjny niż przy opuszczaniu ostatniego pola. Ponadto program po zachowaniu bieżącego rekordu wyświetla nowy, pusty rekord, w którym można wprowadzić inne dane. Należy też umożliwić użytkownikom anulowanie wprowadzania faktury. Dodaj do formularza następny przycisk polecenia i wybierz akcję Cofnij rekord z kategorii Operacje na rekordach. Wybierz domyślny obraz dla operacji cofania i nazwij przycisk cmdCancel. Potrzebny jest też przycisk umożliwiający zamknięcie formularza. Właściwość Pole menu sterowania należy ustawić na Nie, aby ukryć symbol X w prawym górnym rogu formularza. Dodaj do formularza przycisk i ustaw dla niego akcję Zamknij formularz z kategorii Operacje na formularzach. Nazwij ten przycisk cmdClose.
Modyfikowanie wyglądu formularza Ostatni krok polega na zwiększeniu atrakcyjności formularza. Na głównym formularzu zmień szerokość i rozmieszczenie formantów. Przycisk poleceń umieść w prawym dolnym rogu. W podformularzu zmniejsz szerokość kolumn SalesLineItemID i InvoiceNumber na zero, przeciągając prawą krawędź tych kolumn maksymalnie w lewo. Aby móc przeciągnąć te krawędzie, wyświetl formularz w widoku formularza lub układu. Rozmieszczenie formantów przedstawia rysunek 19.22. W ostatnim kroku zmień kolejność przechodzenia między formantami za pomocą klawisza tabulacji. Kliknij przycisk Kolejność tabulacji z zakładki PROJEKTOWANIE na wstążce, aby wyświetlić okno dialogowe Kolejność tabulacji widoczne na rysunku 19.23. Po ustawieniu kolejności tabulacji zmień wartość właściwości Przechodzenie tabulatorami formantu InvoiceNumber na Nie. Numer faktury znajduje się w polu typu Autonumerowanie, dlatego użytkownik nie powinien go modyfikować.
560
Część V Formularze i raporty Accessa
Rysunek 19.22. Formanty rozmieszczone na formularzu
Rysunek 19.23. Określanie kolejności tabulacji dla formantów
Rozdział 20.
Prezentowanie danych za pomocą raportów W tym rozdziale:
Różne typy raportów w Accessie
Tworzenie raportu za pomocą kreatora
Tworzenie raportu od podstaw
Poprawa wyglądu raportu
Raporty odgrywają bardzo istotną rolę w aplikacjach bazodanowych. Z raportów tworzonych w Accessie korzysta wielu ludzi, którzy nigdy nie używali go osobiście. Bardzo dużo pracy w projektach bazodanowych pochłania tworzenie nowych i ulepszanie istniejących raportów. Access słynie z rozbudowanych mechanizmów tworzenia raportów. Raporty to najbardziej elastyczny sposób przeglądania i drukowania sumarycznych informacji. Wyświetlają informacje z żądanym poziomem szczegółowości, pozwalając przeglądać je lub drukować w wielu różnych formatach. Do raportów można dodawać wielopoziomowe sumy, porównania statystyczne, obrazy i grafikę. W tym rozdziale najpierw nauczysz się korzystać z Kreatora raportów. Dowiesz się też, jak samemu utworzyć raport i jakie typy raportów są dostępne w Accessie. W tym rozdziale będziesz tworzyć raporty za pomocą kreatora oraz samodzielnie. Do tego celu wykorzystasz tabele utworzone w poprzednich rozdziałach. Kompletne raporty opisane w tym rozdziale są dostępne w pliku bazy danych Rozdział20.accdb.
Podstawowe informacje o raportach W raportach prezentowane są niestandardowe widoki danych. Wyniki raportu można wyświetlić na ekranie albo wydrukować. Raporty często wykorzystuje się do podsumowywania informacji zapisanych w bazie danych. Dane można grupować i sortować według dowolnych kryteriów, a następnie tworzyć podsumowania ze wskaźnikami statystycznymi.
562
Część V Formularze i raporty Accessa
Raporty mogą zawierać zdjęcia i inne typy grafiki oraz pola typu Długi tekst. Bez względu na to, jakiego raportu potrzebujesz, w Accessie prawdopodobnie można go stworzyć.
Dostępne typy raportów W większości firm wykorzystywane są trzy podstawowe typy raportów:
Raport tabelaryczny — drukuje dane w wierszach i kolumnach, grupując je i obliczając sumy. Jego odmianami są raport sumaryczny i raport grupującosumujący.
Raport kolumnowy — drukuje dane. Może zawierać sumy i wykresy.
Raport korespondencji seryjnej — służy do tworzenia wielokolumnowych arkuszy etykiet pocztowych albo do prezentowania danych w postaci szpalt tekstu (ang. snaked-column report).
Raporty tabelaryczne Raporty tabelaryczne przypominają tabele, w których dane wyświetlają się w wierszach i kolumnach. Typowy raport tabelaryczny (rptProductsSummary) w oknie podglądu wydruku pokazano na rysunku 20.1. Rysunek 20.1. Raport tabelaryczny (rptProductsSummary) w widoku podglądu wydruku
Raporty tabelaryczne — w przeciwieństwie do formularzy i arkuszy danych — zwykle grupują dane według wartości jednego lub wielu pól. Często obliczają i wyświetlają sumy częściowe albo informacje statystyczne dotyczące pól liczbowych w każdej grupie. Niektóre raporty wyświetlają także sumy dla stron i sumy łączne. Mogą nawet zawierać zawinięte kolumny, dzięki którym można tworzyć katalogi (takie jak książka tele-
Rozdział 20. Prezentowanie danych za pomocą raportów
563
foniczna). Raporty tego typu mogą zawierać numery stron, daty utworzenia raportu oraz linie i ramki oddzielające informacje. Mogą zawierać kolory i cieniowanie oraz wyświetlać obrazy, wykresy biznesowe i pola typu Długi tekst. Specjalny typ raportu tabelarycznego — raport sumaryczny — ma wszystkie cechy raportu tabelarycznego, ale nie drukuje poszczególnych rekordów. Raporty kolumnowe Raporty kolumnowe zwykle wyświetlają jeden lub kilka rekordów na stronie w układzie pionowym. Prezentują dane niemal tak samo jak formularze, ale służą wyłącznie do oglądania, a nie do modyfikowania danych. Fragment raportu kolumnowego (rptProducts) w widoku podglądu wydruku zamieszczono na rysunku 20.2. Rysunek 20.2. Raport kolumnowy; formanty raportu są rozproszone po całej stronie
Inny typ raportu kolumnowego wyświetla jeden rekord na głównej stronie (tak jak formularz biznesowy), ale może pokazywać wiele rekordów na osadzonych podformularzach. Typowym przykładem takiego raportu jest faktura. Raporty tego rodzaju mają sekcje, które wyświetlają tylko jeden rekord, oraz sekcje, które wyświetlają kilka rekordów ze strony „wiele” relacji jeden do wielu; mogą też zawierać sumy. Raport faktury z bazy danych MiniAuta dla Kolekcjonerów (rptInvoice) w oknie podglądu wydruku pokazano na rysunku 20.3. Informacje w górnej części raportu pokazanego na rysunku 20.3 znajdują się w głównej jego części, natomiast szczegółowe informacje dotyczące produktów widoczne w dolnej części rysunku są zawarte w podraporcie osadzonym w głównym raporcie. Raporty korespondencji seryjnej Etykiety pocztowe (zobacz rysunek 20.4) również są typem raportu. Można je łatwo utworzyć za pomocą Kreatora etykiet pocztowych dostępnego w Accessie. Kreator pozwala wybrać rodzaj etykiety z długiej listy stylów etykiet. Access precyzyjnie tworzy raport na podstawie wybranego stylu etykiet. Następnie można otworzyć raport w trybie projektu i dostosować go do własnych potrzeb.
Rozdział 20. Prezentowanie danych za pomocą raportów
565
Różnice między raportami a formularzami Główną różnicą między raportami a formularzami jest przeznaczenie wyświetlanych danych. Formularze służą przede wszystkim do wprowadzania danych i komunikacji z użytkownikami, natomiast raporty — do przeglądania danych (na ekranie lub w postaci drukowanej). W formularzach używa się pól obliczeniowych, które obliczają pewne wartości na podstawie innych pól. W raportach wykonuje się obliczenia na pewnych grupach rekordów, stronach rekordów albo wszystkich rekordach przetwarzanych podczas tworzenia raportu. Wszystko, co można zrobić w formularzu — z wyjątkiem wprowadzania danych — można również powielić w raporcie. W rzeczywistości można zapisać formularz jako raport, a następnie dostosować formanty w oknie projektu raportu.
Tworzenie raportu od podstaw Punktem wyjścia do stworzenia raportu jest chęć obejrzenia danych, ale w sposób, który różni się od widoku formularza lub arkusza danych. Celem raportu jest przetworzenie surowych danych w sensowny zbiór informacji. Procedura tworzenia raportu składa się z kilku etapów: 1. Zdefiniowanie układu raportu. 2. Gromadzenie danych. 3. Tworzenie raportu za pomocą kreatora. 4. Drukowanie lub wyświetlanie raportu. 5. Zapisywanie raportu.
Zdefiniowanie układu raportu Należy zacząć od pomysłu na ogólny układ raportu. Można zdefiniować układ w myślach, na papierze lub interaktywnie, korzystając z okna projektu raportu Accessa. W trakcie tworzenia układu raportu zastanów się, jak należy posortować dane (np. chronologicznie lub według nazwisk), jak je pogrupować (np. na podstawie tygodni lub numerów faktur) i czy wymiary kartek używanych do drukowania nie wymuszają określonego formatu danych. Bardzo często od raportu Accessa oczekujemy powielenia istniejącego raportu papierowego wykorzystywanego przez użytkowników aplikacji.
Gromadzenie danych Kiedy już masz ogólne wyobrażenie co do tego, jaki powinien być układ raportu, powinieneś zebrać dane potrzebne do jego utworzenia. W raportach Accessa dane pochodzą z dwóch głównych źródeł:
pojedyncza tabela bazy danych,
zestaw rekordów generowany przez kwerendę.
566
Część V Formularze i raporty Accessa
W kwerendzie można złączyć wiele tabel i wykorzystać wygenerowany zestaw rekordów jako źródło danych raportu. W raporcie Accessa zestaw rekordów kwerendy jest interpretowany tak, jakby był jedną tabelą. Jak dowiedziałeś się z rozdziału 8., w kwerendzie można określić pobierane pola i rekordy oraz sposób sortowania danych. Access traktuje zwrócony zestaw rekordów jak jedną tabelę (do celów przetwarzania) na arkuszach danych, formularzach i raportach. Kiedy raport jest wykonywany, Access dopasowuje dane z zestawu rekordów lub tabeli do pól użytych w raporcie i wykorzystuje dane dostępne w określonym momencie do utworzenia raportu. Porządek sortowania określony w kwerendach nie jest zachowywany w raportach. Przeważnie raporty są sortowane na poziomie raportu — w sekcji szczegółów albo w sekcji grupy. Bardzo często sortowanie danych w kwerendach wykorzystywanych wyłącznie do wypełniania raportów jest marnotrawstwem czasu, ponieważ w raporcie dane są sortowane ponownie.
W poniższym przykładzie wykorzystasz dane z tabeli tblProducts w celu stworzenia stosunkowo prostego raportu tabelarycznego.
Tworzenie raportu za pomocą kreatora W Accessie można utworzyć praktycznie każdy typ raportu. Niektóre tworzy się jednak łatwiej niż inne, zwłaszcza jeśli się skorzysta z Kreatora raportów jako punktu wyjścia. Podobnie jak kreatory formularzy, kreatory raportów tworzą podstawowy układ raportu, który potem można dostosować do własnych potrzeb. Kreator raportów upraszcza procedurę rozmieszczania formantów — wyświetla użytkownikom szereg pytań dotyczących raportu, który ma być utworzony. W tym rozdziale nauczysz się korzystać z Kreatora raportów do stworzenia raportów tabelarycznego i kolumnowego. Tworzenie nowego raportu Na wstążce Accessa dostępnych jest szereg poleceń umożliwiających tworzenie nowych raportów w aplikacjach. Zakładka TWORZENIE na wstążce zawiera grupę Raporty, w której jest dostępnych kilka opcji, np. Raport, Etykiety i Kreator raportów. Aby rozpocząć ćwiczenie, kliknij przycisk Kreator raportów w grupie Raporty w zakładce TWORZENIE. Wyświetli się pierwszy ekran kreatora raportów (zobacz rysunek 20.5). W oknie dialogowym pokazanym na rysunku 20.5 jako źródło danych nowego raportu wybrano tabelę tblProducts. Zbiór dostępnych pól znajduje się na liście rozwijanej Tabele/kwerendy. Kliknięcie pola na tej liście i wciśnięcie strzałki wskazującej w prawo powoduje przeniesienie pola z listy Dostępne pola na listę Zaznaczone pola i dodanie go raportu. Dla potrzeb tego przykładu wybierz pola ProductID, Category, Description, QtyInStock, RetailPrice i Cost. Można kliknąć dwukrotnie dowolne pole na liście Dostępne pola, aby przenieść je na listę Zaznaczone pola. Można również kliknąć dwukrotnie dowolne pole na liście Zaznaczone pola, aby usunąć je z listy.
Rozdział 20. Prezentowanie danych za pomocą raportów
567
Rysunek 20.5. Pierwszy ekran kreatora raportów po wybraniu źródła danych i pól
Na liście znajdują się tylko pola z pierwotnie wybranego źródła rekordów. Można wybrać pola z innych raportów lub kwerend za pomocą rozwijanej listy Tabele/kwerendy na tym ekranie kreatora. Jeśli określisz prawidłowe relacje i Access będzie mógł połączyć dane, pola te zostaną dodane do pierwotnie wybranych i będzie można użyć ich w raporcie. Jeśli wybierzesz pola z tabel, które nie mają zdefiniowanych relacji, wyświetli się okno dialogowe z pytaniem, czy chcesz zmodyfikować relacje i połączyć tabele. Można też wrócić do Kreatora raportów i usunąć pola. Po wybraniu danych należy kliknąć przycisk Dalej, aby przejść do następnego ekranu kreatora. Wybieranie poziomów grupowania Następne okno dialogowe umożliwia wybór pól, które posłużą do grupowania danych. W oknie dialogowym na rysunku 20.6 wybrano pole Category jako pole grupowania danych dla raportu. Pola wybrane do grupowania określają sposób wyświetlania danych w raporcie. Pola grupowania występują w raporcie jako nagłówki i stopki grup. Rysunek 20.6. Definiowanie grupowania w raporcie
568
Część V Formularze i raporty Accessa
Grup najczęściej używa się do łączenia danych, które są ze sobą logicznie powiązane. Klasycznym przykładem jest pogrupowanie produktów według kategorii. Bardzo praktycznym przykładem jest pogrupowanie danych według pola CustomerID tak, by historia transakcji klienta wyświetliła się w raporcie jako grupa. Nagłówki i stopki grup wykorzystuje się do wyświetlania nazwiska klienta i innych informacji właściwych dla każdego klienta. Kreator raportów umożliwia określenie do czterech pól grupowania w raporcie. Aby zmienić kolejność grupowania w raporcie, można skorzystać z przycisków Priorytet. Wybrana kolejność pól określa hierarchię grupowania. Aby określić grupowanie na podstawie przynależności do kategorii, wybierz pole Category i kliknij strzałkę (>). Zwróć uwagę, że obraz się zmienił — pole Category wyświetliło się jako pole grupowania danych dla raportu (zobacz rysunek 20.6). Wszystkie pola wybrane w raporcie (ProductID, Description, QtyInStock, RetailPrice i SalesPrice) wyświetlą się w sekcji szczegółów grupy Category. Definiowanie opcji grupowania Po wybraniu pól grupowania można kliknąć przycisk Opcje grupowania w dolnej części okna dialogowego, aby wyświetlić inne okno dialogowe, umożliwiające dokładniejsze zdefiniowanie sposobu wykorzystania pól grupowania w raporcie. Na przykład można się zdecydować na grupowanie tylko według pierwszego znaku pola wybranego do grupowania. Oznacza to, że wszystkie rekordy z tym samym pierwszym znakiem w polu grupowania znajdą się w jednej grupie. Jeśli pogrupujesz tabelę z danymi o klientach według pola CustomerName i wybierzesz grupowanie według pierwszej litery pola CustomerName, nagłówek i stopka grupy wyświetlą się dla zbioru wszystkich klientów, których nazwa rozpoczyna się na tę samą literę. Stworzy się grupa dla wszystkich rekordów, dla których wartość pola CustomerName rozpoczyna się na literę A, inna grupa dla wszystkich rekordów z polem CustomerName rozpoczynającym się na literę B itd. Okno dialogowe Opcje grupowania umożliwia dokładniejsze zdefiniowanie grupowania. Wybrane tu opcje mają różny stopień ważności dla danych różnych typów. Na liście Interwały grupowania wyświetlają się różne wartości dla poszczególnych typów danych: — Normalny, 1 litera, 2 początkowe litery, 3 początkowe litery, 4 początkowe litery, 5 początkowych liter.
Ustawienie Normalny oznacza, że dane są grupowane według wartości całego pola. W tym przykładzie użyto całego pola Category. Zwróć uwagę, że opcje grupowania upraszczają tworzenie raportów pogrupowanych według miesięcy kalendarzowych, kwartałów, lat itp. Oznacza to, że można z łatwością tworzyć raporty dotyczące sprzedaży, płac lub innych informacji finansowych niezbędnych do raportowania w biznesie.
Rozdział 20. Prezentowanie danych za pomocą raportów
569
Jeśli wcześniej wyświetlono okno dialogowe Opcje grupowania, należy kliknąć przycisk OK, aby wrócić do okna poziomów grupowania. Następnie można kliknąć Dalej, by przejść do okna dialogowego Porządek sortowania. Wybieranie kolejności sortowania Domyślnie Access automatycznie sortuje pogrupowane rekordy w porządku, który ułatwia nadanie sensu grupowaniu. Na przykład jeśli wybierzesz pole Category do pogrupowania rekordów klienta, Access posortuje grupy w porządku alfabetycznym według pola Category. Jednak dla pewnych zastosowań może być potrzebne posortowanie rekordów w obrębie każdej grupy. Użytkownicy mogą na przykład wymagać posortowania rekordów produktów według ceny w porządku malejącym, tak aby najdroższe produkty pojawiały się na początku wszystkich grup odpowiadających poszczególnym kategoriom. W omawianym przykładzie Access sortuje dane według pola Category. Jak pokazano na rysunku 20.7, dane posortowano również w ramach każdej grupy według pola Description. Rysunek 20.7. Wybieranie kolejności sortowania
Pola sortowania wybiera się w taki sam sposób, jak pola grupowania raportu. Można wybrać pola, których nie wybrano do grupowania, i użyć ich jako pól sortowania. Pola wybrane w tym oknie dialogowym nie wpływają na grupowanie; mają tylko wpływ na kolejność sortowania w sekcjach szczegółów. Można określić kolejność rosnącą lub malejącą, klikając przycisk po prawej stronie każdego pola sortowania. Wybieranie opcji podsumowania Na dole okna sortowania kreatora raportów znajduje się przycisk Opcje podsumowania. Kliknięcie tego przycisku powoduje wyświetlenie okna Opcje podsumowania pokazanego na rysunku 20.8. W tym oknie można określić dodatkowe opcje dotyczące pól liczbowych. Wyświetlają się tu wszystkie pola liczbowe i walutowe wybrane do raportu. Wszystkie one są dostępne do tworzenia podsumowań. Można też wyświetlać średnie oraz wartości minimalne i maksymalne. Można też zdecydować, czy dane w sekcji szczegółów powinny być widoczne czy ukryte. Jeśli zaznaczysz opcję Szczegóły i podsumowanie, raport będzie zawierał dane szczegółowe, natomiast jeśli zaznaczysz opcję Tylko podsumowanie, sekcja szczegółów będzie ukryta i w raporcie pojawią się tylko sumy.
570
Część V Formularze i raporty Accessa
Rysunek 20.8. Wybieranie opcji podsumowania
Zaznaczenie opcji Obliczaj udziały procentowe sum sprawia, że pod sumą w stopce grupy pojawia się procentowy udział tej sumy w całej wartości raportu. Jeśli na przykład są trzy grupy produktów i ich sumy wynoszą — odpowiednio — 15, 25 i 10, to pod sumami pojawiłyby się wartości 30%, 50% i 20%, wskazujące, jaki udział każda suma ma w sumie łącznej (czyli 50) w odniesieniu do skali 100%. Kliknięcie przycisku OK w tym oknie dialogowym spowoduje powrót do okna sortowania w kreatorze tworzenia raportów. Kliknięcie przycisku Dalej powoduje przejście do następnego ekranu kreatora. Wybieranie układu raportu Następny krok w kreatorze określa wygląd raportu. W ramce Układ można wybrać podstawowy układ danych. W ramce tej są do wyboru trzy opcje; za ich pomocą można poinformować Accessa, czy mają się powtarzać nagłówki kolumn, czy należy zastosować wcięcia dla każdego z poziomów grupowania i czy należy dodawać linie lub ramki wokół wierszy szczegółów. Po wybraniu poszczególnych opcji rysunek po lewej stronie zmienia się, by zaprezentować efekt wprowadzonych zmian. Ramka Orientacja umożliwia wybór układu pionowego (wzdłuż) lub poziomego (w poprzek strony). Pole wyboru Dostosuj szerokość pól tak, aby wszystkie pola były widoczne na stronie pozwala zmieścić dużą ilość danych na niewielkim obszarze (prawdopodobnie nie obędzie się bez szkła powiększającego!). W tym przykładzie wybierz układ krokowy i orientację pionową, jak pokazano na rysunku 20.9. Następnie kliknij przycisk Dalej, aby przejść do kolejnego okna dialogowego. Otwieranie projektu raportu Ostatnie okno dialogowe Kreatora raportów zawiera obszar, w którym można wpisać tytuł raportu. Tytuł ten pojawia się tylko raz, na początku raportu (nie na górze każdej strony), spełnia również rolę nazwy raportu. Domyślnie tytułem raportu jest nazwa tabeli lub kwerendy wybranej jako źródło danych raportu. Raport, który utworzyliśmy w bazie danych Rozdział20.accdb, ma nazwę rptProducts_Kreator.
Rozdział 20. Prezentowanie danych za pomocą raportów
571
Rysunek 20.9. Wybieranie układu raportu
Następnie można wybrać jedną z opcji na dole okna dialogowego:
Podgląd raportu,
Modyfikuj projekt raportu.
W tym przykładzie pozostaw domyślnie zaznaczoną opcję, aby wyświetlić podgląd raportu. Kliknij przycisk Zakończ, aby zamknąć Kreator raportów i obejrzeć raport (zobacz rysunek 20.10).
Rysunek 20.10. Raport tblProducts_Kreator w widoku podglądu raportu
Dopracowywanie układu raportu Jest kilka drobnych problemów z raportem pokazanym na rysunku 20.10. Kreator raportów Accessa wybrał czcionki i ogólny schemat kolorów, które mogą się różnić od oczekiwań autora. Ponadto kolumna Retail Price nie jest wystarczająco szeroka, by zmieścił się w niej nagłówek.
572
Część V Formularze i raporty Accessa
Kreator raportów wyświetlił nowy raport w widoku podglądu raportu. Aby przejść do widoku układu, należy kliknąć prawym przyciskiem myszy pasek tytułu raportu i z menu podręcznego wybrać polecenie Widok układu. Nowy raport wyświetlony w widoku układu pokazano na rysunku 20.11.
Rysunek 20.11. Widok układu przydaje się w sytuacji, gdy zaistnieje konieczność zmiany rozmiaru formantów w raporcie kolumnowym
Jak widać na rysunku 20.11, zmniejszono szerokość kolumny Category, aby wyeliminować puste miejsce, a także rozciągnięto kolumnę Description w lewą stronę, żeby zapełnić powstałą lukę. Pozostałe kolumny odsunięto od siebie, dzięki czemu widoczne stały się nagłówki, a same kolumny nie są już tak ściśnięte. Manipulowanie formantami w widoku układu raportu odbywa się tak samo jak w widoku układu formularza. Na przykład aby zmniejszyć szerokość kolumny, przeciągnij lewą krawędź formantu w lewo. Ponadto zmieniono nazwy kolumn na bardziej zrozumiałe. Wybór motywu Po dopracowaniu układu raportu można wykorzystać formanty z grupy Motywy zakładki Projektowanie na wstążce, aby zmodyfikować kolory, czcionki i ogólny wygląd raportu. Przycisk Motywy otwiera galerię zawierającą kilkadziesiąt motywów (zobacz rysunek 20.12). Motywy to bardzo ważny element Accessa 2013. Motyw decyduje o schemacie kolorów, kroju czcionki, kolorach czcionek oraz rozmiarach czcionek w formularzach i raportach Accessa 2013. Wskazanie myszą ikony motywu w galerii powoduje, że raport otwarty w widoku układu za galerią natychmiast się zmienia. Dzięki temu można zobaczyć, jak wyglądałby raport w przypadku wybrania wskazanego motywu.
Rozdział 20. Prezentowanie danych za pomocą raportów
573
Rysunek 20.12. Wybór motywu raportu
Każdy motyw ma nazwę, np. Office, Apteka, Strumień, Papier, Metro. Nazwy są przydatne w sytuacjach, kiedy trzeba wskazać określony motyw w dokumentacji aplikacji, korespondencji e-mail lub innych dokumentach. Motywy znajdują się w plikach z rozszerzeniem .thmx w folderze Program Files\Microsoft Office\Document Themes 15. Są stosowane we wszystkich dokumentach pakietu Office 2013 (w Wordzie, Excelu i Accessie), dzięki czemu można łatwo wybrać styl do zastosowania we wszystkich dokumentach firmowych tworzonych za pomocą pakietu Office. Użytkownicy Accessa 2007 pewnie się zastanawiają, co się stało z funkcją Autoformatowania. Z kilku powodów firma Microsoft zdecydowała się zastąpić w pakiecie Office opcję Autoformatowania opcją motywów. Opcja Autoformatowania miała zastosowanie do pojedynczych formantów, co sprawiało, że w przypadku tworzenia złożonych formularzy lub raportów trzeba było wykonać dużo pracy. Funkcja Autoformatowania była ponadto opcją typu „wszystko albo nic”. W związku z tym trudno było zastosować tę opcję, a następnie zmodyfikować kolory i czcionki formantów w formularzu bądź raporcie. Motywy zapewniają znacznie większą elastyczność. Pozwalają nawet na to, aby zapisać cały formularz lub raport z innym motywem (do tego celu służy opcja Zapisz bieżący motyw w dolnej części galerii motywów pokazanej na rysunku 20.12). W Accessie 2007 nie było sposobu dostosowania funkcji Autoformatowania do indywidualnych potrzeb.
Jak widać na menu podręcznym z rysunku 20.12, wybrany motyw można zastosować do bieżącego raportu (Zastosuj motyw tylko do tego obiektu), do wszystkich raportów (Zastosuj motyw do wszystkich zgodnych obiektów) albo do wszystkich formularzy oraz raportów w aplikacji (Ustaw ten motyw jako domyślny dla bazy danych). Istnieje nawet opcja dodania motywu jako przycisku na pasku narzędzi szybkiego dostępu. Jest to niezwykle przydatna możliwość pozwalająca na selektywne stosowanie motywu do innych obiektów w bazie danych. Na potrzeby tego ćwiczenia dla nowego raportu produktów wybrano motyw Ekskluzywny.
574
Część V Formularze i raporty Accessa Podczas tworzenia formularzy i raportów Accessa można odczuć pokusę, by wypróbować wszystkie style raportów. Trzeba jednak pamiętać, że w przypadku zastosowania zbyt dużej mieszanki stylów aplikacja Accessa może wyglądać jako bezużyteczny zbiór różnych pomysłów, a nie jak przydatne narzędzie biznesowe. Profesjonalni twórcy baz danych zazwyczaj ograniczają do minimum liczbę stosowanych stylów formularzy i raportów oraz używają ich konsekwentnie w całej aplikacji. Należy uwzględnić potrzeby użytkowników i unikać przytłaczania ich olbrzymią liczbą kolorów czcionek i innych elementów stylu raportów oraz komponentów interfejsu użytkownika.
Tworzenie nowych schematów kolorów w motywach Access 2013 daje dostęp do wielu domyślnych motywów. Każdy z tych motywów składa się ze zbioru spójnych kolorów, czcionek i własności czcionek. Oprócz tego można samodzielnie stworzyć motyw kolorów i czcionek całkowicie od podstaw i zastosować go do formularzy oraz raportów. Stworzenie własnego motywu to doskonały sposób zastosowania firmowego schematu kolorów w formularzach i raportach aplikacji. Aby stworzyć własny motyw, otwórz raport lub formularz w widoku projektu, a następnie wykonaj poniższe czynności: 1. Kliknij przycisk Kolory w grupie Motywy w zakładce PROJEKTOWANIE. Wyświetli się lista kolorów motywu. 2. Wybierz polecenie Dostosuj kolory wyświetlające się na samym dole listy. Wyświetli się okno dialogowe Tworzenie nowych kolorów motywu (zobacz rysunek 20.13) prezentujące aktualnie wybrany motyw. Rysunek 20.13. Konfigurowanie własnego motywu kolorów
Zmodyfikowanie motywu kolorów wymaga sporo pracy. Jak można zobaczyć na rysunku 20.13, każdy motyw składa się z 12 różnych kolorów. Kliknięcie każdego spośród 12 przycisków w oknie dialogowym Tworzenie nowych kolorów motywu otwiera paletę kolorów (zobacz rysunek 20.14). Można na niej wybrać kolor elementu motywu, np. kolor dla elementu Tekst/tło — jasne 2.
Rozdział 20. Prezentowanie danych za pomocą raportów
575
Rysunek 20.14. Wybór koloru elementu motywu
3. Po zakończeniu procesu dostosowywania kolorów należy przypisać nazwę dla własnego motywu, a następnie kliknąć Zapisz. Po zamknięciu okna dialogowego Tworzenie nowych kolorów motywu można zauważyć, że własny motyw koloru został zastosowany do formularza lub raportu otwartego w widoku projektu. Aby zastosować nowy motyw do wszystkich formularzy lub raportów w aplikacji, należy otworzyć listę motywów kolorów, kliknąć prawym przyciskiem myszy nazwę własnego motywu wyświetlanego na początku listy (zobacz rysunek 20.15), a następnie wybrać polecenie Zastosuj schemat kolorów do wszystkich zgodnych obiektów. Jeśli w widoku projektu otwarty jest raport, to motyw zostanie zastosowany do wszystkich raportów w aplikacji. Jeśli natomiast w widoku projektu otwarty jest formularz, to motyw zostanie zastosowany do wszystkich formularzy w aplikacji. Nawet po zastosowaniu motywu kolorów można dostosować kolory indywidualnych elementów raportu (bądź formularza). Należy otworzyć raport w widoku projektu, zaznaczyć element do zmiany, po czym wybrać nowy kolor (kolory) w arkuszu właściwości. Choć nie pokazano tego w tym miejscu, podobne okno dialogowe (Tworzenie nowych czcionek motywu) jest dostępne na liście Czcionki w grupie Motywy zakładki PROJEKTOWANIE. Okno dialogowe Tworzenie nowych czcionek motywu umożliwia skonfigurowanie własnych czcionek motywu (czcionek nagłówków, treści itp.), które można potem stosować w formularzach i raportach. Tworzenie własnych motywów czcionek działa podobnie jak dodawanie własnych motywów kolorów w aplikacji. Motyw należy zapisać pod nazwą pozwalającą na późniejszą identyfikację, a następnie można go stosować według potrzeb w formularzach i raportach.
576
Część V Formularze i raporty Accessa
Rysunek 20.15. Zastosowanie motywu kolorów do wszystkich zgodnych obiektów w aplikacji
Korzystanie z podglądu wydruku Na rysunku 20.16 pokazano okno podglądu wydruku z powiększoną stroną raportu tblProducts_Kreator. Okno to wyświetla raport z rzeczywistymi czcionkami, cieniowaniem, liniami, prostokątami i danymi, które znajdą się na wydruku z domyślnej drukarki systemu Windows. Kliknięcie lewym przyciskiem myszy powoduje przełączenie do trybu podglądu strony, w którym widać całą stronę. Wstążka Accessa zmienia swoją postać, wyświetlając polecenia dotyczące przeglądania i drukowania raportu. Zakładka PODGLĄD WYDRUKU wstążki zawiera formanty umożliwiające dostosowanie rozmiaru strony, marginesów i orientacji (pionowa lub pozioma), a także zastosowanie innych opcji przeglądania. Opcje drukowania są zapisywane wraz z raportem podczas zapisywania projektu raportu. Zakładka PODGLĄD WYDRUKU zawiera także przycisk Drukuj umożliwiający wydrukowanie raportu oraz przycisk pozwalający na zamknięcie podglądu wydruku i powrót do poprzedniego widoku raportu (projektu, układu lub raportu). Po stronie można się poruszać za pomocą poziomego i pionowego paska przewijania. Przyciski Strona (w lewym dolnym rogu okna) służą do przechodzenia między stronami. Przyciski te, podobne jak przyciski na odtwarzaczu DVD, pozwalają przejść do następnej lub poprzedniej strony albo do pierwszej lub ostatniej strony raportu. Można również przejść do określonej strony, wpisując jej numer w polu tekstowym między przyciskiem poprzedniej i następnej strony.
Rozdział 20. Prezentowanie danych za pomocą raportów
577
Rysunek 20.16. Raport tblProducts_ Kreator wyświetlający się w powiększonym trybie podglądu
Kliknięcie na raporcie prawym przyciskiem myszy i wybranie opcji Kilka stron albo skorzystanie z grupy Powiększenie zakładki PODGLĄD WYDRUKU na wstążce umożliwia podgląd na ekranie więcej niż jednej strony. Na rysunku 20.17 pokazano raport w trybie dwustronicowego podglądu raportu. Za pomocą przycisków nawigacyjnych (w lewym dolnym rogu okna podglądu wydruku) można przełączać strony, tak jak przełącza się rekordy na arkuszu danych. Okno podglądu wydruku zawiera pasek narzędzi z często używanymi poleceniami drukowania. Jeśli po obejrzeniu podglądu jesteś z niego zadowolony, możesz kliknąć ikonę drukarki na pasku narzędzi, aby wydrukować raport. Jeśli efekty są niezadowalające, można kliknąć przycisk Zamknij, aby przełączyć się do okna projektu raportu, gdzie można wprowadzić dalsze zmiany. Publikowanie raportu w różnych formatach Istotną cechą zakładki Podgląd wydruku jest możliwość zapisywania raportu Accessa w różnych popularnych formatach, takich jak PDF, XPS (od ang. XML Paper Specification) lub HTML. Kliknięcie przycisku PDF lub XPS w grupie Dane z zakładki PODGLĄD WYDRUKU na wstążce powoduje otwarcie okna dialogowego Publikowanie jako pliku PDF lub XPS (zobacz rysunek 20.18). To okno dialogowe zawiera opcje umożliwiające zapisanie raportu w standardowym formacie PDF albo w wersji skondensowanej (przeznaczonej do wykorzystania w sieci Web). Można tu także określić folder docelowy eksportowanych plików.
578
Część V Formularze i raporty Accessa
Rysunek 20.17. Wyświetlanie kilku stron raportu w trybie wielostronicowego podglądu raportu Rysunek 20.18. Access 2013 zawiera zaawansowane opcje publikowania raportów
Rozdział 20. Prezentowanie danych za pomocą raportów
579
Widok w formacie PDF lub XPS nie różni się od raportu przeglądanego w środowisku Accessa. Każdy z tych formatów jest dziś powszechnie stosowany w środowiskach biznesowych. Okno projektu raportu Kliknięcie prawym przyciskiem myszy paska tytułu raportu i wybranie polecenia Widok projektu powoduje otwarcie okna projektu raportu. Jak widać na rysunku 20.19, projekt raportu odzwierciedla wybory dokonane w Kreatorze raportów.
Rysunek 20.19. Okno projektu raportu
Aby powrócić do trybu podglądu wydruku, należy kliknąć przycisk Podgląd wydruku na pasku narzędzi okna projektu albo wybrać polecenie Podgląd wydruku z grupy Widoki.
Drukowanie lub wyświetlanie raportu Ostatnim krokiem w procesie tworzenia raportu jest jego wyświetlenie lub przeglądanie. Drukowanie raportu Jest kilka sposobów pozwalających na wydrukowanie raportu:
Wybór polecenia Plik/Drukuj w głównym oknie Accessa (po podświetleniu raportu w okienku nawigacji) — powoduje otwarcie standardowego okna dialogowego Drukowanie systemu Windows. Za pomocą tego okna można wybrać zakres wydruku, liczbę kopii oraz właściwości drukowania.
Kliknięcie przycisku Drukuj na zakładce PODGLĄD WYDRUKU na wstążce Accessa — powoduje natychmiastowe wysłanie raportu do drukarki domyślnej, bez wyświetlenia okna dialogowego Drukowanie.
580
Część V Formularze i raporty Accessa
Przeglądanie raportów Raport można przeglądać w czterech różnych widokach: projektu, raportu, układu i podglądu wydruku (widok układu omówiono w następnym punkcie). Można również wydrukować raport na domyślnej drukarce systemu Windows. Okna podglądu omówiono już w poprzednich rozdziałach. W tym rozdziale opisano okno projektu raportu. Okno projektu raportu to jeden z dwóch widoków, w których można tworzyć i modyfikować raporty. Pracę z nowym raportem rozpoczyna się od wybrania tabeli lub kwerendy, które mają służyć jako źródło danych nowego raportu. Następnie należy kliknąć przycisk Pusty raport w zakładce TWORZENIE na wstążce Accessa. Domyślnie nowy raport wyświetli się w widoku układu, tak jak pokazano na rysunku 20.20. Rysunek 20.20. Widok układu nowego raportu bazującego na tabeli tblProducts
Widok układu umożliwia oglądanie rozmieszczenia formantów względem siebie w treści raportu, a także marginesów, nagłówków stron i stopek oraz innych szczegółów raportu. Najważniejszym ograniczeniem widoku układu raportu jest brak możliwości dokładnego dopracowania projektu raportu bez przełączenia się do widoku projektu. Widok układu służy głównie do dostosowania rozmieszczenia formantów względem siebie na raporcie. Widok ten nie jest przeznaczony do przesuwania po raporcie poszczególnych formantów. W widoku układu można również kliknąć prawym przyciskiem myszy dowolny formant i z menu podręcznego wybrać polecenie Właściwości. Arkusz właściwości umożliwia modyfikację ustawień domyślnych dla wybranego formantu. Na rysunku 20.21 pokazano wstążkę Accessa w czasie, kiedy raport jest otwarty w widoku układu. Zgodnie z oczekiwaniami opcje na wstążce dotyczą przede wszystkim dostosowania wyglądu formantów w raporcie.
Rozdział 20. Prezentowanie danych za pomocą raportów
581
Rysunek 20.21. Wstążka Accessa w czasie, kiedy raport jest otwarty w widoku układu Widok układu po raz pierwszy wprowadzono w Accessie 2007. We wcześniejszych wersjach widok ten nie był dostępny.
Zapisywanie raportów Projekt raportu można zapisać w dowolnym momencie, wybierając w oknie projektu polecenie Plik/Zapisz, Plik/Zapisz jako lub Plik/Eksportuj albo klikając przycisk Zapisz na pasku narzędzi szybkiego dostępu. Kiedy zapisujemy raport po raz pierwszy (a także każdorazowo po wybraniu polecenia Zapisz jako lub Eksport), wyświetla się okno dialogowe pozwalające na wybór lub wpisanie nazwy. Przed przystąpieniem do modyfikowania raportu warto zadbać o zapisanie jego kopii. Raporty mogą być dość złożone, dlatego łatwo może dojść do popełnienia pomyłki w projekcie raportu. W takiej sytuacji powrót do poprzedniego stanu może być trudny. Kopia zapasowa to cenne zabezpieczenie przed przypadkową utratą projektu raportu.
Zagadnienia związane z raportami typu pasmowego Raporty Accessa są projektowane w strukturze tzw. pasm. Projektowanie raportów typu pasmowego to ważne zagadnienie, dlatego projektanci Accessa powinni je dobrze poznać. W raporcie Accessa dane są przetwarzane rekord po rekordzie. Poszczególne pola mogą być umieszczane w różnych miejscach w raporcie. Pole może nawet występować w raporcie więcej niż raz, jeśli zajdzie taka potrzeba. Wielu początkujących projektantów Accessa jest zaskoczonych wyglądem raportów w widoku projektu. Niektórzy spodziewają się zobaczyć „stronę”, którą należy „udekorować” poprzez dodanie pól na dużej przestrzeni projektowej — podobnie jak w przypadku formularzy. Ponieważ jednak Access przetwarza dane raportu po jednym rekordzie, to widok projektu ma służyć do tego, by określić sposób ułożenia każdego wiersza na drukowanej stronie. Co więcej, w widoku projektu widoczne są również takie elementy, jak nagłówek i stopka strony oraz obszary zajmowane przez nagłówki i stopki. Każdy obszar zajmowany przez formanty odgrywa kluczową rolę w wyglądzie raportu podczas drukowania. Raporty dzielą się na sekcje, które w pewnych programach do tworzenia raportów noszą nazwę pasm (w Accessie są nazywane po prostu sekcjami). Access pobiera kolejne rekordy ze źródła danych, przetwarzając każdą sekcję po kolei i decydując (dla każdego rekordu z osobna), czy przetworzyć pola lub tekst w poszczególnych sekcjach. Na przykład sekcja stopki raportu jest przetwarzana dopiero po przetworzeniu ostatniego rekordu w zestawie rekordów.
582
Część V Formularze i raporty Accessa
Na rysunku 20.22 pokazano raport rptProductsSummary w widoku podglądu wydruku. Zwróćmy uwagę, że dane w raporcie pogrupowano według pola Category (Osobowe, Ciężarowe itp.). Każda grupa ma nagłówek grupy, w którym wyświetla się nazwa kategorii. Każda grupa ma również stopkę, w której wyświetlają się podsumowania dotyczące poszczególnych kategorii. Nagłówek strony zawiera opisy kolumn (ProductID, Description itd.). Stopka kończąca każdą grupę zawiera podsumowania dla wybranych kolumn. Rysunek 20.22. Fragment raportu rptProductSummary — raport zawierający pogrupowane sumaryczne dane
W Accessie dostępne są następujące sekcje raportu:
Nagłówek raportu — drukowany tylko na początku raportu; używany jako strona tytułowa.
Nagłówek strony — drukowany na górze każdej strony.
Nagłówek grupy — drukowany przed przetworzeniem pierwszego rekordu należącego do grupy.
Szczegóły — drukuje każdy rekord z tabeli lub zestawu rekordów.
Stopka grupy — drukowana po przetworzeniu ostatniego rekordu należącego do grupy.
Stopka strony — drukowana na dole każdej strony.
Stopka raportu — drukowana na końcu raportu po przetworzeniu wszystkich rekordów.
Na rysunku 20.23 pokazano raport rptProductSummary otwarty w widoku projektu. Jak można zauważyć, raport dzieli się na siedem sekcji. W sekcji grupy wyświetlane dane są pogrupowane według kategorii, więc widać sekcje [Category] – nagłówek i [Category] – stopka. Pozostałe sekcje także noszą nazwy odpowiadające pełnionym przez nie funkcjom.
Rozdział 20. Prezentowanie danych za pomocą raportów
583
Rysunek 20.23. Raport rptProductSummary w widoku projektu
W każdej sekcji można umieścić dowolny formant (np. pole tekstowe), ale Access przetwarza dane po jednym rekordzie. Podejmuje też pewne czynności (w oparciu o wartości pól grup, lokalizację strony albo położenie w raporcie), aby uaktywnić poszczególne sekcje. Przykład z rysunku 20.23 to typowy raport z wieloma sekcjami. Jak wyjaśniono, każda sekcja raportu ma inne przeznaczenie i jest inaczej wyzwalana. Nagłówki i stopki stron oraz raportów trzeba dodawać parami. Jeśli potrzebna jest tylko jedna z tych sekcji, należy zmniejszyć wysokość niepożądanej sekcji do zera albo ustawić jej właściwość Widoczny na Nie.
W przypadku usunięcia sekcji nagłówka i stopki traci się również wszystkie formanty zawarte w tej sekcji.
Sekcja nagłówka raportu Formanty umieszczone w sekcji nagłówka raportu są drukowane tylko raz, na początku raportu. Sekcji nagłówka raportu często używa się jako strony tytułowej albo umieszcza się w niej informacje, które wystarczy przekazać użytkownikowi raportu tylko raz. Można również sprawić, że formanty z sekcji nagłówka raportu zostaną wydrukowane na oddzielnej stronie, co pozwala utworzyć stronę tytułową i umieścić na niej grafikę lub zdjęcie. Sekcja nagłówka raportu ma właściwość Wymuszaj nową stronę. Jeśli ustawisz tę właściwość na Po sekcji, informacje w nagłówku raportu zostaną umieszczone na oddzielnej stronie. W nagłówku raportu można umieścić tylko dane z pierwszego rekordu.
584
Część V Formularze i raporty Accessa
Sekcja nagłówka strony Formanty umieszczone w sekcji nagłówka strony są zwykle drukowane na początku każdej strony. Jeśli nagłówek raportu nie zajmuje oddzielnej strony (pierwszej), sekcja nagłówka strony jest drukowana tuż pod nagłówkiem raportu. Zwykle nagłówków strony używa się jako nagłówków kolumn w raportach grupująco-sumujących; mogą też zawierać tytuł raportu. Sekcja nagłówka strony pokazana na rysunku 20.23 zawiera także poziome linie nad i pod formantami etykiet. Każda etykieta raportu może być oddzielnie przesuwana, powiększana lub zmniejszana. Można też osobno zmieniać formatowanie (kolor, cieniowanie, grubość obramowania i linii, a także typ oraz rozmiar czcionki) każdego formantu tekstowego. Sekcje nagłówka i stopki strony mają cztery możliwe ustawienia (określa się je we właściwościach raportu, a nie we właściwościach sekcji):
Wszystkie strony — nagłówek lub stopka strony są drukowane na każdej stronie.
Nie z nagłówkiem raportu — nagłówek lub stopka strony nie są drukowane na stronie, która zawiera nagłówek raportu.
Nie ze stopką raportu — gdy dla nagłówka lub stopki strony wybrane jest to ustawienie, stopka raportu jest umieszczana na odrębnej stronie. Na tej stronie nie pojawia się sekcja, dla której ustawiono tę opcję.
Nie z nagłówkiem/stopką raportu — stopka raportu jest umieszczana na odrębnej stronie. Sekcja z tym ustawieniem nie jest drukowana na tej stronie ani na stronie z nagłówkiem raportu.
Sekcja nagłówka grupy Sekcja nagłówka grupy zwykle wyświetla nazwę grupy, np. „Ciężarówki” lub „Motocykle”. Access wie, że wyświetlił wszystkie rekordy grupy w sekcji szczegółów, kiedy zmienia się nazwa grupy. W tym przykładzie rekordy szczegółów dotyczą poszczególnych produktów. Formant pola Category w nagłówku grupy informuje, że produkty tej grupy należą do określonej kategorii (ciężarówek bądź motocykli). Sekcje nagłówka grupy bezpośrednio poprzedzają sekcje szczegółów. Można zdefiniować wiele poziomów nagłówków i stopek grup. W tym raporcie dane są grupowane tylko według kategorii. Jednakże w niektórych raportach dane są grupowane według dat. Można zgrupować dane według roku albo miesiąca i roku, a w obrębie tych sekcji — według innej wartości, np. według kategorii. Aby nadać właściwościom grupy (takim jak Grupuj według, Interwał grupowania i Trzymaj razem) wartości inne niż domyślne, trzeba najpierw ustawić właściwość Nagłówek grupy albo Stopka grupy (lub obie) wybranego pola lub grupy. Więcej informacji na ten temat można znaleźć w dalszej części tego rozdziału.
Rozdział 20. Prezentowanie danych za pomocą raportów
585
Sekcja szczegółów Sekcja szczegółów przetwarza każdy rekord danych i właśnie w niej drukowane są poszczególne wartości. Często zawiera pole obliczeniowe, np. zysk obliczany przez wyrażenie matematyczne. W tym przykładzie sekcja szczegółów po prostu wyświetla dane z tabeli tblProduct z wyjątkiem ostatniego formantu. Zysk jest obliczany jako różnica wartości Cost i RetailPrice. Można poinformować Accessa o zamiarze dołączenia sekcji szczegółów do raportu, zmieniając właściwość Widoczny sekcji w oknie raportu projektu. Jeśli wyłączysz wyświetlanie wszystkich sekcji szczegółów (albo tylko niektórych), otrzymasz raport sumaryczny bez szczegółów lub tylko z niektórymi grupami.
Sekcja stopki grupy Sekcji stopki grupy używa się do obliczania sum wszystkich rekordów należących do grupy. W raporcie Zestawienie produktów wyrażenie =Suma([RetailPrice]-[Cost])dodaje wyniki wszystkich obliczeń tego typu dla wybranej kategorii. Wartość tego pola jest automatycznie zerowana, kiedy zmienia się grupa. Więcej informacji o wyrażeniach i polach tekstowych podsumowań można znaleźć w rozdziałach 9. i 21. Aby zmienić sposób obliczania sum, należy zmienić właściwość Suma bieżąca pola tekstowego w oknie projektu raportu. Jeśli wartość tej właściwości to Nie, widoczna jest tylko wartość bieżącego rekordu (jest to ustawienie domyślne). Wartość W grupie powoduje sumowanie wartości z tego formantu dla wszystkich rekordów z grupy. Wartość Wszędzie sprawia, że sumowane są wartości z formantu dla wszystkich rekordów z całego raportu.
Sekcja stopki strony Sekcja stopki strony zwykle zawiera numery stron albo sumy pól. W bardzo dużych raportach, zwłaszcza w takich, gdzie jest wiele stron szczegółów bez podsumowań, mogą się przydać zarówno sumy grup, jak i liczba stron. W raporcie Zestawienie produktów w sekcji stopki strony drukuje się numer strony dzięki połączeniu słowa „Strona” z wbudowanymi formantami numeru strony. Za pomocą tych formantów wyświetla się tekst Strona x z y, gdzie x jest bieżącym numerem strony, a y — łączną liczbą stron w raporcie. Aby wyświetlić numer strony, należy użyć pola tekstowego z następującym wyrażeniem we właściwości Źródło formantu: ="Strona: " & [Page] & " z " & [Pages]
Można również dodać datę wydruku wraz z godziną. Pole tekstowe wyświetlające numer strony znajduje się w sekcji Stopka strony na rysunku 20.23. Stopka strony raportu rptProductsSummary zawiera także bieżącą datę i godzinę — po lewej stronie stopki.
Sekcja stopki raportu Sekcja stopki raportu jest drukowana na końcu raportu po wydrukowaniu wszystkich sekcji szczegółów i stopek grupy. W stopkach raportu zwykle umieszcza się sumy łączne lub dane statystyczne (takie jak średnie i procenty) całego raportu. Stopka raportu
586
Część V Formularze i raporty Accessa
Zestawienie produktów zawiera wyrażenia =Suma sumujące wartości wszystkich pól liczbowych. Jeśli raport ma stopkę, sekcja stopki strony jest drukowana po sekcji stopki raportu.
Narzędzie raportujące w Accessie jest dwuprzebiegowe i może wstępnie przetwarzać wszystkie rekordy w celu obliczenia wartości (takich jak procenty) potrzebnych w raportach statystycznych. Dzięki temu można tworzyć wyrażenia, które obliczają procenty, w miarę jak Access przetwarza rekordy wymagające znajomości sumy łącznej.
Tworzenie raportu od podstaw Raport to kolejny sposób przeglądania danych z jednej lub wielu tabel. Trzeba pamiętać, że raport jest związany albo z jedną tabelą, albo z kwerendą, która pobiera dane z jednej lub wielu tabel. Kiedy tworzysz raport, musisz zdecydować, które pola kwerendy lub tabeli chcesz w nim umieścić. Jeśli nie chcesz oglądać wszystkich rekordów z tabeli, możesz związać raport z kwerendą. Jeśli nawet posługujesz się danymi z jednej tabeli, kwerenda pozwala utworzyć raport na podstawie określonych kryteriów wyszukiwania i kolejności sortowania. Aby wykorzystać dane z wielu tabel, właściwie nie ma innego sposobu, jak tylko związać raport z kwerendą. W przykładach zaprezentowanych w tym rozdziale wszystkie raporty są związane z kwerendami (nawet jeśli można powiązać raport z tabelą. Pomimo że być może dla wielu Czytelników jest to oczywiste, warto wspomnieć, że dane w drukowanym raporcie są statyczne i odzwierciedlają jedynie stan danych w bazie w chwili wydrukowania raportu. Z tego powodu, w celu udokumentowania chwili wydrukowania raportu, na każdym raporcie powinny znaleźć się data i godzina sporządzenia wydruku (najczęściej umieszcza się je w obszarze nagłówka lub stopki). Access pozwala utworzyć raport bez wiązania go z tabelą lub kwerendą, choć wówczas nie będzie zawierał żadnych pól. Dzięki temu można utworzyć szablony stron ze wspólnymi nagłówkami lub stopkami, zawierającymi na przykład numery stron albo datę i czas. Szablony te służą jako model dla innych raportów. Pola można dodać później, zmieniając źródło rekordów raportu.
Podczas lektury pozostałej części tego rozdziału dowiesz się, jak utworzyć raport Lista produktów (jedną ze stron tego raportu pokazano na rysunku 20.24). W kolejnych punktach zaprojektujesz podstawowy raport, połączysz dane i rozmieścisz je w odpowiednich miejscach. Podobnie jak w przypadku większości zadań w Accessie, istnieje wiele sposobów tworzenia raportu bez pomocy kreatora. Warto jednak posługiwać się konkretną metodą, ponieważ do utworzenia dobrego raportu niezbędne jest spójne podejście. Należy sporządzić listę kontrolną — zbiór czynności gwarantujących uzyskanie dobrego raportu za każdym razem. Po wykonaniu każdej czynności należy skreślić ją z listy. Na koniec uzyskiwany jest świetnie wyglądający raport. Metodę tę omówiono w kolejnych punktach.
Rozdział 20. Prezentowanie danych za pomocą raportów
587
Rysunek 20.24. Raport Lista produktów
Tworzenie nowego raportu i wiązanie go z kwerendą Pierwszą czynnością jest utworzenie nowego pustego raportu i powiązanie go z tabelą tblProducts. Tworzenie pustego raportu jest stosunkowo proste: 1. Wybierz zakładkę TWORZENIE na głównej wstążce Accessa. 2. Kliknij przycisk Pusty raport w grupie Raporty na wstążce. Access otworzy pusty raport w widoku układu i wyświetli okno dialogowe Lista pól (zobacz rysunek 20.25) nad raportem lub zadokowane po prawej stronie okna aplikacji. W tym momencie można skorzystać z dwóch różnych sposobów dodawania formantów do raportu: dalej pracować w widoku układu lub przełączyć się do widoku projektu. Każda z tych technik ma określone zalety, ale dla potrzeb tego przykładu wykorzystano widok projektu, ponieważ lepiej demonstruje proces tworzenia raportów Accessa. 3. Kliknij prawym przyciskiem myszy pasek tytułu raportu i z menu podręcznego wybierz polecenie Widok projektu. Okno raportu przekształci się w tradycyjne, złożone z sekcji okno projektowania raportu (zobacz rysunek 20.26). Na rysunku pokazano również otwarte okno Lista pól dla tabeli tblProducts. Okno to pozwala przeciągać pola z listy do odpowiednich sekcji nowego raportu. Na rysunku 20.26 pole Description przeciągnięto do sekcji Szczegóły raportu.
588
Część V Formularze i raporty Accessa
Rysunek 20.25. Pusty raport w widoku układu
Rysunek 20.26. Tworzenie nowego raportu w widoku projektu
Rozdział 20. Prezentowanie danych za pomocą raportów
589
Definiowanie rozmiaru i układu strony raportu Podczas planowania raportu należy wziąć pod uwagę własności dotyczące układu strony, a także rodzaj papieru i typ drukarki, które mają być wykorzystane do wygenerowania wydruku. Decyzje podejmuje się poprzez wprowadzanie danych w kilku oknach dialogowych i modyfikowanie właściwości. Dzięki ustawieniu właściwych parametrów można uzyskać pożądany wynik. Aby ustawić marginesy raportu, orientację papieru i inne cechy ogólne, należy kliknąć zakładkę Ustawienia strony na wstążce. Na rysunku 20.27 zaprezentowano fragment ekranu Accessa z zaznaczoną zakładką Ustawienia strony i otwartą opcją Marginesy.
Rysunek 20.27. Ustawienia marginesów raportu
Zwróć uwagę, że zakładka Ustawienia strony zawiera opcje umożliwiające ustawienie rozmiaru papieru, orientacji raportu (pionowa lub pozioma), jego marginesów oraz innych szczegółów. Rozwinięcie opcji Rozmiar lub Marginesy powoduje otwarcie zakładki zawierającej popularne ustawienia dla każdej z tych opcji. Raport rptProductDisplay powinien mieć układ pionowy, czyli być wyższy niż szerszy. Będzie drukowany na papierze formatu A4 (21×29,7 cm), a marginesy lewy, prawy, dolny i górny powinny być ustawione na 6,4 mm. Zwróć uwagę, że w oknie dialogowym na rysunku 20.27 zaznaczono opcję marginesów Wąskie, w której wszystkie cztery marginesy mają szerokość 6,4 mm. Jeśli marginesy, jakie chcesz zastosować w raporcie, nie są dostępne na zakładce Marginesy, można kliknąć przycisk Ustawienia strony w grupie Układ strony i wyświetlić okno dialogowe Ustawienia strony. W tym oknie dialogowym można określić marginesy, orientację oraz inne parametry układu strony. Aby ustawić prawą krawędź raportu Zestawienie produktów na 19 cm, wykonaj poniższe czynności: 1. Kliknij prawą krawędź raportu (w miejscu, gdzie biały arkusz styka się z szarym tłem). Wskaźnik myszy zmieni się w strzałkę o dwóch grotach. 2. Przeciągnij krawędź do znacznika 19 cm na linijce. Jednostki miary mogą być inne niż opisywane w niniejszym rozdziale. Konkretne opcje zależą od ustawień regionalnych w Panelu sterowania.
590
Część V Formularze i raporty Accessa
Jeśli w oknie projektu raportu nie wyświetla się linijka, wybierz zakładkę ROZMIESZCZANIE, przejdź do grupy Pokazywanie/ukrywanie i kliknij ikonę linijki. Można też zmienić właściwość Szerokość w oknie właściwości raportu.
Jeśli w wyświetlonym raporcie co druga strona jest pusta, oznacza to, że szerokość raportu przekracza szerokość strony. Aby rozwiązać ten problem, należy zmniejszyć lewy i prawy margines albo szerokość raportu. Czasem podczas przesuwania formantów można przypadkowo zwiększyć szerokość raportu w stosunku do pierwotnego projektu. Jeśli na przykład w raporcie pionowym suma szerokości lewego marginesu, raportu i prawego marginesu przekracza 21 cm, pojawią się puste strony.
Umieszczanie formantów na raporcie Access w pełni wykorzystuje funkcję przeciągania i upuszczania stosowaną w systemie Windows; metoda umieszczania pól w raporcie nie stanowi wyjątku. 1. Kliknij przycisk Dodaj istniejące pola w grupie Narzędzia w zakładce PROJEKTOWANIE. Wyświetli się okno Lista pól. 2. Jeśli żądany formant ma być inny niż domyślny formant dla danego pola tabeli, kliknij odpowiedni przycisk na przyborniku. 3. Zaznacz pola, które mają się znaleźć w raporcie, i przeciągnij je do odpowiednich sekcji w oknie projektu raportu. Aby zaznaczyć więcej niż jedno pole, należy przytrzymać klawisz Ctrl podczas klikania pól w oknie Lista pól. W zależności od tego, czy podczas przeciągania pól do raportu zaznaczysz jedno czy wiele pól, kształt wskaźnika myszy zmienia się, ilustrując dokonany wybór. Pola pojawią się w sekcji szczegółów raportu (zobacz rysunek 20.28). Zwróć uwagę, że każdemu polu przeciągniętemu z okna listy pól odpowiadają dwa formanty. Kiedy dodajesz pole metodą „przeciągnij i upuść”, Access automatycznie tworzy formant etykiety dołączony do pola tekstowego, z którym związane jest pole tabeli. Access zawsze tworzy formant związanej ramki obiektu dla pól tabeli typu Obiekt OLE, np. dla pola Picture_Small na rysunku 20.28. Zauważ, że sekcja szczegółów automatycznie się zwiększa, aby pomieścić wszystkie formanty. Ponad związaną ramką obiektu znajduje się formant odpowiadający polu typu Długi tekst — Features.
W sekcji nagłówka strony trzeba umieścić formanty, które będą wyświetlać informacje o kliencie. Przedtem jednak należy zwiększyć ramkę nagłówka strony, aby zrobić miejsce na tytuł raportu.
Zmiana rozmiaru sekcji Aby zrobić miejsce na tytuł raportu w sekcji nagłówka strony, trzeba zwiększyć rozmiar sekcji. W tym celu należy umieścić wskaźnik myszy na dole sekcji, której rozmiar chcesz zmienić. Wskaźnik zmieni się w pionową strzałkę o dwóch grotach i będzie widoczny w dolnej części sekcji; należy przeciągnąć krawędź sekcji w górę lub w dół, aby zmniejszyć lub zwiększyć sekcję.
Rozdział 20. Prezentowanie danych za pomocą raportów
591
Rysunek 20.28. Raport, do którego dodano kilka pól
W omawianym przykładzie należy zmienić rozmiar sekcji Nagłówek strony poprzez przeciągnięcie dolnego marginesu nagłówka strony w dół, w taki sposób, aby jej wysokość wynosiła około 2 cm. Do przeciągnięcia formantów do raportu wykorzystaj grupę Formanty na zakładce PROJEKTOWANIE. Dodaj dwie etykiety do sekcji nagłówka strony i wpisz Lista produktów we właściwości Tytuł jednej z nich oraz MiniAuta dla Kolekcjonerów w drugiej. Dodane etykiety są niepołączone — nie są powiązane z żadnym z formantów w raporcie. Podczas przeciągania pola z okna Lista pól Access dodaje nie tylko pole tekstowe przeznaczone na dane pola, ale także etykietę, która spełnia rolę identyfikatora pola tekstowego. Etykiety przeciągane z grupy Formanty na wstążce Accessa są niepołączone — nie są powiązane z polami tekstowymi ani z żadnymi innymi formantami w raporcie. Jak można zauważyć, sekcja Nagłówek strony rozszerzyła się po to, by pomieścić przeciągnięte do sekcji formanty etykiet. Wszystkie pola potrzebne do utworzenia raportu Lista produktów zostały raz umieszczone w odpowiednich sekcjach. Aby utworzyć etykietę wielowierszową, należy nacisnąć klawisze Ctrl+Enter w miejscu, w którym chcemy rozpocząć nowy wiersz. Jeśli edytujesz lub wprowadzasz tytuł, który nie mieści się w oknie właściwości, zawartość pola będzie przewijać się w miarę pisania. Aby mieć więcej miejsca, można otworzyć okno Powiększenie, naciskając klawisze Shift+F2.
592
Część V Formularze i raporty Accessa
Modyfikowanie wyglądu tekstu w formancie Aby zmodyfikować wygląd tekstu w formancie, należy zaznaczyć formant, klikając jego obramowanie (nie środek formantu). Następnie można wybrać sposób formatowania etykiety, klikając odpowiedni przycisk na zakładce FORMATOWANIE. Aby wyróżnić tytuły raportu, zmodyfikuj wygląd tekstu w etykietach, wykonując poniższe czynności: 1. W sekcji nagłówka raportu kliknij nowo utworzoną etykietę tytułu raportu Lista produktów. 2. Kliknij zakładkę FORMATOWANIE na wstążce, a następnie kliknij przycisk Pogrubienie w grupie Czcionka. 3. Kliknij strzałkę obok listy rozwijanej Rozmiar czcionki i wybierz z listy pozycję 18. 4. Powtórz tę procedurę dla etykiety MiniAuta dla Kolekcjonerów, używając pogrubienia i czcionki Arial o rozmiarze 12 punktów. Rozmiar etykiet może nie pasować do tekstu, który ma się w nich wyświetlić. Aby zmniejszyć etykietę lub wyświetlić cały tekst, jeśli rozmiar etykiety nie jest wystarczający, należy kliknąć dwukrotnie dowolny z uchwytów zmiany rozmiaru — Access dobierze wówczas odpowiedni rozmiar dla etykiety. Etykiety po ich dodaniu do sekcji Nagłówek strony oraz powiększeniu i sformatowaniu pokazano na rysunku 20.29. Rysunek 20.29. Dodawanie niezwiązanych etykiet do raportu
Praca z polami tekstowymi Do tej pory dodawałeś do raportu formanty związane z polami tabeli oraz niezwiązane etykiety służące do wyświetlania tytułów. Do raportów często dodaje się jeszcze jeden typ pola tekstowego, a mianowicie niezwiązane pole tekstowe, które przechowuje wyrażenie wyświetlające numer strony, datę albo wynik obliczeń. Tworzenie i używanie formantów pola tekstowego W raportach pola tekstowe pełnią dwie funkcje:
pozwalają wyświetlić dane przechowywane w określonym polu tabeli lub kwerendy;
wyświetlają wyniki wyrażeń.
Rozdział 20. Prezentowanie danych za pomocą raportów
593
Wyrażeniami mogą być obliczenia, których argumentami są inne formanty, obliczenia używające funkcji Accessa (wbudowanych lub zdefiniowanych przez użytkownika) albo ich kombinacja. Wprowadzanie wyrażenia w polu tekstowym Wyrażenia umożliwiają tworzenie wartości, których nie ma w tabeli lub kwerendzie. Mogą to być proste funkcje (np. zwracające numer strony) albo skomplikowane obliczenia matematyczne. Wyrażenia zostało opisane bardziej szczegółowo w rozdziale 9.
Funkcja to niewielki program, który po wykonaniu zwraca pojedynczą wartość. Może to być jedna z wielu wbudowanych funkcji Accessa albo funkcja zdefiniowana przez użytkownika. Poniżej wyjaśniamy, jak dodać do raportu niezwiązane pole tekstowe wyświetlające numer strony: 1. Kliknij w środku sekcji stopki strony, ustaw wysokość stopki strony na około 1,5 cm. 2. Przeciągnij pole tekstowe z grupy Formanty w zakładce PROJEKTOWANIE i upuść je w obszarze stopki strony. Ustaw wysokość pola tekstowego na wartość około trzech czwartych wysokości sekcji Stopka strony, a szerokość na wartość około 1,5 cm. 3. Zaznacz etykietę powiązaną z polem tekstowym i zmień jej zawartość tak, by zawierała słowo „Strona:”. 4. Zaznacz pole tekstowe (wyświetla się w nim napis Niezwiązane) i wpisz w nim formułę =Page. Można też otworzyć arkusz właściwości (wciśnij F4) i wpisać =[Page] jako właściwość Źródło rekordów pola tekstowego. 5. Przeciągnij nowy formant pola tekstowego w taki sposób, aby znalazł się w pobliżu prawej krawędzi strony raportu (zobacz rysunek 20.30). Można również przesunąć etykietę pola tekstowego tak, aby znalazła się blisko pola. Użycie uchwytu w lewym górnym rogu etykiety pozwala na przemieszczanie etykiety niezależnie od pola tekstowego. Rysunek 20.30. Dodawanie wyrażenia wyświetlającego numer strony w polu tekstowym
W każdej chwili można obejrzeć wyniki. Aby to zrobić, należy kliknąć przycisk Podgląd wydruku na pasku narzędzi i powiększyć sekcję stopki strony, aby sprawdzić numer strony.
594
Część V Formularze i raporty Accessa
Zmiana rozmiaru pola tekstowego lub etykiety Aby zaznaczyć formant, wystarczy go kliknąć. W zależności od rozmiaru formantu pojawi się wówczas od trzech do siedmiu uchwytów zmiany rozmiaru — po jednym w każdym rogu z wyjątkiem lewego górnego i po jednym na każdym boku. Kiedy wskaźnik znajdzie się nad uchwytem zmiany rozmiaru, zmienia się w strzałkę z dwoma grotami. Gdy tak się stanie, należy kliknąć formant i rozciągnąć go do pożądanego rozmiaru. Warto zauważyć, że podczas przeciągania kursora myszy pojawia się kropkowany zarys, który wskazuje, jaki rozmiar będzie miał formant po zwolnieniu przycisku myszy. Jeśli klikniesz dwukrotnie jeden z uchwytów zmiany rozmiaru, Access zmieni rozmiar formantu tak, aby jak najlepiej dopasować go do rozmiaru tekstu. Przydaje się to zwłaszcza wtedy, gdy ktoś zmieni rozmiar czcionki i potem zauważy, że tekst nie pasuje do formantu. Zwróć uwagę, że w przypadku etykiet mechanizm dopasowywania rozmiaru dostosowuje rozmiar w poziomie i w pionie, natomiast w przypadku pól tekstowych — tylko w pionie. Dzieje się tak dlatego, że w trybie projektu Access nie może przewidzieć szerokości pola tekstowego — nazwa pola i jego zawartość mogą znacznie się różnić. Zdarza się, że rozmiar etykiet nie zostanie poprawnie ustawiony i trzeba go wyregulować ręcznie. Aby automatycznie zmienić rozmiar etykiety, można również wybrać polecenie Format/Rozmiar/Dopasuj.
Przed przystąpieniem do dalszych zadań warto sprawdzić postępy. Warto też często zapisywać raport zaraz po dokonaniu w nim zmian. Można wydrukować jedną stronę na drukarce, ale łatwiej wyświetlić raport w podglądzie wydruku. Wystarczy kliknąć prawym przyciskiem myszy pasek tytułu raportu i z menu podręcznego wybrać polecenie Podgląd wydruku. Na rysunku 20.31 pokazano powiększony podgląd wydruku raportu w bieżącej postaci. Na samej górze strony znajduje się jej nagłówek, a poniżej niego informacje pochodzące z rekordu pierwszego produktu. W miarę przemieszczania myszy nad podglądem wydruku kursor zmienia się w szkło powiększające. Wystarczy kliknąć dowolną część widoku, aby go powiększyć i dokładnie przeanalizować układ raportu. Ze względu na pionowy układ pól raport wyświetla tylko jeden rekord na stronę. W następnym punkcie przesuniesz pola tak, aby utworzyć poziomy układ. Usuwanie i wycinanie etykiet dołączonych do pól tekstowych Aby utworzyć raport pokazany na rysunku 20.31, należy przesunąć etykiety pól tekstowych z sekcji Szczegóły do sekcji Nagłówek strony oraz rozmieścić pola tekstowe w układzie tabelarycznym. Po przesunięciu formanty wyświetlą się jako nagłówki kolumn danych i będą się powtarzały na każdej stronie raportu. Usuwanie jednego lub wielu dołączonych formantów jest bardzo łatwe — wystarczy zaznaczyć żądane formanty i nacisnąć klawisz Delete. Aby jednak przenieść etykietę do sekcji nagłówka strony (zamiast jej usuwania), można ją wyciąć zamiast kasowania. Podczas usuwania połączonych formantów dostępne są następujące opcje:
Rozdział 20. Prezentowanie danych za pomocą raportów
595
Rysunek 20.31. Podgląd wydruku raportu
usunięcie tylko etykiety;
wycięcie etykiety i umieszczenie jej w schowku;
usunięcie lub wycięcie zarówno etykiety, jak i formantu pola.
Z niewiadomych względów nie można przeciągnąć etykiety z sekcji szczegółów do nagłówka strony. Próba przeciągnięcia połączonej etykiety z sekcji szczegółów powoduje przeciągnięcie także pola tekstowego. Aby przenieść etykietę, należy wyciąć ją w sekcji szczegółów i wkleić w sekcji nagłówka strony. Po wybraniu pól wytnij je, wciskając kombinację klawiszy Ctrl+X lub wybierając z menu polecenie Edycja/Wytnij. Jeśli zaznaczysz formant pola i go wytniesz lub usuniesz, spowoduje to usunięcie zarówno etykiety, jak i formantu pola. Aby wyciąć etykietę dołączoną do formantu (w tym przypadku etykietę dołączoną do pola Description), wykonaj poniższe czynności: 1. Kliknij przycisk Zamknij na pasku narzędzi, aby wyłączyć tryb podglądu wydruku. 2. Zaznacz etykietę Description w sekcji szczegółów. 3. Naciśnij klawisze Ctrl+X (polecenie Wytnij). Wyciętą etykietę można umieścić w innym miejscu. W tym przykładzie umieść ją w sekcji nagłówka strony.
596
Część V Formularze i raporty Accessa
Wklejanie etykiet do sekcji raportu Wycinanie etykiet dołączonych do formantów w sekcji szczegółów i wklejanie ich w sekcji nagłówka strony jest równie łatwe jak usuwanie etykiet i tworzenie nowych w nagłówku strony. Niezależnie od sposobu umieszczenia etykiety w schowku teraz wklej etykietę wyciętą w poprzednim kroku: 1. Kliknij gdziekolwiek w sekcji nagłówka strony. 2. Naciśnij klawisze Ctrl+V (polecenie Wklej). Etykieta Opis pojawi się w nagłówku strony. 3. Zrób to samo z etykietami Sztuk w magazynie, Cena i Koszt. Jeśli przypadkowo zaznaczysz formant pola danych i usuniesz lub wytniesz formant wraz z etykietą, możesz nacisnąć przycisk Cofnij na pasku narzędzi lub wcisnąć klawisze Ctrl+Z, aby wrócić do stanu wyjściowego. Aby usunąć tylko formant pola, a zachować dołączony formant etykiety, należy kliknąć prawym przyciskiem myszy etykietę i wybrać polecenie Kopiuj z menu podręcznego. Następnie, w celu usunięcia zarówno formantu pola, jak i etykiety, trzeba nacisnąć klawisz Delete. Wreszcie należy kliknąć prawym przyciskiem myszy w dowolnym miejscu na raporcie i wybrać z menu podręcznego polecenie Wklej, aby wkleić do raportu tylko skopiowaną etykietę.
Przesuwanie etykiet i pól tekstowych Przed przejściem do omówienia przesuwania etykiet i pól tekstowych warto jeszcze raz przypomnieć kilka różnic między formantami połączonymi a niepołączonymi. Kiedy wraz z polem tekstowym tworzona jest połączona etykieta, powstaje formant złożony. Kiedy przesuwasz jeden z elementów formantu złożonego, drugi przesuwa się wraz z nim. Oznacza to, że przesunięcie pola tekstowego lub etykiety powoduje jednocześnie przesunięcie połączonego formantu. Aby przesunąć oba elementy formantu złożonego, należy zaznaczyć jeden z nich kliknięciem myszy. Przesunięcie wskaźnika myszy nad jeden z dwóch elementów powoduje zmianę wskaźnika myszy w ikonę dłoni. Wówczas należy kliknąć formanty i przesunąć je w inne miejsce. Gdy przeciągasz formanty, wraz ze wskaźnikiem myszy porusza się ich zarys. Aby przesunąć tylko jeden element formantu złożonego, należy przeciągnąć żądany element za jego uchwyt przesuwania (duży kwadrat w lewym górnym rogu formantu). Po kliknięciu formantu złożonego wydaje się, że zaznaczone zostają oba jego elementy, ale jeśli przyjrzysz się dokładniej, zauważysz, że zaznaczony jest tylko jeden z nich (ten, wokół którego wyświetlają się uchwyty zmiany rozmiaru). Niezaznaczony formant wyświetla tylko uchwyt przesuwania. Ikona dłoni z wyciągniętym palcem wskazującym oznacza, że wybrano uchwyt przesuwania i można przesunąć jeden z formantów. Aby przesunąć jeden formant niezależnie od drugiego, należy kliknąć uchwyt przesuwania i przeciągnąć formant w nowe miejsce. Aby przesunąć niedołączoną etykietę, wystarczy kliknąć jej obramowanie (w miejscu, w którym nie ma uchwytu) i przeciągnąć.
Rozdział 20. Prezentowanie danych za pomocą raportów
597
Aby zaznaczyć grupę formantów, wystarczy kliknąć gdzieś poza grupą i przeciągnąć wskaźnik przez formanty lub wokół formantów, które chcemy zaznaczyć. Wyświetli się szary prostokąt, który wskazuje zakres zaznaczenia. Po zwolnieniu przycisku myszy zostaną zaznaczone wszystkie formanty otoczone przez prostokąt. Następnie można przeciągnąć grupę formantów w nowe miejsce. Opcja Plik/Opcje/Projektanci obiektu/Formularze/Raporty/Zachowanie podczas zaznaczania to właściwość, która określa sposób zaznaczania formantów. Zaznaczone zostają albo formanty otoczone w pełni (prostokąt musi całkowicie otaczać formant), albo częściowo (wystarczy, że prostokąt dotyka formantu — jest to ustawienie domyślne).
Zmień też rozmiar wszystkich formantów w sposób pokazany na rysunku. Zmodyfikuj rozmiar i kształt pola Feature typu Długi tekst oraz pola Picture typu Obiekt OLE. Pole Picture typu Obiekt OLE wyświetla się w widoku projektu jako prostokąt bez nazwy pola. Na rysunku 20.32 jest widoczne na dole nad stopką. Rysunek 20.32. Reorganizacja formantów w raporcie
Aby uzyskać końcowy układ, umieść wszystkie formanty w odpowiednich miejscach. Na rysunku 20.32 pokazano jeden z możliwych układów formantów. Warto przesuwać formanty grupami, zaznaczając kilka formantów jednocześnie i przenosząc je w pobliże docelowego miejsca. Następnie można ustawić dokładnie ich położenie. Formanty umieść w odpowiednich miejscach zgodnie z rysunkiem 20.32.
598
Część V Formularze i raporty Accessa
W tym momencie jesteś mniej więcej w połowie pracy. Ekran powinien wyglądać tak jak na rysunku 20.32. Należy pamiętać, że rysunki sporządzono w systemie Windows przy rozdzielczości ekranu równej 1024×768 pikseli. Jeśli ktoś używa niższej rozdzielczości albo dużych czcionek (włącza się je w oknie dialogowym Właściwości: Ekran w panelu sterowania), będzie musiał przewinąć okno, aby zobaczyć cały raport. Właśnie ukończyłeś podstawowy projekt raportu. Trzeba jeszcze zmienić niektóre właściwości, czcionki i rozmiary. Po wprowadzeniu tych zmian należy ponownie przesunąć pola. Raport pokazany na rysunku 20.32 to tylko przykład. Podczas ulepszania raportu w oknie projektu pamiętaj, że najważniejsze jest to, jak wygląda on na Twoim komputerze. Modyfikowanie wyglądu wielu formantów Następnym etapem będzie dodanie pogrubienia wszystkich etykiet znajdujących się w sekcji nagłówka strony tuż nad separatorem sekcji. Poniżej wyjaśniamy, jak zmienić wygląd tekstu w wielu etykietach jednocześnie: 1. Zaznacz wszystkie etykiety na dole sekcji nagłówka strony, przytrzymując wciśnięty klawisz Shift i kolejno je klikając. Można też kliknąć pionową linijkę wyświetlającą się z lewej strony etykiet w nagłówku strony. Access zaznaczy wtedy wszystkie formanty umieszczone na prawo od miejsca kliknięcia. Na ekranie można zaznaczyć cztery etykiety (zobacz rysunek 20.32). Inna możliwość to przeciągnięcie ramki wokół wszystkich formantów etykiet w obszarze nagłówka strony. 2. Kliknij przycisk Pogrubienie na pasku narzędzi. Po wprowadzeniu ostatnich modyfikacji raport będzie niemal gotowy — trzeba będzie jeszcze poprawić formant obrazu. W tym celu należy zmodyfikować pewne właściwości. Zrobisz to w następnym punkcie. Liczba etapów może się wydawać bardzo duża, bo poszczególne procedury specjalnie zaprojektowano tak, aby pokazać, że tworzenie raportu zabiera sporo czasu. Należy jednak pamiętać, że kiedy klikasz myszą, nie zdajesz sobie nawet sprawy, ile pracy oszczędzasz, projektując raport metodą wizualną. Narzędzia typu WYSIWYG (ang. What You See Is What You Get — uzyskujesz to, co widzisz), takie jak projektant raportów w Accessie, wymagają wykonywania wielu czynności, ale i tak jest to znacznie łatwiejsze i szybsze niż programowanie. Na rysunku 20.32 pokazano ostateczną wersję projektu raportu po wykonaniu czynności opisanych w tym punkcie. W następnym punkcie zobaczysz, jak ulepszyć ten projekt.
Zmiana właściwości etykiet i pól tekstowych Aby zmienić właściwości pola tekstowego lub etykiety, trzeba wyświetlić arkusz właściwości formantu. Jeśli jeszcze się nie wyświetla, wykonaj jedną z poniższych czynności:
Kliknij dwukrotnie obramowanie formantu (w dowolnym miejscu poza uchwytem zmiany rozmiaru albo uchwytem przesuwania).
Zaznacz formant i wciśnij F4.
Kliknij formant prawym przyciskiem myszy i wybierz Właściwości.
Wciśnij F4, aby otworzyć okno arkusza właściwości, i skorzystaj z listy rozwijanej w górnej części okna, aby wybrać formularz lub formant na formularzu.
Rozdział 20. Prezentowanie danych za pomocą raportów
599
Arkusz właściwości pozwala obejrzeć właściwości formantu i łatwo je zmodyfikować. Narzędzia takie jak okna formatowania i przyciski formatowania z zakładki FORMATOWANIE również umożliwiają modyfikowanie właściwości formantów. Jeśli na przykład klikniesz przycisk Pogrubienie, w rzeczywistości ustawisz właściwość Grubość czcionki na Pogrubiona. Użycie formantów z zakładki FORMATOWANIE jest zwykle znacznie bardziej intuicyjne, ale niektórych właściwości nie da się zmienić w ten sposób. Ponadto niektóre obiekty mają więcej opcji dostępnych tylko na arkuszu właściwości. Właściwość Tryb wymiarowania obiektu OLE (związanej ramki obiektu) z ustawieniami Obetnij, Rozciągnij i Powiększ to dobry przykład właściwości dostępnej tylko na arkuszu właściwości. Formant obrazu, czyli związanej ramki obiektu, ma obecnie właściwość Tryb wymiarowania ustawioną na domyślną wartość Powiększ. Gdy wartość tej właściwości to Obetnij, obraz jest wyświetlany w oryginalnym rozmiarze i Access może przyciąć krawędzie obrazu lub wyświetlić pusty obszar wokół niego. Przy ustawieniu Rozciągnij obraz zajmuje cały formant, jednak może być zniekształcony, jeśli proporcje ramki są inne niż proporcje grafiki. Ustawienie Powiększ pozwala zachować proporcje i dopasować obraz do ramki. Wokół obrazu może pojawić się wtedy pusta przestrzeń, ale jest to zwykle lepsze od zniekształcenia grafiki. Można również zmienić właściwość Styl obramowania na wartość Przezroczysty — wówczas w raporcie nie wyświetli się ramka wokół zdjęcia. W ostatnim kroku usuń etykietę powiązaną z formantem obrazu. Etykiety przy formantach Features i Picture są niepotrzebne, ponieważ użytkownik z pewnością domyśli się, jakie dane są mu wyświetlane. Zaznacz powiązane z tymi formantami etykiety i wciśnij klawisz Delete, aby je usunąć. Następnie przenieś formant obrazu w taki sposób, aby znalazł się na prawo od formantu Features. W ten sposób wprowadzone zostały kolejne zmiany w raporcie. Na rysunku 20.33 przedstawiono podgląd wydruku kilku pierwszych rekordów. Zauważ, że obrazy są obecnie prawidłowo wyświetlane, a pole Features znajduje się na dole każdej sekcji szczegółów.
Powiększanie i zmniejszanie pól tekstowych Podczas drukowania lub wyświetlania w podglądzie wydruku formantów, które mogą zawierać tekst o zmiennej długości, Access daje możliwość powiększenia lub zmniejszenia wysokości pola w zależności od zawartości rekordu. Właściwości Można powiększać i Można zmniejszać określają, czy pole tekstowe zmieni swój pionowy wymiar w taki sposób, by dostosować się do ilości tekstu wyświetlanej w związanym polu. Chociaż właściwości te przydają się dla dowolnych formantów tekstowych, są szczególnie przydatne dla pól tekstowych. Dopuszczalne wartości tych dwóch właściwości zestawiono w tabeli 20.1.
600
Część V Formularze i raporty Accessa
Rysunek 20.33. Raport wyświetlony w widoku podglądu wydruku
Tabela 20.1. Ustawienia właściwości Można powiększać i Można zmniejszać Właściwość
Wartość
Opis
Można powiększać
Tak
Jeśli dane rekordu zajmują więcej wierszy, niż formant może wyświetlić, formant automatycznie zmienia rozmiar, by pomieścić dodatkowe wiersze.
Można powiększać
Nie
Jeśli dane rekordu zajmują więcej wierszy, niż formant może wyświetlić, formant nie zmienia rozmiaru i wyświetla tylko część danych.
Można zmniejszać
Tak
Jeśli dane rekordu zajmują mniej wierszy, niż formant może wyświetlić, formant automatycznie zmienia rozmiar, by wyeliminować puste wiersze. Aby można było zmniejszać sekcję, właściwość Można zmniejszać wszystkich formantów w sekcji musi być ustawiona na wartość Tak.
Można zmniejszać
Nie
Jeśli dane rekordu zajmują więcej wierszy, niż formant może wyświetlić, formant nie zmienia rozmiaru, by wyeliminować puste wiersze.
Aby zmienić właściwość Można powiększać pola tekstowego, wykonaj poniższe czynności: 1. Zaznacz pole tekstowe Features. 2. Wyświetl okno właściwości. 3. Kliknij właściwość Można powiększać, a następnie kliknij strzałkę i wybierz ustawienie Tak.
Rozdział 20. Prezentowanie danych za pomocą raportów
601
Właściwości Można powiększać i Można zmniejszać są również dostępne w sekcjach raportu. Aby je zmodyfikować, należy użyć arkusza właściwości sekcji. Ustawienie właściwości Można powiększać i Można zmniejszać sekcji raportu dotyczy tylko tej sekcji, a nie formantów, które są w niej zawarte. Aby można było zwiększać formanty w wybranej sekcji raportu, trzeba jednak zmienić ustawienie właściwości Można powiększać na Tak. Jeśli ustawienie właściwości Można powiększać sekcji nie będzie włączone, formanty będzie można powiększać tylko w takim zakresie, na jaki pozwala obramowanie sekcji.
Raport wygląda coraz lepiej, ale warto jeszcze zgrupować podobne dane i określić kolejność sortowania danych. Aby to zrobić, należy wykorzystać możliwości sortowania i grupowania.
Sortowanie i grupowanie danych Przydatność danych zaprezentowanych w raporcie można zwiększyć poprzez odpowiednie ich pogrupowanie. Przypuśćmy, że chcesz uporządkować listę produktów według kategorii, a w ramach każdej kategorii — według opisu. W tym celu należy skorzystać z pól Category i Description do pogrupowania i posortowania danych. Tworzenie nagłówka lub stopki grupy Pogrupowanie danych w raporcie według określonego pola powoduje dodanie do niego dwóch sekcji (Nagłówek grupy i Stopka grupy). W czynnościach wyszczególnionych poniżej wykorzystano nagłówek grupy do wyświetlenia nazwy kategorii produktu nad każdą grupą rekordów. Nie jest tu używana stopka grupy Category, ponieważ nie są obliczane podsumowania dla całej kategorii. Nie ma też innych powodów, by trzeba było skorzystać ze stopki grupy. Aby utworzyć nagłówek grupy Category, wykonaj następujące czynności: 1. Kliknij przycisk Grupuj i sortuj w grupie Grupowanie i sumy w zakładce PROJEKTOWANIE. W dolnej części ekranu pojawi się panel Grupowanie, sortowanie i sumowanie. 2. Kliknij przycisk Dodaj grupę w obszarze Grupowanie, sortowanie i sumowanie. 3. Wybierz pole Category z listy pól. Access wyświetli napis Grupuj według Kategoria z literą A na górze w obszarze Grupowanie, sortowanie i sumowanie. Po wybraniu pola grupowania Category Access doda sekcje Category – nagłówek i Category – stopka do projektu raportu. Sekcja Category – nagłówek została umieszczona pomiędzy sekcjami Nagłówek strony i Szczegóły. Jeśli zdefiniujesz stopkę grupy, pojawi się ona pod sekcją Szczegóły, ale nad sekcją Stopka strony. Jeśli w raporcie jest wiele poziomów grupowania, każda kolejna grupa będzie umieszczona bezpośrednio przy sekcji szczegółów. Grupy zdefiniowane jako pierwsze są umieszczone najdalej od sekcji szczegółów. Okienko właściwości grupy (wyświetlane po kliknięciu przycisku Więcej dla grupy) zawiera wyrażenie, w którym poszczególne opcje są oddzielone od siebie przecinkami. Opcje mają postać list rozwijanych lub tekstu, który można kliknąć, aby ustawić daną właściwość. Dla grupy Category dostępne są następujące opcje:
602
Część V Formularze i raporty Accessa
Grupuj według Category — określa pole, na podstawie którego dane są grupowane. Można zmienić tę wartość nawet po ustawieniu pola. W tym celu należy wybrać z listy rozwijanej inne pole.
Z literą A na górze — określa porządek sortowania (tu jest to porządek alfabetyczny). Aby odwrócić kolejność, wybierz opcję Z literą Z na górze.
Według całych wartości — przy tym ustawieniu grupy są tworzone na podstawie wartości w danym polu. Można też grupować dane według pierwszego znaku w polu, pierwszych dwóch znaków lub dowolnej innej liczby znaków wpisanej w polu Znaki.
Bez sum — określa, czy w nagłówku lub stopce grupy mają pojawiać się podsumowania. Można wybrać pole, z którego wartości będą podsumowywane, i rodzaj przeprowadzanych obliczeń.
Z tytułem — tu można określić tytuł grupy
Z sekcją nagłówka — powoduje wyświetlenie sekcji nagłówka dla grupy. Aby ukryć nagłówek, wybierz opcję Bez sekcji nagłówka.
Bez sekcji stopki — powoduje ukrycie sekcji stopki dla grupy. Aby wyświetlić stopkę, wybierz opcję Z sekcją stopki.
Nie zachowuj całej grupy na jednej stronie — umożliwia kontynuowanie grupy na następnej stronie, jeśli informacji jest zbyt dużo, aby zmieściły się na bieżącej. Opcja Zachowaj całą grupę na jednej stronie powoduje utworzenie nowej strony, jeśli informacje nie mieszczą się na bieżącej. Opcja Zachowaj nagłówek i pierwszy rekord na jednej stronie sprawia, że nowa strona jest tworzona tylko wtedy, gdy brakuje miejsca na pierwszy rekord.
Kliknij przycisk Mniej, aby ukryć opcje po ich ustawieniu. Przedstawione opcje dotyczą grupowania danych według pola Category, które jest polem tekstowym. Dla innych typów pól dostępne są niektóre z opisanych oraz dodatkowe opcje. Oto opcje dla pól dat:
Od najstarszych do najnowszych — pola dat nie są sortowane „z literą A na górze”, ale od najstarszych do najnowszych. Aby odwrócić kolejność, wybierz opcję Od najnowszych do najstarszych.
Według kwartałów — umożliwia grupowanie danych według całych dat, dni, tygodni, miesięcy, kwartałów, lat, a także niestandardowych przedziałów czasu.
Pozostałe opcje w polach dat są takie same jak w polach tekstowych i nie trzeba ich ponownie opisywać. W polach liczbowych dostępne są następujące opcje:
Od najmniejszych do największych — określa sposób sortowania liczb. Aby odwrócić kolejność, wybierz opcję Od największych do najmniejszych.
Według całych wartości — dane można grupować według całych wartości, według piątek, dziesiątek, setek i tysięcy lub według niestandardowych przedziałów.
Rozdział 20. Prezentowanie danych za pomocą raportów
603
Sortowanie danych w obrębie grup Sortowanie umożliwia określenie kolejności przeglądania rekordów w raporcie na podstawie wartości jednego lub kilku formantów. Kolejność ma znaczenie podczas przeglądania danych w tabelach w kolejności innej niż ta, w jakiej wprowadzano dane. Na przykład do tabeli tblProducts dodano nowe produkty, ponieważ były potrzebne do faktury. Fizyczny porządek rekordów w bazie danych odzwierciedla datę i godzinę dodania produktu. W przypadku listy produktów spodziewamy się jej raczej w porządku alfabetycznym, według identyfikatora produktu oraz posortowanej według opisu produktu bądź jego kosztów. Wykonanie sortowania w samym raporcie sprawia, że nie trzeba się przejmować kolejnością danych. Chociaż dane można posortować w tabeli według klucza głównego oraz w kwerendzie według dowolnego pola, są powody, dla których warto posortować je wewnątrz raportu. W ten sposób jeśli zmodyfikujesz kwerendę lub tabelę, raport w dalszym ciągu będzie wyświetlał się we właściwym porządku. W przypadku raportu dotyczącego produktów chcielibyśmy, aby rekordy w ramach grupy każdej kategorii były posortowane według opisu. Aby zdefiniować porządek sortowania na podstawie pola Description w ramach grup kategorii, wykonaj poniższe czynności: 1. Kliknij przycisk Grupuj i sortuj w zakładce PROJEKTOWANIE. Wyświetli się obszar Grupowanie, sortowanie i sumowanie, jeśli nie otwarto go wcześniej. Jak można zauważyć, w raporcie wcześniej włączono grupowanie według kategorii. 2. Kliknij przycisk Dodaj sortowanie w obszarze Grupowanie, sortowanie i sumowanie. 3. Wybierz pole Description na liście pól. Zwróć uwagę, że domyślnie w raporcie wykorzystuje się rosnący porządek sortowania („z literą A na górze”). 4. Zamknij obszar Grupowanie, sortowanie i sumowanie poprzez kliknięcie znaku X w prawym górnym rogu okna. Obszar Grupowanie, sortowanie i sumowanie powinien mieć teraz zawartość podobną do tej, którą pokazano na rysunku 20.34.
Rysunek 20.34. Obszar Grupowanie, sortowanie i sumowanie w ostatecznej postaci
Chociaż w tym przykładzie do sortowania użyto pola, równie dobrze można sortować (i grupować) dane z wykorzystaniem wyrażeń. Aby wprowadzić wyrażenie, należy kliknąć przycisk Dodaj sortowanie lub Dodaj grupę w obszarze Grupowanie, sortowanie i sumowanie, a następnie kliknąć przycisk Wyrażenie w dolnej części listy pól. Otworzy się okno dialogowe Konstruktor wyrażeń, w którym można wprowadzić dowolne wyrażenie Accessa, np. =[RetailPrice]-[Cost]. Aby zmienić porządek sortowania dla pól w kolumnie Pole/wyrażenie, należy kliknąć strzałkę skierowaną w dół po prawej stronie przycisku z literą A na górze. Wyświetli się lista dostępnych opcji sortowania, z której należy wybrać pozycję z literą Z na górze.
604
Część V Formularze i raporty Accessa
Usuwanie grupy Aby usunąć grupę, należy wyświetlić obszar Grupowanie, sortowanie i sumowanie, zaznaczyć grupę, a następnie wcisnąć klawisz Delete. Wszystkie formanty w nagłówku lub stopce grupy zostaną usunięte. Ukrywanie sekcji Access pozwala również ukryć nagłówki i stopki, aby umożliwić podział danych na grupy bez wyświetlania informacji o grupie. Można też ukryć sekcję szczegółów, by utworzyć raport sumaryczny. Aby ukryć sekcję, wykonaj poniższe czynności: 1. Kliknij sekcję, którą chcesz ukryć. 2. Wyświetl arkusz właściwości sekcji. 3. Kliknij pole tekstowe przy właściwości Widoczny, a następnie wybierz Nie z rozwijanej listy pola tekstowego właściwości. Sekcje nie są jedynymi obiektami raportu, które można ukrywać; właściwość Widoczny mają także formanty. Właściwość ta przydaje się do tworzenia wyrażeń używanych przez inne wyrażenia.
Zmiana rozmiaru sekcji Po utworzeniu nagłówka grupy można umieścić w nim formanty albo poprzesuwać formanty w obrębie sekcji, a nawet między sekcjami. Przed przystąpieniem do manipulowania formantami należy się upewnić, że sekcja ma właściwą wysokość. Aby zmodyfikować wysokość sekcji, należy przeciągnąć krawędź sekcji znajdującej się pod nią. Jeśli na przykład w raporcie jest nagłówek strony, sekcja szczegółów i stopka strony, można zmienić wysokość sekcji szczegółów, przeciągając górną krawędź sekcji stopki strony. Przeciągając obramowanie sekcji, można zwiększyć lub zmniejszyć sekcję. Poniższy przykład pokazuje, jak ustawić wysokość sekcji nagłówka grupy na 1 cm: 1. Przesuń wskaźnik myszy na dół sekcji Category. Wskaźnik zmieni się w poziomą linię z dwiema strzałkami. 2. Kliknij górną krawędź sekcji szczegółów (która jest zarazem dolną krawędzią sekcji Category). 3. Przeciągnij krawędź sekcji w dół, aż czarny pasek na pionowej linijce będzie miał wysokość 1 cm, a następnie zwolnij przycisk myszy. Szara pozioma linia wskazuje, gdzie znajdzie się dolna krawędź sekcji, kiedy zwolnisz przycisk myszy. Przenoszenie formantów między sekcjami Teraz przesuń formant Category z sekcji szczegółów do sekcji nagłówka grupy Category. Można przesuwać formanty między sekcjami, przeciągając je z jednej sekcji do drugiej albo wycinając je z jednej sekcji i wklejając w drugiej. 1. Zaznacz formant Category w sekcji szczegółów i przeciągnij go w górę do sekcji nagłówka, jak pokazano na rysunku 20.35. Następnie wykonaj dalsze czynności, aby dokończyć projekt raportu.
Rozdział 20. Prezentowanie danych za pomocą raportów
605
Rysunek 20.35. Uzupełnianie sekcji nagłówka grupy i wymuszanie nowej strony przed rozpoczęciem sekcji nagłówka Kategoria
2. Usuń etykietę Category z nagłówka strony. 3. Ustaw właściwość Styl obramowania formantu Category i wszystkich innych formantów z nagłówka strony na Przezroczysty. 4. Zmień wielkość czcionki, dodaj pogrubienie i określ kolor formantu Category, aby wizualnie odróżnić go od rekordów znajdujących się poniżej. Na rysunku 20.35 pokazano, jak formanty powinny być rozmieszczone w gotowym projekcie raportu. Access automatycznie określa nazwy sekcji nagłówka i stopki grupy. Aby zmienić nadaną nazwę, wybierz nagłówek grupy w arkuszu właściwości i zmień wartość właściwości Nazwa na odpowiednią. Możesz na przykład zmienić nazwę NagłówekGrupy0 na Nagłówek kategorii, aby można było łatwiej zidentyfikować sekcję.
Wprowadzanie podziału na strony Access pozwala dzielić raporty na strony w miejscach, w których kończą się i zaczynają grupy. Można też wymusić podział w obrębie sekcji (z wyjątkiem sekcji nagłówka i stopki strony). W niektórych raportach każda grupa powinna zaczynać się od nowej strony. Można uzyskać ten efekt za pomocą właściwości Wymuszaj nową stronę sekcji grupy. Właściwość ta pozwala wymusić podział strony za każdym razem, kiedy zmienia się grupa. Oto cztery dostępne ustawienia właściwości Wymuszaj nową stronę:
606
Część V Formularze i raporty Accessa
Nie — bez wymuszonego podziału strony (ustawienie domyślne).
Przed sekcją — kiedy pojawia się nowa grupa, bieżąca sekcja jest drukowana od góry nowej strony.
Po sekcji — kiedy pojawia się nowa grupa, następna sekcja jest drukowana od góry nowej strony.
Przed i po — łączy efekt ustawień Przed sekcją i Po sekcji.
Aby wymusić podział strony przed grupą Category, wykonaj następujące czynności: 1. Kliknij dowolne miejsce w nagłówku grupy Category lub kliknij pasek Category – nagłówek nad sekcją. 2. Wyświetl okno arkusza właściwości, a następnie wybierz pozycję Przed sekcją na liście rozwijanej Wymuszaj nową stronę. Inna możliwość to ustawienie właściwości Wymuszaj nową stronę na wartość Po sekcji w sekcji stopki grupy Category.
Czasem programista nie zamierza dzielić stron według grup, ale mimo to chce wymusić nową stronę, na przykład po to, aby utworzyć kilka stron tytułowych. W tym celu można użyć narzędzia Podział strony z grupy Formanty na wstążce. Wystarczy przeciągnąć formant i upuścić go na raporcie, w miejscu, gdzie ma znaleźć się podział strony przy każdym jej wydrukowaniu. Należy uważać, aby nie podzielić danych w formancie. Podziały należy umieszczać nad albo pod formantami; nie należy nakładać ich na formanty.
Dopracowywanie wyglądu raportu Testowanie projektu raportu powinno obejmować również sprawdzenie, jak prezentuje się on na wydruku. Na rysunku 20.36 pokazano podgląd wydruku raportu Lista produktów. Aby dokończyć raport, zostało do zrobienia jeszcze kilka rzeczy. W bieżącej postaci nasz raport jest nudny i prozaiczny. Jeśli celem jest po prostu obejrzenie danych, raport można uznać za gotowy. Jeśli jednak komuś zależy na czymś więcej, będzie musiał wykonać kilka dodatkowych czynności. Choć raport zawiera poprawne i dobrze zorganizowane dane, nie cechuje się profesjonalizmem. Aby zwiększyć atrakcyjność raportu, zwykle dodaje się do niego linie i prostokąty, ewentualnie efekty specjalne, takie jak cienie i obszary wklęsłe. Sekcje powinny być odgraniczone liniami lub kolorem. Warto sprawdzić, czy formanty się nie stykają (bo może to prowadzić do zlewania się tekstu). Należy też się upewnić, że tekst jest wyrównane względem tekstu na górze lub na dole i do lewej lub do prawej strony. Raport z rysunku 20.36 można dopracować pod co najmniej kilkoma względami.
Rozdział 20. Prezentowanie danych za pomocą raportów
607
Rysunek 20.36. W tej postaci raport jest dość prosty i niezbyt interesujący
Modyfikowanie nagłówka strony W nagłówku strony znajduje się kilka dużych etykiet odsuniętych zbyt daleko od siebie. Nagłówki kolumn są za małe, przez co wydają się zawieszone w próżni. Warto zwiększyć rozmiar ich czcionki o jeden punkt. Nagłówek strony należałoby oddzielić od sekcji szczegółów za pomocą poziomej linii. Aby dodać do raportu nieco koloru, można zmienić barwę tytułu. Nie należy jednak używać zbyt wielu kolorów, chyba że ktoś ma na myśli określony motyw graficzny. W większości poważnych raportów biznesowych używa się jednego lub dwóch kolorów, rzadko więcej niż trzech (z wyjątkiem diagramów i wykresów). Co więcej, kolory nie na wiele się przydadzą w przypadku drukowania raportów na większości drukarek laserowych. Kolorowe drukarki laserowe w dalszym ciągu nie są powszechne, zatem zbyt dużo kolorów w raportach Accessa może być niezbyt pożądaną własnością. Wprowadzone zmiany pokazano na rysunku 20.37. Dla etykiety Lista produktów zmieniono kolory i uzyskano wyświetlanie białego tekstu na niebieskim tle. W tym celu najpierw zaznaczono formant, a następnie wybrano niebieski kolor tła. Etykiety dosunięto do siebie i wyrównano do lewej strony. Dobrano również właściwy rozmiar prostokątnych ramek wokół każdego z formantów. Efekt ten osiągnięto poprzez dwukrotne kliknięcie uchwytów zmiany rozmiaru każdego z formantów.
608
Część V Formularze i raporty Accessa
Rysunek 20.37. Dostosowywanie formantów w nagłówku strony
Następnym etapem będzie dodanie grubej linii oddzielającej sekcję nagłówka strony od sekcji nagłówka grupy Category. 1. Zaznacz narzędzie Linia w grupie Formanty na wstążce. 2. Przeciągnij linię między etykietami Opis i Sztuk w magazynie, co pokazano na rysunku 9.37. 3. Zaznacz linię i wybierz grubość 2 pkt za pomocą ikony szerokości linii na pasku narzędzi.
Tworzenie wyrażenia w nagłówku grupy Na rysunku 20.37 widać też, że pole Category zastąpiono wyrażeniem. Jeśli w sekcji nagłówka grupy umieścisz samą nazwę kategorii, będzie wydawała się nie na miejscu i trudno będzie ją zinterpretować. Większość danych powinna mieć identyfikujące je etykiety. Wyrażenie ="Kategoria: " & [Category] wyświetli tekst Kategoria:, spację i wartość pola Category (np. Kategoria: Osobowe). Symbol łączenia (&) łączy łańcuch z polem danych. Należy pamiętać, aby wstawić spację za dwukropkiem, bo w przeciwnym razie wartość nie będzie oddzielona od etykiety. Tekst formantu został pogrubiony i podkreślony, zwiększono też jego rozmiar. Jak można zauważyć, po zmianie właściwości Źródło formantu Access zgłasza odwołanie cykliczne do pola tekstowego Category. Przyczyną tej sytuacji jest fakt, iż formant ma nazwę Category, a pole tekstowe jest powiązane z polem o nazwie Category. Access nie potrafi rozpoznać, że odwołanie [Category] w wyrażeniu wprowadzonym
Rozdział 20. Prezentowanie danych za pomocą raportów
609
jako Źródło formantu odnosi się do pola tabeli, a nie do pola tekstowego (wartość pola tekstowego nie może bazować na jego zawartości — stąd odwołanie cykliczne). Rozwiązaniem tego problemu może być zmiana nazwy pola tekstowego na txtKategoria, aby odróżnić je od powiązanego z nim pola. W czasie tworzenia formantu związanego domyślnie otrzymuje on taką samą nazwę jak pole tabeli. Wykorzystanie formantu w wyrażeniu bez zmiany nazwy formantu powoduje odwołanie cykliczne. Formantowi trzeba nadać inną nazwę niż nazwa pierwotnego pola tabeli. Jest to kolejny powód, dla którego warto stosować prostą konwencję nazewnictwa, np. poprzedzanie nazw pól tekstowych prefiksem txt. Zastosowanie takiej konwencji nazewnictwa dla formantów w raportach Accessa pozwoli uniknąć wielu trudnych do rozwiązania problemów.
Aby wprowadzić wyrażenie i zmienić nazwę formantu, wykonaj poniższe czynności: 1. Zaznacz formant Category w sekcji nagłówka grupy Category, aby wyświetlić okno właściwości formantu. 2. Zmień właściwość Źródło formantu na ="Kategoria: " & [Category]. 3. Zmień właściwość Nazwa na txtCategory. Ostatni krok w trakcie formatowania nagłówka kategorii polega na ustawieniu właściwości Styl obramowania formantu txtCategory na Przezroczysty. Dzięki zmianie czcionki formant wizualnie odróżnia się od innych elementów, dlatego obramowanie jest zbędne.
Tworzenie nagłówka raportu Formanty umieszczone w sekcji nagłówka raportu są drukowane tylko raz, na początku raportu. Sekcja nagłówka raportu to logiczne miejsce do umieszczenia takich elementów jak tytuł i logo raportu oraz data i godzina sporządzenia wydruku. Umieszczenie tych informacji w nagłówku raportu sprawi, że będzie można łatwo stwierdzić, co znajduje się w raporcie i kiedy został on wydrukowany. Kiedy raport jest otwarty w widoku projektu, wstążka zawiera zakładkę PROJEKTOWANIE. W grupie Nagłówek/stopka zakładki PROJEKTOWANIE znajduje się wiele formantów, które pozwalają dodać sporo istotnych informacji do nagłówka i stopki raportu. Na przykład kliknięcie przycisku Logo spowoduje otwarcie okna dialogowego Wstawianie obrazu (zobacz rysunek 20.38). Można za jego pomocą odszukać plik graficzny, który będzie użyty jako logo raportu. Do tego celu można wykorzystać niemal wszystkie typy plików graficznych (.jpg, .gif, .bmp itp.). Kliknięcie przycisku Tytuł w grupie Nagłówek/stopka powoduje dodanie nazwy raportu jako tytułu nagłówka raportu. Jednocześnie kursor edycji zostaje umieszczony w obrębie etykiety tytułu. Dzięki temu z łatwością można dostosować tytuł raportu. Wreszcie przycisk Data i godzina powoduje otwarcie okna dialogowego Data i godzina (zobacz rysunek 20.39). W tym oknie dialogowym można określić format daty i godziny do wykorzystania wewnątrz formantu daty (aby utworzyć taki formant, wybierz opcję Data i godzina z grupy Nagłówek/stopka z zakładki PROJEKTOWANIE na wstążce).
610
Część V Formularze i raporty Accessa
Rysunek 20.38. Wybieranie pliku graficznego do wykorzystania jako logo raportu Rysunek 20.39. Określanie formatu daty i godziny
Gotowy raport wyświetlony w widoku podglądu wydruku pokazano na rysunku 20.40. Stworzenie nagłówka raportu pokazanego na tym rysunku zajęło mniej niż minutę. Do tego celu użyto wyłącznie narzędzi wbudowanych w Accessie 2013. W chwili zamykania raportu Access wyświetli pytanie o nazwę.
Rozdział 20. Prezentowanie danych za pomocą raportów Rysunek 20.40. Ukończony raport w widoku podglądu wydruku
611
612
Część V Formularze i raporty Accessa
Rozdział 21.
Raporty w Accessie — techniki zaawansowane W tym rozdziale:
Budowanie raportów pod kątem logicznej prezentacji danych
Tworzenie atrakcyjnych raportów
Udostępnianie dodatkowych informacji na temat raportu
Inne techniki wzbogacania wyglądu raportów
W dawnych, niedobrych czasach większość generowanych komputerowo raportów drukowano na marnym perforowanym papierze, w sztywnym układzie kolumn i wierszy (zwanym tabelarycznym). Od użytkownika oczekiwano, że dodatkowo przetworzy dane zgodnie ze swoimi potrzebami — często był to pracochłonny proces, obejmujący ręczne dodawanie danych lub rysowanie wykresów. Czasy się zmieniły. Dziś zorientowani wizualnie pracownicy biznesu wymagają wygodnych, czytelnych raportów, generowanych bezpośrednio ze swoich baz danych. Nikt nie chce marnować czasu na rysowanie wykresów na podstawie danych wydrukowanych w prostym, tabelarycznym formacie. Użytkownicy chcą, by większość pracy wykonywało za nich oprogramowanie. Oznacza to, że narzędzia do raportowania, takie jak Microsoft Access, muszą być zdolne do generowania bardzo czytelnych, wysokiej jakości raportów, jakich oczekują użytkownicy. Access jest aplikacją systemu Windows, więc daje do dyspozycji wszystkie wyrafinowane możliwości tego systemu: czcionki TrueType, grafikę i interfejs graficzny do projektowania i podglądu raportów. Poza tym raporty w Accessie wyposażone są we właściwości i model zdarzeń (aczkolwiek dostępnych jest tu mniej zdarzeń niż w formularzach) do modyfikacji zachowania raportów zgodnie z oczekiwaniami użytkownika. Raporty tworzone w Accessie można ulepszać i automatyzować za pomocą języka Visual Basic.
614
Część V Formularze i raporty Accessa
W niniejszym rozdziale przedstawiono kilka ogólnych zasad i technik projektowych, o których warto pamiętać podczas tworzenia raportów w Accessie. Zasady te pozwolą poprawić czytelność i użyteczność raportów. W rozdziale tym nie opisaliśmy podstaw tworzenia raportów w Accessie (informacje na ten temat znajdziesz w rozdziale 20.). Zamiast tego omówiliśmy tu liczne techniki projektowe, które można zastosować w raportach Accessa z wykorzystaniem umiejętności opisanych w rozdziale 20. Wszystkie przykłady przedstawione w niniejszym rozdziale są dostępne w przykładowej bazie danych o nazwie Rozdział21.accdb, znajdującej się w plikach dołączonych do niniejszej książki. Warto zwrócić uwagę na to, że na wielu rysunkach w niniejszym rozdziale siatka w widoku projektu została wyłączona, aby poprawić czytelność szczegółów projektu raportu. W rozdziale tym wykorzystano dane z przykładowej bazy danych firmy Northwind Traders. Doskonale nadają się one do tworzenia opisanych tu przykładowych raportów i są dobrym wzorcem do tworzenia większości baz danych w Accessie. Omówione dalej techniki można bez większych trudności dostosować do każdej dobrze zaprojektowanej bazy danych.
Grupowanie i sortowanie danych Aby dane w raporcie były maksymalnie użyteczne, należy je dobrze uporządkować. Pogrupowanie podobnych danych pozwala zmniejszyć ilość prezentowanych informacji, co ułatwia znajdowanie konkretnych danych. Podczas lektury tego podrozdziału przekonasz się, że konstruktor raportów Accessa zapewnia w tym zakresie duże możliwości. Wprowadzenie do grupowania i sortowania znajdziesz w rozdziale 20. Tu rozwinęliśmy informacje z owego rozdziału i zaprezentowaliśmy dodatkowe przykłady.
Alfabetyczne grupowanie danych Dane są często wyświetlane w sposób zbyt szczegółowy, aby były przydatne. Raport zawierający wszystkie operacje sprzedaży, dokonane przez wszystkich pracowników, sformatowany tabelarycznie, może być mało czytelny. Okno dialogowe Grupowanie, sortowanie i sumowanie (dostępne po kliknięciu przycisku Grupuj i sortuj w sekcji Grupowanie i sumy z zakładki PROJEKTOWANIE) pozwala kontrolować, jak dane będą grupowane w raportach Accessa. Sortowanie alfabetycznie po prostu porządkuje rekordy w kolejności alfabetycznej na podstawie pierwszego znaku nazwy firmy, podczas gdy grupowanie według nazwy przedsiębiorstwa utworzy osobną grupę dla każdej firmy. Jeśli klikniesz przycisk Dodaj grupę, w okienku Grupowanie, sortowanie i sumowanie pojawi się lista, z której można wybrać pole używane do grupowania danych w raporcie. Na rysunku 21.1 wybrano pola CompanyName i OrderDate. Dane są grupowane na podstawie pola CompanyName, a następnie sortowane w ramach poszczególnych firm według pola OrderDate.
Rozdział 21. Raporty w Accessie — techniki zaawansowane
615
Rysunek 21.1. Grupowanie alfabetycznie jest proste!
Dane zwykle są grupowane według całej zawartości pola lub kombinacji pól. Proste grupowanie według pola CompanyName oznacza, że wszystkie rekordy związane z firmą Bottom Dollar Markets pojawią się razem jako grupa, a wszystkie rekordy firmy Ernst Handel — jako inna grupa. Możemy jednakże zastąpić zachowanie domyślne i grupować na podstawie pierwszych znaków przez zmianę właściwości Grupuj według w oknie dialogowym Grupowanie, sortowanie i sumowanie. Zwróć uwagę na przycisk Więcej na pasku sortowania dla pola CompanyName na rysunku 21.1. Jeśli klikniesz ten przycisk, zobaczysz szczegółowe informacje o sortowaniu według tego pola (zobacz rysunek 21.2). Pola tekstowe (takie jak CompanyName) domyślnie są sortowane alfabetycznie na podstawie całej zawartości pola. Można to jednak zmienić, aby zmodyfikować sposób, w jaki Access grupuje dane z określonego pola (zobacz rysunek 21.3).
Rysunek 21.2. Dostępnych jest wiele opcji związanych z grupowaniem i sortowaniem
Rysunek 21.3. Modyfikowanie grupowania na podstawie tekstu
Jeśli wybierzesz grupowanie według pierwszego znaku, właściwość Wartość niestandardowa pozwoli Accessowi ustalić, ile znaków ma uwzględniać. Tu wartość jest ustawiona na 1, co oznacza, że przy grupowaniu należy uwzględniać tylko pierwszy znak. W zależności od potrzeb można grupować według pierwszego znaku, dwóch pierwszych znaków lub dowolnej liczby znaków z pola. Warto zauważyć, że pole CompanyName jest sortowane w kolejności rosnącej (A znajduje się na początku), przez co powstają grupy z nazwami zaczynającymi się na A aż do nazw rozpoczynających się na Z. Przy tym połączeniu właściwości wszystkie firmy, których nazwy zaczynają się na A, będą zgrupowane razem, firmy o nazwie zaczynającej się od B znajdą się w następnej grupie i tak dalej.
616
Część V Formularze i raporty Accessa
Dla tego przykładu nieco odmienny raport posłużył do zilustrowania grupowania według pierwszych znaków. Raport ten (rptSalesJanuaryAlpha1, przedstawiony na rysunku 21.4) zawiera dane zakupów ze stycznia zgrupowane według nazwy klienta. W raporcie wyświetlane są data i identyfikator zamówienia oraz nazwisko pracownika, który wypełnił zamówienie. Wynik sortowania i grupowania z rysunku 21.1 został przedstawiony na rysunku 21.4.
Rysunek 21.4. Zmiana układu danych z rysunku 20.13 (przedstawionego w dalszej części rozdziału)
Warto zwrócić uwagę, że dane przedstawione na rysunku 21.4 są identyczne jak na rysunku 21.13. W istocie do wygenerowania obu raportów zostało użyte to samo źródło rekordów (qrySalesJanuary z rysunku 21.11 przedstawionego w dalszej części rozdziału). Często zmiana układu danych może dać nam przydatne informacje. Na przykład z łatwością można zauważyć, że firma Bottom Dollars Market złożyła w styczniu trzy zamówienia u przedstawicieli o nazwiskach Steven Buchanan, Robert King i Nancy Davolio. Załóżmy, że chcesz ulepszyć raport rptSalesJanuaryAlpha1, dodając do grup jako etykiety litery alfabetu. Wszyscy klienci o nazwach zaczynających się na A (Antonio Moreno Tagueria i Around the Horn) znajdą się w jednej grupie, klienci o nazwach zaczynających się na B (Blondel père et fils, Bon App’ i Bottom-Dollars Market) w kolejnej i tak dalej. W każdej grupie nazwy firm będą posortowane alfabetycznie. Wyniki sprzedaży dla każdego klienta będą dalej posortowane według daty zamówienia.
Rozdział 21. Raporty w Accessie — techniki zaawansowane
617
Aby podkreślić grupowanie według alfabetu, do raportu zostały dodane pola tekstowe z pierwszą literą dla każdej grupy (rptSalesJanuaryAlpha2 na rysunku 21.5). Wprawdzie zbiór danych w tym przykładzie jest raczej niewielki, lecz w dużych raportach takie nagłówki mogą być przydatne. Rysunek 21.5. Alfabetyczne nagłówki grup klientów poprawiają czytelność raportu rptSalesJanuaryAlpha2
Proces dodawania pola tekstowego zawierającego literę jest prosty: 1. Kliknij pasek tytułu raportu prawym przyciskiem myszy i wybierz opcję Widok projektu. 2. Wybierz opcję Grupuj i sortuj z zakładki PROJEKTOWANIE na wstążce. Pojawi się okno dialogowe Grupowanie, sortowanie i sumowanie. 3. Dodaj grupę dla pola CompanyName. 4. Kliknij przycisk Więcej i upewnij się, że zaznaczona jest opcja Z sekcją nagłówka. W ten sposób zostanie dodany pasek grupy na podstawie informacji z pola CompanyName (zobacz rysunek 21.6). 5. Wybierz opcję Według pierwszego znaku zamiast Według całych wartości. 6. Otwórz nagłówek grupy CompanyName i dodaj do niego niezwiązane pole tekstowe. 7. We właściwości Źródło formantu pola tekstowego wpisz wyrażenie: =left$([CompanyName],1)
8. Ustaw odpowiednie wartości innych właściwości pola tekstowego (Nazwa czcionki, Rozmiar czcionki itd.).
618
Część V Formularze i raporty Accessa
Rysunek 21.6. Raport rptSalesJanuaryAlpha2 w widoku projektu
9. Jeśli grupujesz dane według pierwszego znaku nazwy firmy, zadbaj o to, aby nazwy firm były prawidłowo sortowane. Kliknij przycisk Dodaj sortowanie i ponownie wybierz pole CompanyName. Kliknij przycisk Więcej, aby się upewnić, że sortowanie będzie się odbywało na podstawie całych wartości i że sekcja nagłówka nie zostanie dodana. 10. W ostatnim kroku dodaj sortowanie według pola OrderDate, aby uporządkować zamówienia złożone przez poszczególne firmy. Teraz raport w widoku projektu powinien wyglądać jak na rysunku 21.6. Warto zauważyć, że nagłówek grupy CompanyName został dodany przez skonfigurowanie ustawienia Z sekcją nagłówka w oknie dialogowym Grupowanie, sortowanie i sumowanie. Arkusz właściwości niezwiązanego pola tekstowego został pokazany, aby zilustrować wyrażenie, które zostało wprowadzone do pola tekstowego. Ta sztuczka może zadziałać dlatego, że wszystkie wiersze w grupie CompanyName mają taki sam pierwszy znak. Pobierając pierwszy znak za pomocą funkcji Left$() i używając go jako tekst w polu tekstowym, udało się otrzymać atrakcyjne, przydatne nagłówki grup opartych na polu CompanyName.
Rozdział 21. Raporty w Accessie — techniki zaawansowane
619
Grupowanie według przedziałów czasowych Wiele raportów wymaga grupowania danych według przedziałów czasowych (dnia, tygodnia lub miesiąca). Na przykład firma Northwind Traders może potrzebować raportu sprzedaży ze stycznia, zgrupowanego według tygodni, aby zaobserwować wzorce zmian z tygodnia na tydzień. Na szczęście mechanizm raportowania w Accessie zawiera potrzebną do tego funkcję. Opcja w oknie dialogowym Grupowanie, sortowanie i sumowanie pozwala szybko i prosto grupować dane raportu na podstawie dat lub przedziałów czasowych. Podobnie jak w poprzednim przykładzie pogrupowano dane na podstawie pierwszych znaków nazwy, można grupować informacje według dat, posługując się właściwością Grupuj według grupy. Rysunek 21.7 przedstawia raport sprzedaży ze stycznia pogrupowany według tygodni miesiąca. Raport ten nosi nazwę rptSalesJanuaryByWeek.
Rysunek 21.7. Dane sprzedaży ze stycznia, zgrupowane według tygodni
Taki raport można zbudować z łatwością. Otwórz ponownie okno dialogowe Grupowanie, sortowanie i sumowanie i utwórz grupę dla pola OrderDate. Ustaw opcję Z nagłówkiem grupy i rozwiń listę (zobacz rysunek 21.8). Jak widać, Access jest na tyle inteligentny, że oferuje opcje grupowania (według lat, kwartałów, miesięcy, tygodni itd.) mające sens dla pól związanych z datą i czasem, takich jak OrderDate. Po wybraniu z tej listy opcji Według tygodni Access posortuje dane z pola OrderDate według tygodni. Warto zauważyć, że dane należy dodatkowo posortować według całej wartości pola OrderDate, aby informacje były uporządkowane w ramach poszczególnych tygodni.
620
Część V Formularze i raporty Accessa
Rysunek 21.8. OrderDate jest polem typu Data/godzina, więc dostępne opcje grupowania są związane z danymi daty i godziny
Etykieta na górze grupy, identyfikująca tydzień (pierwszy jest opisany „Tydzień rozpoczynający się 01-sty-12:”) stanowi wynik następującego wyrażenia w niezwiązanym polu tekstowym w nagłówku grupy OrderDate: ="Tydzień od " & [OrderDate] & ":"
Rysunek 21.9 przedstawia raport rptSalesJanuaryByWeek w widoku projektu. Widać tu niezwiązane pole tekstowe w nagłówku grupy OrderDate. Pole to zawiera wartość daty zamówienia, za pomocą której Access zgrupował dane z określonej grupy OrderDate.
Rysunek 21.9. Raport rptSalesJanuaryByWeek w widoku projektu. Warto zwrócić uwagę na wyrażenie w nagłówku grupy OrderDate
Ukrywanie powtarzających się informacji Raporty tabelaryczne można łatwo ulepszyć, zmniejszając w nich ilość powtarzających się informacji. Rysunek 21.10 przedstawia typowy raport tabelaryczny wygenerowany przez Access (rptTabularBad), oparty na prostej kwerendzie pobierającej dane z bazy Northwind Traders. Raport z rysunku 21.10 został wygenerowany za pomocą kreatora raportów; wybrano format tabelaryczny i wszystkie ustawienia domyślne. Kwerenda, na której opiera się ten raport (zobacz rysunek 21.11), pobiera dane z tabel Customers, Orders i Employees z bazy danych Rozdział21.accdb. Jak widać, dane zwracane przez tę kwerendę zostały ograniczone do stycznia 2012 roku. Poza tym imię i nazwisko każdego pracownika zostały sklejone jako pole Name.
Rozdział 21. Raporty w Accessie — techniki zaawansowane
621
Rysunek 21.10. Prosty raport tabelaryczny może być nieprzejrzysty i nudny
Rysunek 21.11. Prosta kwerenda dla raportu rptTabularBad
Kwerendę z rysunku 21.11 (qrySalesJanuary) wykorzystano w kilku przykładach z tego rozdziału. Można znacznie ulepszyć raport z rysunku 21.10, ukrywając informacje powtarzające się w sekcji Szczegóły. Gdy już raz pojawi się nazwisko Andrew Fuller, nie ma potrzeby powtarzać go dla każdej sprzedaży, którą Andrew przeprowadził w styczniu 2012 roku. Z uwagi na sposób rozmieszczenia danych w raporcie rptTabularBad trzeba szukać, gdzie kończą się dane sprzedaży jednego pracownika, a zaczynają dane następnego.
622
Część V Formularze i raporty Accessa
Ukrycie powtarzających się wartości jest proste: 1. Otwórz raport w widoku projektu. 2. W sekcji Szczegóły zaznacz pole txtEmployeeName, zawierające imię i nazwisko pracownika. 3. Otwórz arkusz właściwości pola txtEmployeeName (zobacz rysunek 21.12). Rysunek 21.12. Domyślne wartości właściwości czasem dają niezadowalające wyniki
4. Zmień wartość właściwości Ukryj duplikaty na Tak. Wartość domyślna (Nie) powoduje, że Access wyświetla wszystkie wystąpienia każdego pola. 5. Przełącz raport z powrotem w tryb podglądu wydruku i ciesz się nowym układem raportu (zobacz rysunek 21.13). Raport z rysunku 21.13 nosi nazwę rptTabularGood. Rysunek 21.13. O wiele lepiej! Ukryto powtarzające się informacje
Rozdział 21. Raporty w Accessie — techniki zaawansowane
623
Na rysunku 21.13 rozróżnienie wyników sprzedaży poszczególnych pracowników jest o wiele prostsze niż wtedy, gdy raport zawierał powtarzające się informacje. Warto zwrócić uwagę, że nie było tu potrzebne żadne wyrafinowane programowanie ani projektowanie raportu. Prosta zmiana wartości właściwości dała nam o wiele czytelniejszy i bardziej użyteczny raport. Twórcy raportów w systemach mainframe współpracujący z autorami tradycyjnych raportów daliby się pokroić za raport wyglądający równie dobrze jak ten z rysunku 21.13! Właściwość Ukryj duplikaty stosuje się tylko do rekordów, które występują w raporcie sekwencyjnie. Nazwisko, które Access umieści w raporcie, nie będzie powtarzać się w rekordach następujących bezpośrednio po bieżącym. Na rysunku 21.13 rekordy są posortowane według pola EmployeeName, więc wszystkie rekordy dla jednego pracownika pojawiają się jako grupa jeden za drugim. Gdyby raport był sortowany według innego pola (np. OrderID lub OrderDate), właściwość Ukryj duplikaty ustawiona dla pola Name byłaby wykorzystywana tylko wówczas, gdyby nazwisko tego samego pracownika pojawiło się przypadkowo w dwóch lub więcej rekordach pod rząd. Właściwość Ukryj duplikaty można zastosować do wielu formantów w raporcie. Jeśli zapamiętasz, że właściwość ta ukrywa tylko kolejne powtarzające się wartości w sekcji szczegółów, powinieneś móc uzyskać pożądane efekty. Warto jednak zauważyć, że zmiana wartości w tylko jednym z powtarzających się pól może prowadzić do nieoczekiwanych skutków.
Ukrycie nagłówka strony Czasem zachodzi potrzeba wyświetlenia nagłówka lub stopki strony jedynie na pierwszej stronie raportu. Przykładem może być klauzula warunków sprzedaży na pierwszej stronie faktury. Informacje te powinny pojawiać się na pierwszej stronie faktury, lecz nie na następnych. W niektórych przykładach z tego rozdziału wykorzystano kod VBA. Omówienie języka VBA znajdziesz w rozdziałach od 23. do 28.
W tym celu należy dodać do raportu formant niezwiązanego pola tekstowego z wyrażeniem =HideHeader() we właściwości Źródło formantu. Usuń też etykietę pola tekstowego. Funkcja HideHeader() zwraca pusty ciąg znaków, co sprawia, że pole tekstowe staje się niewidoczne. Nie można we właściwości Widoczny tego formantu ustawić wartości Nie; tak skonfigurowany formant nie mógłby reagować na zdarzenia.
Funkcja HideHeader() wygląda następująco: Function HideHeader() As String ' Ustawianie właściwości Visible nagłówka Me.Section("PageHeader0").Visible = False HideHeader = vbNullString End Function
624
Część V Formularze i raporty Accessa
Niewidoczne pole tekstowe można umieścić w dowolnym miejscu pierwszej strony, lecz najbardziej logicznym miejscem na nie jest stopka strony. Zakładamy, że ponieważ nagłówek jest pierwszym drukowanym elementem strony, nagłówek pierwszej strony zawsze będzie generowany. Gdy tylko stopka tej strony, zawierająca niewidoczne pole tekstowe, zostanie przetworzona, właściwość Visible nagłówka strony otrzyma wartość False i nagłówek nie będzie już widoczny na kolejnych stronach raportu.
Nowa numeracja strony dla każdej grupy Czasami raport zawiera szereg stron dla każdej grupy danych. Można podczas drukowania rozpoczynać numerowanie stron od 1 dla każdej grupy, tak aby poszczególne grupy miały własną numerację stron. Załóżmy, że chcesz przygotować raport z danymi o sprzedaży pogrupowanymi według regionów. Dane z każdego regionu mogą zająć wiele stron wydruku, a za pomocą właściwości ForceNewPage (Wymuszaj nową stronę) można zagwarantować, że na żadnej stronie nie znajdą się dane z dwóch grup. Ale jak rozpocząć numerowanie stron w każdej grupie od 1? Właściwość Page raportu, która służy do drukowania numeru strony na każdej stronie raportu, można konfigurować. Oznacza to, że można wyzerować jej wartość w dowolnym miejscu drukowanego raportu. Za pomocą zdarzenia Format nagłówka grupy należy ustawić we właściwości Page wartość 1. Za każdym razem, gdy grupa będzie formatowana, poniższy kod ustawi we właściwości Page wartość 1: Private Sub GroupHeader0_Format(Cancel As Integer, FormatCount As Integer) Me.Page = 1 End Sub
Właściwość Page pozwoli wyświetlić bieżący numer strony w nagłówku lub stopce. Można na przykład wstawić poniższe wyrażenie do niezwiązanego pola tekstowego w stopce strony: = "Strona " & [Page]
W bazie Rozdział21.accdb znajduje się raport o nazwie rptResetPageEachGroup, w którym zastosowano tę technikę. Niestety, nie istnieje prosta metoda liczenia stron w grupie, tak aby można było w stopce strony umieścić tekst Strona x z y, gdzie y będzie liczbą stron grupy.
Formatowanie danych Sortowanie i grupowanie danych nie są jedynymi metodami zwiększania przydatności raportów. Można też sformatować je tak, aby wyróżnić wybrane informacje. Numerowanie pozycji lub stosowanie wypunktowania pozwala wyróżnić dane, a za pomocą linii i odstępów można rozdzielić części raportu. Ważne jest też, aby elementy raportu były rozmieszczone w spójny sposób. Raport może obejmować wszystkie potrzebne dane, jednak jeśli są one niewłaściwie przedstawione, użytkownik może być bardzo niezadowolony. Techniki omówione w tym podrozdziale pomogą Ci w tworzeniu raportów o profesjonalnym wyglądzie.
Rozdział 21. Raporty w Accessie — techniki zaawansowane
625
Tworzenie list numerowanych Pozycje w raportach Accessa domyślnie nie są numerowane. Pojawiają się po prostu w kolejności podyktowanej ustawieniami w oknie dialogowym Grupowanie, sortowanie i sumowanie. Czasem przydaje się przypisać numer do każdej pozycji w raporcie lub w ramach grupy w raporcie. Można na przykład chcieć policzyć pozycje na liście albo jednoznacznie je zidentyfikować. Raport szczegółów sprzedaży może zawierać numer każdej zamówionej pozycji oraz pole dla zamówionych pozycji informujące, ile rzeczy zamówiono. Funkcja Accessa Suma bieżąca pozwala przypisać w raporcie numer do każdej pozycji listy. Załóżmy, że zarząd firmy Northwind Traders zażądał raportu zawierającego sumę sprzedaży dla każdego klienta w styczniu, posortowaną malejąco, tak że firma, która dokonała najwięcej zakupów, znajdzie się na szczycie listy. A tak przy okazji zarząd chce, by do każdego wiersza był przypisany numer, aby otrzymać ranking klientów firmy Northwind. Co za wymogi! Kwerenda, która posłuży do realizacji tego żądania, została przedstawiona na rysunku 21.14 (qryCustomerPurchasesJanuary). Kwerenda ta sumuje zakupy każdego klienta w miesiącu zaczynającym się 01.01.2012 i kończącym się 31.01.2012 roku. Kolumna Purchases została posortowana malejąco, więc klient dokonujący najwięcej zakupów znajdzie się na początku zestawu wyników kwerendy. Pole OrderDate nie zostało zawarte w wynikach kwerendy i jest używane w kwerendzie jedynie jako kryterium pobierania danych (zwróć uwagę na opcję Gdzie w komórce Podsumowanie).
Rysunek 21.14. Ciekawa kwerenda, która sumuje dane i zwraca wyniki w porządku malejącym
Wprawdzie wiele z tego można zrobić w czasie wykonywania programu, za pomocą kodu VBA programistycznie sumując wartości zwrócone przez kwerendę lub instrukcję SQL-a z właściwości Źródło rekordu raportu, jednak należy zawsze wykorzystywać silnik kwerend Accessa do wykonywania funkcji agregujących. Wszystkie kwerendy w Accessie są przy zapisywaniu optymalizowane. Daje to gwarancję, że kwerenda zostanie przeprowadzona tak szybko, jak to możliwe — o wiele szybciej, niż filtrowanie oparte na instrukcji SQL-a we właściwości Źródło rekordu raportu.
626
Część V Formularze i raporty Accessa Funkcje agregujące kreatora kwerend Accessa funkcjonują bezproblemowo. Co więcej, silnik ACE wykonuje funkcje agregujące dokładnie tak samo przy każdym uruchomieniu kwerendy. Nie ma żadnych powodów, by ręcznie sumować dane, gdy kwerenda może to zrobić za programistę.
Podstawowy raport (rptUnNumberedList), przygotowany na podstawie danych zwróconych przez kwerendę qryCustomerPurchasesJanuary, został przedstawiony na rysunku 21.15. W oknie dialogowym Grupowanie, sortowanie i sumowanie zostały usunięte wszystkie opcje sortowania, aby umożliwić automatyczne uporządkowanie rekordów według wyników kwerendy. Rysunek 21.15. Prosty raport (rptUnNumberedList) wygenerowany na podstawie danych z kwerendy qryCustomer PurchasesJanuary
Dodanie kolumny Pozycja do prostego raportu z rysunku 21.15 nie jest trudne. Wprawdzie informacje przedstawione na tym rysunku są przydatne, lecz nie tego zażądał użytkownik. Aby dodać do raportu kolumnę Pozycja, można wykorzystać właściwość Suma bieżąca niezwiązanego pola tekstowego, aby zsumować wartości dla wszystkich pozycji raportu. Gdy właściwość Suma bieżąca ma wartość W grupie, Access dodaje 1 do wartości w tym polu tekstowym dla każdego rekordu wyświetlonego w sekcji Szczegóły raportu (suma bieżąca może też zostać użyta w nagłówku lub stopce grupy). Inne ustawienie (Wszędzie) powoduje, że Access doda 1 dla każdego pojawienia się pola tekstowego w całym raporcie. Dodaj w raporcie po lewej stronie pola tekstowego CompanyName niezwiązane pole tekstowe z odpowiednim nagłówkiem w obszarze Nagłówek strony. We właściwości Źródło rekordów pola tekstowego wprowadź =1, a we właściwości Suma bieżąca — ustawienie Wszędzie. Na rysunku 21.16 pokazano pole tekstowe Ranking w raporcie rptNumberedList.
Rozdział 21. Raporty w Accessie — techniki zaawansowane
627
Rysunek 21.16. Wartość w niezwiązanym polu tekstowym o nazwie txtRank będzie zwiększana o 1 dla każdego rekordu w raporcie
Z rozdziału 20. dowiesz się, jak przenieść etykiety z sekcji szczegółów w inne miejsce.
Po otwarciu tego raportu (rptNumberedList) kolumna Pozycja zostanie zapełniona sumą bieżącą obliczoną przez Access (zobacz rysunek 21.17). Dane w tym raporcie są takie same jak w innych przykładowych raportach. Główne różnice polegają na dodatkowych manipulacjach przeprowadzonych przez kwerendę, zanim dane dotrą do raportu, oraz dodatkowych informacjach zwracanych z sumy bieżącej. Rysunek 21.17. Kolumna z sumą bieżącą podaje ranking klientów według wartości zakupów dokonanych w styczniu
628
Część V Formularze i raporty Accessa
Raporty mogą zawierać więcej niż jedno pole z sumą bieżącą. Można na przykład za pomocą sumy bieżącej wyświetlić liczbę sztuk towaru umieszczonych w każdym opakowaniu, gdy zamówienie składa się z wielu opakowań, podczas gdy druga suma bieżąca będzie liczyć opakowania. Początkowa wartość sumy bieżącej wynosi 0 (zero), dlatego też trzeba było zainicjalizować ją, wprowadzając wartość 1 we właściwości Źródło formantu na arkuszu właściwości. Można przypisać sumę bieżącą w każdej grupie, ustawiając we właściwości Suma bieżąca niezwiązanego pola tekstowego W grupie zamiast Wszędzie. Przy takim ustawieniu suma bieżąca będzie zaczynać się od 0 w każdej grupie. Trzeba więc pamiętać, by we właściwości Źródło formantu sumy bieżącej grupy wprowadzić wartość 1.
Dodawanie znaków wypunktowania Jeśli chcesz, możesz do listy dodać znaki wypunktowania, zamiast tworzyć listy numeryczne. Zamiast osobnego pola na znak wypunktowania łatwiej jest jednak po prostu dokleić ten znak do właściwości Źródło formantu pola. Access doklei znak wypunktowania do danych wyświetlanych w raporcie, eliminując problemy z wyrównaniem, które mogłyby pojawić się w przypadku użycia osobnego niezwiązanego pola tekstowego. Projekt raportu rptBullets przedstawiono na rysunku 21.18. Warto zwrócić uwagę na znak wypunktowania w polu tekstowym txtCompanyName oraz w arkuszu właściwości tego pola. Rysunek 21.18. Znak wypunktowania został dodany do właściwości Źródło formantu pola tekstowego txtCompanyName
Znaki wypunktowania dodawane są z wykorzystaniem mechanizmów systemu Windows. Należy umieścić kursor we właściwości Źródło formantu pola CompanyName i wpisać 0149, przytrzymując naciśnięty klawisz Alt. System Windows wstawi standardowy znak wypunktowania Windows, który pojawi się w arkuszu właściwości. Na rysunku 21.18 widać, że znak wypunktowania został poprawnie wstawiony do pola tekstowego w raporcie. Wyrażenie we właściwości Źródło formantu wygląda następująco:
Rozdział 21. Raporty w Accessie — techniki zaawansowane
629
= "•" & Space$(2) & [CompanyName]
gdzie znak wypunktowania został wstawiony za pomocą sztuczki z Alt+0149. Ten sam efekt możemy osiągnąć, używając w polu tekstowym następującego wyrażenia: = Chr(149) & Space$(2) & [CompanyName]
Wyrażenie to skleja znak wypunktowania (zwrócony przez Chr(149)) z danymi z pola CompanyName. Opisana sztuczka działa tylko wtedy, gdy do formantu (etykiety lub pola tekstowego) przypisana jest odpowiednia czcionka (np. Arial), obejmująca znak wypunktowania jako 149. znak ASCII. Nie wszystkie czcionki dostępne w aplikacjach Accessa obejmują znak wypunktowania, znajduje się on jednak w większości popularnych czcionek, np. w Arialu.
Teraz raport będzie wyglądać jak na rysunku 21.19. Można podać większą liczbę w funkcji Space$(), aby zwiększyć odstęp pomiędzy znakiem wypunktowania a tekstem. Znak wypunktowania i pole CompanyName zostały sklejone razem w polu tekstowym, więc będą wyświetlone takim samym krojem pisma. Poza tym dołączenie znaku wypunktowania do pola tekstowego zawierającego nazwę firmy zapewni, że odstęp pomiędzy znakiem i pierwszą literą nazwy firmy będzie taki sam we wszystkich rekordach. Podczas stosowania czcionek proporcjonalnych, takich jak Arial, czasem trudno jest osiągnąć precyzyjne wyrównanie pomiędzy elementami raportu. Sklejanie danych w polu tekstowym eliminuje problemy z odstępami powodowane przez czcionki proporcjonalne. Warto jednak zauważyć, że jeśli długość tekstu w polu przekroczy jeden wiersz, dla kolejnych wierszy wcięcie nie zostanie zastosowane. Rysunek 21.19. Funkcja Windows pozwala wstawić znak wypunktowania na początek pola CompanyName
Można też dodawać do formantów inne znaki specjalne. W aplikacji systemu Windows Charmap.exe (Tablica znaków; zobacz rysunek 21.20) widoczne są wszystkie znaki dostępne w czcionce, którą wybrano dla formantu pola tekstowego. Należy pamiętać, by wybrać czcionkę zastosowaną w formancie. Jedynym ograniczeniem w stosunku do znaków używanych w raportach Accessa jest to, że czcionka użyta w polu tekstowym musi zawierać wskazane znaki. Nie wszystkie zestawy znaków TrueType z systemu Windows zawierają komplet znaków specjalnych (np. znaki wypunktowania).
630
Część V Formularze i raporty Accessa
Rysunek 21.20. Tablica znaków to przydatne narzędzie do sprawdzania czcionek systemu Windows
Dodawanie wyróżnienia w czasie wykonywania programu Do raportów możemy dodać szereg ukrytych formantów, które zredukują natłok na stronie i niepotrzebne informacje. Formant może być ukrywany i wyświetlany w zależności od wartości innego formantu. Aby ukryć formant, należy podczas projektowania ustawić w jego właściwości Widoczny wartość False (lub No). Dopiero gdy informacje zawarte w formancie będą potrzebne, zmienimy tę wartość na True. Przykładem może być komunikat dla klientów firmy Northwind Traders mówiący, że produkcja danego towaru została przerwana i zapasy magazynowe maleją. Nie miałoby sensu pokazywanie tego komunikatu dla wszystkich pozycji z katalogu Northwind,
Rozdział 21. Raporty w Accessie — techniki zaawansowane
631
a przedstawienie w raporcie liczby pozostałych w magazynie sztuk towaru, razem z komunikatem o zaprzestaniu sprzedaży, może zachęcić klientów do zgromadzenia zapasów danego towaru. Rysunek 21.21 przedstawia raport rptPriceList w trybie podglądu wydruku (aby otworzyć podgląd, kliknij nazwę raportu i wybierz opcję Widok/Podgląd wydruku). Warto zauważyć, że napój Guarana Fantastica można wyróżnić pochyłą czcionką, jego cenę czcionką pochyłą pogrubioną, a po prawej stronie można na przykład podać komunikat Tylko 20 w magazynie!. Rysunek 21.21. Czy widzisz, że trwa promocja na napój Guarana Fantastica?
Rysunek 21.22 ujawnia część sekretów tej techniki. Pole tekstowe pod ceną jednostkową jest w istocie niezwiązane. Służy ono do wyświetlania użytkownikom ceny jednostkowej. Inne pole tekstowe związane zostało z polem UnitPrice ze zbioru rekordów, lecz zostało ukryte przez ustawienie we właściwości Visible wartości No. Tuż na lewo od ukrytego pola UnitPrice znajduje się ukryte pole wyboru, które reprezentuje pole Discontinued. Pole txtMessage, zawierające komunikat Tylko x w magazynie!, również jest ukryte. Rysunek 21.22. Raport rptPriceList w widoku projektu ujawnia, jak ta technika została zaimplementowana
632
Część V Formularze i raporty Accessa
Za pomocą zdarzenia Format sekcji Szczegóły właściwość Visible pola txtMessage jest zmieniana na True wówczas, gdy pole txtDiscontinued zawiera wartość True. Kod jest bardzo prosty: Private Sub Detail1_Format(Cancel As Integer, _ FormatCount As Integer) Me.txtProductName.FontItalic = Me.Discontinued.Value Me.txtPrice.FontItalic = Me.Discontinued.Value Me.txtPrice.FontBold = Me.Discontinued.Value ' Obniżanie ceny o połowę, gdy zaprzestano dostaw Me.txtPrice = Me.UnitPrice * IIf(Me.Discontinued.Value, 0.5, 1) Me.txtMessage.Visible = Me.Discontinued.Value End Sub
W tym kodzie Me jest skrótowym odwołaniem do raportu. Gdy dostawy towaru nie są zakończone, trzeba bezpośrednio wyłączyć kursywę, pogrubienie i inne właściwości czcionki. W przeciwnym razie podczas drukowania wszystkich produktów po produkcie, który przestał być sprowadzany, zostałyby wydrukowane ze specjalnymi ustawieniami czcionki. Właściwości czcionki ustawione w arkuszu właściwości formantu są jedynie ustawieniami początkowymi; jeśli zmienisz któreś ustawienie w czasie wykonywania programu, pozostanie ono zmienione aż do chwili, gdy zmodyfikujemy je ponownie. Podobnie pole txtMessage po wyświetleniu musi zostać ukryte przez ustawienie we właściwości Visible wartości False.
Unikanie pustych raportów Gdy Access nie znajdzie odpowiednich rekordów do wstawienia w sekcji Szczegóły raportu, podczas drukowania w sekcji tej pojawi się jedynie pusta linia. Aby uniknąć tego błędu, można do zdarzenia NoData raportu dołączyć kod, który wyświetla komunikat i ustawia flagę anulującą drukowanie, jeśli nie zostaną znalezione żadne rekordy. Zdarzenie NoData jest wyzwalane, gdy Access podczas próby zbudowania raportu nie znajdzie żadnych danych w zestawie rekordów, na którym opiera się raport. Sposób użycia NoData jest prosty: Private Sub Report_NoData(Cancel As Integer) MsgBox "Brak rekordów dla tego raportu." Cancel = True End Sub
Instrukcja Cancel = True informuje, że Access ma zaprzestać prób otwarcia raportu. Użytkownik zobaczy okno dialogowe z rysunku 21.23 i uniknie otwierania raportu, którego nie można wydrukować (aby zobaczyć ten przykład, otwórz raport rptEmpty z bazy danych Rozdział21.accdb). Zdarzenie NoData jest powiązane z samym raportem, nie znajdziesz go w żadnej sekcji raportu. Wystarczy dodać przedstawiony powyżej kod do procedury zdarzenia NoData raportu — użytkownicy nigdy więcej nie będą się zastanawiać, dlaczego raport jest pusty.
Rozdział 21. Raporty w Accessie — techniki zaawansowane
633
Rysunek 21.23. Informowanie użytkownika o tym, że nie ma rekordów do wydrukowania
Dodawanie linii pionowych pomiędzy kolumnami Linie pionowe można dodawać z łatwością do sekcji raportu, których wysokość jest stała (np. nagłówków i stopek grup). Dodanie linii pionowej do sekcji, której wysokość może się zmieniać (np. do sekcji Szczegóły w raporcie podzielonym na grupy), jest trudniejsze. Naprawdę niełatwo jest uzyskać linię pionową pomiędzy kolumnami raportu (zobacz raport rptVerticalLines na rysunku 21.24). Jeśli po prostu dodasz taką linię po prawej stronie sekcji raportu drukowanego w kilku kolumnach, pojawi się ona po prawej stronie ostatniej (prawej) kolumny strony. Potrzebny jest sposób, by wskazać, gdzie na drukowanej stronie mają pojawić się pionowe linie. Rysunek 21.24. Pionowe linie w raporcie rptVerticalLines pomagają rozdzielić dane
Tworzenie raportów ze szpaltami opisaliśmy w podrozdziale „Inne techniki” w dalszej części rozdziału. Wprawdzie większość formantów jest dodawana podczas projektowania raportu, lecz czasem nie można uniknąć generowania formantu bezpośrednio w chwili, gdy raport jest przygotowywany do wydrukowania. Najłatwiejszym rozwiązaniem w omawianej sytuacji
634
Część V Formularze i raporty Accessa
jest wykorzystanie metody Line raportu i dodanie pionowej linii w trakcie wykonywania programu. Poniższa procedura, wyzwalana przez zdarzenie Format sekcji Szczegóły, rysuje pionową linię 9 cm od lewego marginesu drukowania raportu: Sub Detail1_Format(Cancel As Integer, FormatCount As Integer) Dim X1 As Single X1 = 9 * 567 Me.Line (X1, 0)-(X1, 10000) End Sub
Składnia metody Line wygląda następująco: obiekt.Line (X1, Y1) - (X2, Y2)
Metoda Line przyjmuje cztery argumenty (X1, X2, Y1 i Y2). Wskazują one współrzędne góry i dołu linii (lub jej lewego i prawego końca). Warto zwrócić uwagę, że wszystkie obliczone wymiary na raporcie muszą zostać podane w twipach (567 twipów to jeden centymetr). Tu X1 i X2 mają tę samą wartość, a linia zaczyna się na samej górze sekcji Szczegóły (0) i biegnie w dół na długość 10 000 twipów. Możesz się zastanawiać, dlaczego użyto wartości 10 000 jako współrzędnej Y2 końca linii. Access automatycznie „przytnie” linię do wysokości sekcji Szczegóły. Formant linii nie zawiera danych, więc Access nie przedłuży sekcji Szczegóły tak, by zmieścić linię rysowaną przez kod. Zamiast tego narysuje odcinek linii tak długi, jak potrzeba do wypełnienia sekcji Szczegóły, i na tym się zatrzyma. Maksymalna wartość Y2 wynosi 32 767. Ta sama procedura może posłużyć do rysowania linii poziomych w każdej sekcji raportu. W omawianym przykładzie (raport rptVerticalLines) w bazie danych towarzyszącej niniejszemu rozdziałowi (Rozdział21.accbd) zamiast tego dodano do raportu formanty linii. Użycie formantu Linia, gdy wysokość sekcji raportu jest stała (np. w nagłówku lub stopce raportu), jest po prostu szybsze niż generowanie linii dla każdej sekcji. Gdy klikniesz raport dwukrotnie w okienku nawigacji, domyślnie otworzy się on w widoku raportu. Aby zobaczyć działanie niektórych technik (np. opisanej tu metody dodawania pionowych linii), musisz przełączyć się do podglądu wydruku.
Dodawanie pustego wiersza co n rekordów Sekcje szczegółów wypełnione dziesiątkami lub setkami rekordów mogą być mało czytelne. Zbyt łatwo jest zgubić miejsce podczas czytania kolumn liczb, gdy wiersze są stłoczone razem na stronie. Czy nie lepiej byłoby wstawić pusty wiersz co 4 – 5 rekordów w sekcji Szczegóły? O wiele łatwiej jest czytać poszczególne wiersze raportu, gdy co pięć rekordów zostanie wstawiony odstęp (raport rptGapsEvery5th w bazie Rozdział21.accdb; zobacz rysunek 21.25). Access nie udostępnia żadnej specjalnej metody wstawiania pustych wierszy w środku sekcji Szczegóły. Można jednak osiągnąć taki efekt, stosując odrobinę programowania i kilka ukrytych formantów.
Rozdział 21. Raporty w Accessie — techniki zaawansowane
635
Rysunek 21.25. Wstawienie pustego wiersza w celu podziału danych tabelarycznych poprawia ich czytelność
Rysunek 21.26 ujawnia sposób wykonania „sztuczki” widocznej na rysunku 21.25. Puste, niezwiązane pole tekstowe o nazwie txtSpacer zostało umieszczone pod polami zawierającym dane w sekcji Szczegóły. Po lewej stronie pola txtSpacer znajduje się drugie niezwiązane pole tekstowe o nazwie txtCounter. Rysunek 21.26. Ta sztuczka opiera się na ukrytych niezwiązanych polach tekstowych w sekcji Szczegóły
Dla pól txtSpacer i txtCounter oraz sekcji Szczegóły należy ustawić następujące właściwości (tabela 21.1). Tak skonfigurowane właściwości ukrywają niezwiązane formanty txtSpacer i txtCounter oraz pozwalają na „zwijanie” tych formantów oraz sekcji Szczegóły, gdy jest to konieczne (kiedy formant pola tekstowego txtSpacer jest pusty). Choć formant txtSpacer jest widoczny dla użytkownika, Access zmniejsza go do wysokości 0, gdy nie zawiera danych. Formant txtCounter nigdy nie będzie potrzebować miejsca, ponieważ jego właściwość Widoczny ma wartość Nie, co ukrywa go przed użytkownikiem.
636
Część V Formularze i raporty Accessa
Tabela 21.1. Właściwości z przykładu z pustymi wierszami Formant
Właściwość
Wartość
txtSpacer
Widoczny
Tak
Można zmniejszać
Tak
Widoczny
Nie
Suma bieżąca
Wszędzie
Źródło formantu
=1
Można zmniejszać
Tak
txtCounter
Szczegóły
Ostatnim krokiem będzie wprowadzenie poniższego kodu do procedury zdarzenia Format sekcji Szczegóły: Sub Detail1_Format (Cancel As Integer, _ FormatCount As Integer) If Me.txtCounter.Value Mod 5 = 0 Then Me.txtSpacer.Value = Space$(1) Else Me.txtSpacer.Value = Null End If End Sub
Zdarzenie Format występuje, gdy Access zaczyna formatować formanty w sekcji Szczegóły. Wartość w polu txtCounter jest zwiększana za każdym razem, gdy do sekcji Szczegóły zostaje dodany nowy rekord. Operator Mod zwraca resztę z dzielenia wartości w txtCounter przez 5. Gdy wartość ta jest podzielna przez 5, wynikiem wyrażenia txtCounter Mod 5 jest 0, co powoduje przypisanie znaku spacji do pola txtSpacer. W takim przypadku pole nie jest puste, przez co Access zwiększa wysokość sekcji Szczegóły, by pomieścić pole txtSpacer, czego wynikiem jest odstęp po każdych pięciu rekordach w sekcji. Samo pole txtSpacer nigdy nie jest widoczne, ponieważ zawiera najwyżej niewidoczny znak spacji. Pole txtCounter może zostać umieszczone w dowolnym miejscu sekcji Szczegóły raportu. Wysokość pola txtSpacer można dowolnie zmienić, by otrzymać pożądaną wysokość odstępów na wydruku.
Drukowanie stron nieparzystych i parzystych Każdy, kto przygotowywał już raport do drukowania dwustronnego, zapewne zetknął się z potrzebą ustalenia, czy dane są drukowane na stronie parzystej, czy na nieparzystej. Większość użytkowników woli, by numery stron znajdowały się w pobliżu zewnętrznej krawędzi papieru. Na stronach nieparzystych numer powinien znajdować się przy prawej krawędzi, natomiast na stronach parzystych musi znaleźć się przy krawędzi lewej. Jak więc przenosić numer strony z jednej krawędzi na drugą? Jeśli numery stron mają pojawiać się w sekcji Stopka strony raportu, można ustalić parzystość strony za pomocą zdarzenia Format jej stopki i odpowiednio przenieść numer strony na lewo lub na prawo.
Rozdział 21. Raporty w Accessie — techniki zaawansowane
637
Podstawowy projekt raportu rptEvenOdd został przedstawiony na rysunku 21.27. Warto zwrócić uwagę na to, że wartość właściwości Szerokość pola txtPageNumber jest taka sama jak w nagłówku raportu. Ponadto zawartość pola txtPageNumber została wyrównana do prawej. Zdarzenie Format określa, czy tekst należy wyrównać do lewej czy do prawej, dlatego ustawianie wyrównania do prawej wynika z arbitralnego wyboru. Rysunek 21.27. Pole txtPageNumber ma tę samą szerokość co raport
Procedura zdarzenia Format sekcji Stopka strony jest trochę bardziej złożona niż przedstawiona wcześniej funkcja IsEven. Trzeba zmienić właściwość TextAlign pola txtPage Number, by przesunąć numery stron do lewej lub prawej strony pola tekstowego (w zależności od tego, czy strona jest parzysta czy nieparzysta). Private Sub PageFooter1_Format(Cancel As Integer, _ FormatCount As Integer) Const byALIGN_LEFT As Byte = 1 Const byALIGN_RIGHT As Byte = 3 If Me.Page Mod 2 = 0 Then Me.txtPageNumber.TextAlign = byALIGN_LEFT Else Me.txtPageNumber.TextAlign = byALIGN_RIGHT End If End Sub
W tej procedurze zdarzenia za każdym razem, gdy wartość wyrażenia Me.Page Mod 2 wyniesie 0 (co oznacza, że strona ma numer parzysty), właściwość TextAlign jest ustawiana na 1 (wyrównanie do lewej). Na stronach nieparzystych właściwość ta jest ustawiana na 3 (wyrównanie do prawej). Niemal magicznie ta procedura zdarzenia przenosi pole tekstowe numeru strony z prawej krawędzi na stronach nieparzystych na krawędź lewą stron parzystych (zobacz rysunek 21.28).
638
Część V Formularze i raporty Accessa
Rysunek 21.28. Pole txtPageNumber przeskakuje z prawa na lewo
Używanie różnych formatów w tym samym polu tekstowym W pewnych raportach może zajść potrzeba stosowania w określonych polach formatów zmieniających się w zależności od wartości innych pól raportu. Dobrym przykładem może być raport z dowodów kasowych w wielowalutowym systemie finansowym, gdzie szczegóły mogą zmieniać się zależnie od liczby miejsc po przecinku użytych do wyświetlania wartości waluty. Niestety, formant w sekcji Szczegóły raportu może mieć najwyżej jeden format, zdefiniowany w arkuszu właściwości. Poniższa sztuczka pozwoli elastycznie zmieniać właściwości formatu w czasie wykonywania programu. Funkcja FlexFormat() wykorzystuje argument lDecimals do zwrócenia łańcucha znaków określającego pożądany format: Public Function FlexFormat(lDecimals As Long) As String FlexFormat = "#,##0." & String(lDecimals, "0") End Function
Funkcja String zwraca tu tyle zer, ile określono w argumencie lDecimals. Jeśli argument lDecimals ma wartość 2, funkcja FlexFormat zwraca "#,##.00". Załóżmy, że pole, które ma być formatowane dynamicznie, ma we właściwości Źródło formantu ustawienie [Amount]. Format pola tekstowego Amount powinien zmieniać się zależnie od wartości pola CurrDecPlaces w tym samym rekordzie. CurrDecPlaces jest typu Liczba. Aby wykorzystać funkcję FlexFormat, można zmienić zawartość właściwości Źródło formantu pola tekstowego Amount na: =Format([Amount],FlexFormat([CurrDecPlaces]))
Rozdział 21. Raporty w Accessie — techniki zaawansowane
639
Pole tekstowe Amount będzie formatowane dynamicznie, zgodnie z wartością pola tekstowego CurrDecPlaces. Tę sztuczkę można uogólnić i wykorzystać do formatowania pól innych niż związane z walutą. Jeśli będzie to potrzebne, można uzależnić formatowanie od więcej niż jednego pola, zwiększając liczbę parametrów funkcji formatującej zdefiniowanej przez użytkownika.
Centrowanie tytułu Umieszczenie tytułu raportu dokładnie na środku strony jest często trudne. Najłatwiejszą metodą zapewnienia, że tytuł zostanie poprawnie wyśrodkowany, jest rozciągnięcie pola tytułu od lewego marginesu aż do prawego i kliknięcie przycisku Do środka w poziomie.
Łatwe wyrównywanie etykiet formantów Poprawne wyrównanie pól tekstowych i ich etykiet w raportach bywa trudne. Pole tekstowe i jego etykieta mogą być w raporcie przenoszone niezależnie, więc nader często trzeba poprawiać położenie etykiety, aby wyrównać ją względem pola tekstowego. Można całkowicie wyeliminować etykiety pól tekstowych, dołączając tekst etykiety do źródła formantu pola tekstowego. Dodaj tekst etykiety do źródła formantu pola tekstowego, posługując się znakiem łączenia: = "Produkt: " & [ProductName]
Teraz podczas przenoszenia pola tekstowego etykieta i związane z nią źródło rekordu będą przemieszczać się jako całość. Jedyną wadą tej techniki jest konieczność użycia w polu tekstowym i jego etykiecie tego samego formatu.
Precyzyjne przemieszczanie formantów Rozmiary pól tekstowych formularza najłatwiej można zmieniać w małych krokach, przytrzymując klawisz Shift i naciskając klawisze kursora wymienione w tabeli 21.2. Tabela 21.2. Kombinacje klawiszy dla mikroregulacji Kombinacja klawiszy
Zmiana
Control+strzałka w lewo
Przesunięcie w lewo
Control+strzałka w prawo
Przesunięcie w prawo
Control+strzałka w górę
Przesunięcie w górę
Control+strzałka w dół
Przesunięcie w dół
Shift+strzałka w lewo
Zmniejszenie szerokości
Shift+strzałka w prawo
Zwiększenie szerokości
Shift+strzałka w górę
Zmniejszenie wysokości
Shift+strzałka w dół
Zwiększenie wysokości
640
Część V Formularze i raporty Accessa
Inna technika zmiany rozmiarów polega na najechaniu kursorem myszy na dowolny uchwyt zmiany rozmiarów wybranego formantu i dwukrotnym kliknięciu lewym przyciskiem myszy. Formant automatycznie zmieni rozmiary tak, by dopasować się do rozmiarów zawartego w nim tekstu. Ta szybka metoda pozwala wyrównywać nie tylko etykiety, lecz również pola tekstowe do siatki.
Dodawanie danych W trakcie przeglądania danych w formularzach zwykle można założyć, że są aktualne. Jednak w wydrukowanych raportach nie zawsze wiadomo, jak świeże są dane. Dodanie pewnych detali, takich jak data wydrukowania raportu, pomaga zwiększyć przydatność danych. W tym podrozdziale przedstawiono kilka technik, które wzbogacą raporty o dodatkowe informacje, pozwalające użytkownikom dowiedzieć się czegoś o pochodzeniu danych.
Dodawanie innych informacji do raportu Jak wiadomo, poniższe wyrażenie w niezwiązanym polu tekstowym zwróci bieżącą stronę i całkowitą liczbę stron raportu: ="Strona " & [Page] & " z " & [Pages]
Page i Pages są właściwościami raportu dostępnymi w czasie wykonywania programu i można je wykorzystać w raporcie.
Pomyśl jednak, jak mogą się przydać w raporcie inne jego właściwości. Większość właściwości raportu można dodać do niezwiązanych pól tekstowych, pod warunkiem, że właściwość znajdzie się w nawiasach kwadratowych. Właściwości takie przydają się najczęściej jedynie twórcom raportów, lecz niektóre mogą się też przydać użytkownikom. W taki sposób można dodać do raportu na przykład właściwości Name, RecordSource i inne. Rysunek 21.29 ilustruje, jak za pomocą niezwiązanych pól tekstowych dołączyć takie dane do stopki lub w innym miejscu raportu. Ramka w prawym dolnym rogu rysunku 21.29 zawiera informacje, które dołączono przez dodanie do raportu czterech przedstawionych pól tekstowych. Użytkownik bardzo często nie zna nawet nazwy raportu — jedyne informacje tekstowe, które widzi w drukowanym raporcie, to tekst na pasku tytułu (czyli wartość właściwości Tytuł raportu). W razie problemów z raportem użytkownikowi mogą przydać się informacje z rysunku 21.29 zawarte w stopce raportu.
Dodanie nazwiska użytkownika do raportu związanego Niezwiązane pole tekstowe z nieokreślonym odwołaniem we właściwości Źródło formantu spowoduje, że Access wyświetli okno dialogowe żądające informacji niezbędnych do wypełnienia pola. Na przykład jeśli we właściwości Źródło rekordów niezwiązanego pola tekstowego wpiszesz poniższy kod, po otwarciu raportu otworzy się okienko dialogowe widoczne pośrodku rysunku 21.30. =[Podaj swoje imię i nazwisko]
Rozdział 21. Raporty w Accessie — techniki zaawansowane
641
Rysunek 21.29. Raport rptMoreInfo demonstruje, jak dołączać do raportów dodatkowe informacje
Rysunek 21.30. Niezwiązane pole tekstowe pozwala uzyskiwać przydatne informacje
Access wyświetla podobne okno dialogowe Wprowadzanie wartości parametru dla każdego parametru kwerendy z parametrami. Tekst wpisany w tym oknie zostanie wyświetlony na raporcie. Technika ta została zademonstrowana w raporcie rptUserName z bazy danych Rozdział21.accdb w plikach towarzyszących niniejszej książce.
642
Część V Formularze i raporty Accessa
Z niezwiązanego pola tekstowego mogą korzystać inne formanty w raporcie. Okno dialogowe Wprowadzanie wartości parametru pojawia się przed przygotowaniem raportu do wydrukowania, co oznacza, że wprowadzone w nim dane mogą zostać wykorzystane w wyrażeniach, obliczeniach oraz kodzie VBA raportu. W języku VBA dostępna jest funkcja ENVIRON(), którą można wykorzystać do automatycznego pobrania nazwy użytkownika. Aby wyświetlić nazwę użytkownika bez wyświetlania prośby o jej podanie, zastosuj polecenie ENVIRON("USERNAME") w funkcji VBA i wykorzystaj tę funkcję we właściwości Źródło formantu pola tekstowego. Użytkownik może łatwo zmienić nazwę zwracaną przez funkcję ENVIRON(), dlatego nie stosuj tej techniki tam, gdzie tożsamość użytkownika ma duże znaczenie.
Inne techniki Prawdopodobnie zauważyłeś już, że raporty w Accessie to bardzo rozbudowany temat. W tym podrozdziale opisano kilka dodatkowych technik, dzięki którym raporty będą jeszcze przydatniejsze dla użytkowników.
Wyświetlanie wszystkich raportów w polu kombi Nazwy wszystkich obiektów najwyższego poziomu w bazie danych są przechowywane w tabeli systemowej MSysObjects. Można przeprowadzać kwerendy na tej tabeli tak samo jak na każdej innej tabeli bazy danych. Wypełnienie pola kombi lub pola listy obiektami raportów obecnych w bazie danych Access jest proste. Należy wybrać Tabela/Kwerenda we właściwości Typ źródła wierszy dla pola listy i umieścić poniższą instrukcję SQL-a we właściwości Źródło wierszy pola listy, aby otrzymać w polu listę wszystkich raportów w bazie danych: SELECT DISTINCTROW [Name] FROM MSysObjects WHERE [Type] = -32764 ORDER BY [Name];
Wartość -32764 identyfikuje obiekty raportów w MSysObjects — jednej z tabel systemowych używanych przez program Microsoft Access. Efekt przedstawiono na rysunku 21.31. Rysunek 21.31. Formularz frmAllReports wyświetla raporty zawarte w bazie danych Rozdział21.accdb
Rozdział 21. Raporty w Accessie — techniki zaawansowane
643
Aby ta technika zadziałała, raporty nie muszą być otwarte. W tabeli MSysObjects znajdują się wszystkie obiekty z bazy danych, dlatego opisana metoda nie pominie żadnego raportu.
Jeśli obiekty w bazie danych są ponazywane zgodnie z jakąś konwencją, można posłużyć się przedrostkiem, by wyświetlić tylko pożądane raporty. Poniższy kod zwraca tylko raporty, których nazwy zaczynają się na tmp: SELECT DISTINCTROW [Name] FROM MSysObjects WHERE [Type] = -32764 AND Left([Name], 3) = "tmp" ORDER BY [Name];
Ponieważ MSysObjects zawiera nazwy wszystkich obiektów bazy danych, można zwracać również nazwy innych obiektów najwyższego poziomu. Wystarczy w powyższych instrukcjach SQL-a zmienić wartość określającą typ (-32764) na inną. Tabela 21.3 przedstawia wartości zwracające inne typy obiektów bazy danych. Tabela 21.3. Typy obiektów i wartości w programie Microsoft Access Obiekt
Wartość typu
Tabele lokalne
1
Tabele związane (oprócz tabel związanych za pomocą ODBC)
6
Tabele związane za pomocą ODBC
4
Formularze
–32768
Moduły
–32761
Makra
–32766
Kwerendy
5
Aby wyświetlić tabelę MSysObjects, należy w oknie dialogowym Opcje nawigacji (dostępnym przez kliknięcie prawym klawiszem myszy paska tytułu panelu nawigacji i wybranie Opcje nawigacji z menu podręcznego) zaznaczyć pole wyboru Pokaż obiekty systemowe. Tabela MSysObjects nie musi być widoczna, aby ta sztuczka zadziałała. Choć Microsoft poinformował, że tabela MSysObjects i wartości typów nie są obsługiwane, dlatego mogą ulec zmianie w dowolnym momencie, w Accessie te same wartości typów są używane od wielu lat. Jest mało prawdopodobne, że Microsoft usunie tabelę MSysObjects lub zmieni wartości typów, warto jednak pamiętać, że opisana sztuczka w przyszłości może przestać działać.
Szybkie drukowanie danych z kwerendy Drukowanie raportu opartego na kwerendzie może być czasochłonne. Raporty i formularze nie mogą korzystać z tego samego zestawu rekordów, więc gdy użytkownik znajdzie właściwy rekord w formularzu, szkoda byłoby wykonywać tę samą kwerendę, by wydrukować raport. Można „buforować” informacje w formularzu, tworząc tabelę (nazwiemy ją tblCache) zawierającą wszystkie pola, które zostaną później wydrukowane
644
Część V Formularze i raporty Accessa
w raporcie. Następnie, gdy użytkownik znajdzie właściwy rekord formularza, można skopiować dane z formularza do tabeli tblCache i otworzyć raport. Raport ten będzie oczywiście oparty na tabeli tblCache. Kwerenda jest wykonywana tylko raz, by zapełnić formularz. Operacja kopiowania z formularza do tabeli tblCache odbywa się bardzo szybko, a w razie potrzeby można do tej tabeli dodać większą liczbę rekordów. Raport jest teraz oparty na tabeli, więc otwiera się szybko i jest gotowy do wydrukowania zaraz po otwarciu.
Używanie dwóch i więcej kolumn w raporcie Gdy dane wyświetlane w raporcie nie wymagają pełnej szerokości strony, czasami można zredukować liczbę stron, wyświetlając dane w wielu kolumnach, tak jak w słowniku lub książce telefonicznej. Dzięki temu potrzeba mniej miejsca i mniej papieru, a wydrukowanie raportu potrwa krócej. Na jeden rzut oka dostępnych będzie więcej informacji, a poza tym wielu użytkowników preferuje układ danych w dwóch lub kilku kolumnach ze względów estetycznych. Dla przykładów w niniejszym podrozdziale potrzebna jest kwerenda, która zwróci więcej danych, niż używano do tej pory. Kwerendę, która posłuży do przygotowania przykładowych raportów, przedstawia rysunek 21.32.
Rysunek 21.32. Ta kwerenda zwraca bardziej szczegółowe informacje niż kwerendy używane do tej pory
Kwerenda ta zwraca następujące dane: nazwę firmy, datę zamówienia, identyfikator zamówienia, nazwę produktu, cenę jednostkową oraz liczbę sztuk dla zamówień z okresu od 1 stycznia 2012 roku do 31 marca 2012 roku. Wstępny projekt raportu, który będzie zawierać te dane, został przedstawiony w widoku projektu na rysunku 21.33. Ten dość złożony raport zawiera grupę opartą na identyfikatorze zamówienia dla każdego zamówienia złożonego przez firmę oraz grupę opartą na samej firmie. Taka struktura pozwoli zsumować dane z każdego zamówienia z kwartału oraz poszczególnych firmy w ujęciu kwartalnym.
Rozdział 21. Raporty w Accessie — techniki zaawansowane
645
Rysunek 21.33. Warto zwrócić uwagę, jak wąskie są rekordy w tym raporcie
Ten sam raport w podglądzie wydruku został przedstawiony na rysunku 21.34. Warto zwrócić uwagę, że raport niezbyt efektywnie wykorzystuje dostępną szerokość strony — każdy rekord raportu ma zaledwie 8,25 cm szerokości.
Rysunek 21.34. Ten raport słabo wykorzystuje dostępną szerokość strony
646
Część V Formularze i raporty Accessa
Ustawienie drukowania raportu w kilku kolumnach to opcja z konfiguracji wydruku raportu — nie jest to atrybut samego raportu. Wybierz opcję Kolumny z zakładki NARZĘDZIA PROJEKTOWANIA RAPORTÓW w widoku projektu, aby otworzyć okno dialogowe Ustawienia strony (zobacz rysunek 21.35), a następnie wybierz kartę Kolumny. Zmień wartość w polu Liczba kolumn na 2. W chwili wprowadzenia tej zmiany uaktywni się obszar Układ kolumn na dole karty, w którym, jak widać, Access wybrał opcję W poprzek i w dół, co oznacza, że pozycje mają najpierw być drukowane na szerokość strony, a następnie poniżej. Takie ustawienie nadaje się do drukowania nalepek adresowych dla przesyłek, lecz nie jest odpowiednie w rozwijanym raporcie. Wybierz W dół i w poprzek, by Access drukował raport w kolumnach (zobacz rysunek 21.35). Rysunek 21.35. Do uzyskania dwóch kolumn wystarczy kilka zmian
Podczas drukowania w kilku kolumnach zawsze należy sprawdzić, czy został wybrany odpowiedni układ kolumn. Jeśli zapomnisz zmienić układ na W dół i w poprzek, kolumny będą drukowane poziomo na szerokość strony. Ta typowa pomyłka może powodować sporo niejasności, ponieważ raport nie będzie wyglądać zgodnie z oczekiwaniami (zobacz rysunek 21.36). Raporty z rysunków 21.36 i 37 są identyczne, z wyjątkiem ustawienia Układ kolumn. Jeśli nie będzie zaznaczone pole wyboru Tak, jak szczegóły, Access inteligentnie dopasuje odstępy kolumn i inne opcje, tak by zmieścić na stronie ustawioną liczbę kolumn. Po zaznaczeniu tego pola Access wymusi szerokość kolumn zgodną z ustawieniami w widoku projektu, co może oznaczać, że wybrana liczba kolumn nie zmieści się na stronie. Rysunek 21.37 wyraźnie ilustruje efekt zmiany układu raportu na dwukolumnowy. Przed zmianą wydrukowany raport zajmował 17 stron. Po wprowadzeniu zmiany wystarczyło dziewięć stron.
Rozdział 21. Raporty w Accessie — techniki zaawansowane
Rysunek 21.36. Niewłaściwe ustawienie Układ kolumn może narobić sporo zamieszania!
Rysunek 21.37. Drukowanie raportu w kilku kolumnach pozwala zaoszczędzić miejsca na papierze i zapewnia szybki dostęp do większej ilości informacji
647
648
Część V Formularze i raporty Accessa
Możliwe, że zastanawiasz się, co oznaczają inne opcje wydruku w oknie dialogowym Ustawienia strony (zobacz rysunek 21.35). Oto krótki opis poszczególnych ustawień na karcie Kolumny:
Liczba kolumn — określa liczbę kolumn w raporcie. Należy pamiętać, że parametr ten wpływa jedynie na sekcje Szczegóły, Nagłówek grupy i Stopka grupy. Sekcje Nagłówek strony i Stopka strony nie będą powielane dla każdej kolumny. W trakcie projektowania raportu z kilkoma kolumnami należy zachować na tyle małą szerokość obszaru projektowego, aby po pomnożeniu jej przez liczbę kolumn dane zmieściły się na stronie. Zazwyczaj jeśli w raporcie potrzebne jest miejsce na więcej niż jedną kolumnę, pomocne jest drukowanie w układzie poziomym.
Odstęp wierszy — dodatkowy odstęp w pionie dla każdej pozycji w sekcji Szczegóły. Pozwala wymusić większe odstępy pomiędzy pozycjami, niż umożliwia to projekt raportu.
Odstęp kolumn — dodatkowy odstęp w poziomie pomiędzy kolumnami. Pozwala wymusić większe odstępy pomiędzy kolumnami, niż umożliwia to projekt raportu.
Rozmiar kolumn — Tak, jak szczegóły — szerokość kolumny i wysokość pozycji będą takie same jak w widoku projektu raportu. Ta właściwość przydaje się, gdy trzeba dokładnie rozmieścić kolumny na wydruku raportu (np. gdy dane mają być drukowane na przygotowanych formularzach). Zmiany w ustawieniach projektu raportu będą odzwierciedlane na papierze.
Rozmiar kolumn — Szerokość i Wysokość — szerokość i wysokość kolumny. Te ustawienia przydają się podczas drukowania na gotowych formularzach, by zapewnić, że dane trafią we właściwe miejsca.
Układ kolumn — kolejność drukowania pozycji: W dół i w poprzek albo W poprzek i w dół.
Oprócz tych właściwości należy zwrócić uwagę na właściwość Nowy wiersz lub kolumna sekcji CompanyName — nagłówek (zobacz rysunek 21.38). Wartości tej właściwości to Brak, Przed sekcją, Po sekcji, Przed i po. Za pomocą właściwości Nowy wiersz lub kolumna można wymusić na Accessie na przykład rozpoczynanie nowej kolumny bezpośrednio po wydrukowaniu stopki grupy lub sekcji Szczegóły (zobacz rysunek 21.39). W niektórych raportach i danych właściwość ta umożliwia poprawę czytelności raportów. Należy pamiętać, że o jednostkach miary w oknie dialogowym Ustawienia strony decydują ustawienia systemu Windows. Na przykład w Polsce lub w Niemczech stosowany jest system metryczny, więc wartości będą podane w centymetrach, a nie w calach. Trzeba też wziąć poprawkę na marginesy skonfigurowane na zakładce OPCJE DRUKOWANIA na wstążce (zobacz rysunek 21.40).
Rozdział 21. Raporty w Accessie — techniki zaawansowane Rysunek 21.38. Nagłówki i stopki mają właściwości, które można wykorzystać do ustawiania operacji zachodzących po zmianie wartości
Rysunek 21.39. Właściwość Nowy wiersz lub kolumna pozwala wymusić na Accessie rozpoczynanie kolumny przed sekcją lub po niej
649
650
Część V Formularze i raporty Accessa
Rysunek 21.40. Wszystkie ustawienia stron raportu muszą uwzględniać szerokość marginesów
Jeśli ustawisz na przykład szerokość kolumny na 8,5 cm i lewy margines na 2,5 cm, oznacza to, że prawy brzeg kolumny będzie odległy od lewej krawędzi papieru o 11 cm, czyli więcej niż połowę szerokości papieru A4 (21 cm). Takie ustawienie nie pozwoli na wydrukowanie na standardowym papierze A4 obok siebie dwóch kolumn raportu. W takim przypadku można zmniejszyć szerokość lewego i prawego marginesu, tak by na stronie zmieściły się dwie kolumny o szerokości 8,5 cm każda. Nie ma powodów do obaw o ustawienie marginesów zbyt wąskich dla konkretnej drukarki. Z wyjątkiem niestandardowych drukarek system Windows zna dostępny do drukowania obszar strony i nie pozwoli ustawić zbyt małych marginesów.
Wykorzystanie dwuprzebiegowego przetwarzania raportów W rozdziale 20. wspomniano, że Access formatuje i drukuje raporty w dwóch przebiegach. Tu wyjaśniono, co to oznacza i jak wykorzystać oba etapy w rozwijanych aplikacjach. Główną zaletą takiego sposobu przetwarzania jest to, że raporty mogą zawierać wyrażenia zależne od informacji, które są dostępne w innych miejscach raportu. Na przykład umieszczenie formantu z funkcją Suma() w nagłówku lub stopce oznacza, iż Access w pierwszym przebiegu zgromadzi dane wymagane przez funkcję, a w drugim przetworzy wartości w tej sekcji, zanim je wydrukuje. Innym oczywistym przykładem może być umieszczenie w stopce raportu niezwiązanego pola tekstowego, zawierającego następujące wyrażenie: ="Strona " & [Page] & " z " [Pages]
Wartość zmiennej wbudowanej Pages (zawierającej całkowitą liczbę stron raportu) zostaje ustalona dopiero po ukończeniu przez Access pierwszego przebiegu raportu. W drugim przejściu Access będzie dysponować poprawną liczbą, którą wstawi w miejsce zmiennej Pages.
Rozdział 21. Raporty w Accessie — techniki zaawansowane
651
Największą zaletą raportowania dwuprzebiegowego jest to, że można swobodnie stosować funkcje agregujące, zależne od źródła rekordów używanego w raporcie. Nagłówki i stopki grup mogą mieścić informacje dostępne dopiero po przetworzeniu całego źródła rekordów. W wielu sytuacjach zagregowane informacje dają cenny wgląd w dane. Zastanów się na przykład nad raportem, który ma zawierać dane na temat wydajności wszystkich sprzedawców z ubiegłego roku mierzone względem całkowitych wyników sprzedaży organizacji albo regionalne wyniki sprzedaży w porównaniu z całym obszarem działania firmy. Księgarnia może wymagać informacji, ile miejsca w magazynie zajmuje każda z kategorii książek. Rysunek 21.41 przedstawia taki raportu. Informacje o liczbie klientów, całkowitej sumie sprzedaży i średniej wartości zakupu na górze raportu (rptSummary) należą do jego nagłówka. W jednoprzebiegowym narzędziu do generowania raportów dane niezbędne do wykonania takich obliczeń nie byłyby dostępne przed końcem strony, po przetworzeniu i wyświetleniu wszystkich rekordów. Rysunek 21.41. Dane sumaryczne w nagłówku raportu
Rzut oka na raport rptSummary w widoku projektu (zobacz rysunek 21.42) pozwala odkryć, że pola tekstowe w nagłówku są zapełniane danymi uzyskanymi w wyniku wykonania poniższych wyrażeń matematycznych: Liczba klientów: =Policz([CompanyName]) Sprzedaż łącznie: =Format(Suma([Purchases]),"Walutowy") Średnia wartość transakcji: =Format(Suma([Purchases])/ _ Policz([CompanyName]), "Walutowy")
652
Część V Formularze i raporty Accessa
Rysunek 21.42. Raport rptSummary w widoku projektu
Funkcje Policz() i Suma() wymagają informacji niedostępnych przed przetworzeniem całego raportu. Jeśli Access może znaleźć argumenty dla tych funkcji (CompanyName i Purchases) w zestawie rekordów, obliczenia zostaną przeprowadzone bez interwencji użytkownika.
Przypisywanie unikatowych nazw do formantów Jeśli podczas projektowania raportów posłużysz się kreatorem raportów lub przeciągniesz pola z listy pól, Access przypisze nowym polom tekstowym te same nazwy, co polom w zestawie rekordów, na którym opiera się raport. Na przykład jeśli przeciągniesz pole o nazwie Discount z listy pól, zarówno właściwość Nazwa, jak i Źródło formantu pola tekstowego otrzymają wartość Discount. Jeśli inny formant w raporcie będzie odwoływać się do pola tekstowego lub jeśli zmienisz Źródło formantu pola tekstowego na wyrażenie, np.: =IIf([Discount]=0,"Niedostępny",[Discount])
to przy wyświetleniu raportu pojawi się komunikat #Błąd. Przyczyną tego jest fakt, że Access nie może odróżnić formantu o nazwie Discount od pola o nazwie Discount w zestawie rekordów, na którym opiera się raport. W takiej sytuacji trzeba zmienić właściwość Name formantu, np. na txtRabat, aby Access mógł rozróżnić nazwę formantu i pole, na którym się opiera.
Część VI
Podstawy programowania w Accessie W tej części:
Rozdział 22. Korzystanie z makr programu Access
Rozdział 23. Podstawy programowania w języku VBA
Rozdział 24. Typy danych i procedury w języku VBA
Rozdział 25. Model zdarzeń
Rozdział 26. Debugowanie aplikacji Accessa
Część VI to wprowadzenie do programowania makr. Poznasz tu także naukę i sztukę programowania w języku VBA (ang. Visual Basic for Applications). Zdecydowana większość profesjonalnych aplikacji Accessa zawiera dużą ilość kodu VBA lub makr (albo obu tych elementów). Od Accessa 2007 Microsoft zaczął intensywne prace nad zwiększeniem roli makr w tworzeniu aplikacji. Makra przez długi czas były uznawane za mniej przydatne i gorsze od kodu VBA, dlatego programiści Accessa traktowali je jako drugorzędne narzędzie. Jednak z rozdziału 22. dowiesz się, że Microsoft udostępnił makra osadzone, które są bardzo wydajnym narzędziem do automatyzowania licznych zadań w formularzach i raportach. Począwszy od rozdziału 23., w części VI omawiamy automatyzowanie zadań za pomocą kodu VBA. Język VBA udostępnia funkcje znacznie wykraczające poza otwieranie formularzy i raportów oraz kontrolowanie interfejsu użytkownika. Za pomocą kodu VBA można sprawdzać poprawność danych, a także przekształcać dane oraz łączyć je w nowe i ciekawe sposoby. Kod VBA służy do importowania i eksportowania danych, reagowania na dane wprowadzone przez użytkownika i obsługiwania błędów, które osoby korzystające z aplikacji bez wątpienia będą popełniać.
654
Część VI Podstawy programowania w Accessie
Rozdział 22.
Korzystanie z makr programu Access W tym rozdziale:
Zapoznanie z makrami
Makra a bezpieczeństwo
Praca z makrami obejmującymi różne akcje
Używanie podmakr do wykonywania popularnych akcji
Podejmowanie decyzji warunkowych
Używanie zmiennych tymczasowych
Obsługa błędów i debugowanie makr
Wprowadzenie do makr osadzonych
Porównanie makr z VBA
Od samego początku makra były częścią Accessa. Mijał czas i Access stawał się narzędziem programistycznym, a Visual Basic for Applications (VBA) stawał się standardowym językiem programowania do automatyzowania aplikacji bazodanowych. W poprzednich wersjach Accessa w makrach brakowało obsługi zmiennych oraz błędów, co powodowało, że wielu programistów rezygnowało z tego mechanizmu. W wersji Access 2013 te funkcje są dostępne (dodano je w Accessie 2007), dzięki czemu makra są lepszą alternatywą dla języka VBA, niż były w poprzednich wersjach. Jeżeli ktoś tworzy bazę danych przeznaczoną do użytku w internecie, nie ma ochoty pisać kodu VBA lub nie ma doświadczenia w programowaniu w VBA, a nadal chce indywidualizować akcje wykonywane przez program, ustrukturyzowane makra są doskonałym rozwiązaniem. W rozdziale wykorzystano bazę danych o nazwie Rozdział22.accdb. Jeżeli nie została ona jeszcze skopiowana na dysk komputera, należy to zrobić teraz. Baza ta zawiera tabele, formularze, raporty oraz makra, które wykorzystywane są w tym rozdziale.
656
Część VI Podstawy programowania w Accessie
Wprowadzenie do makr Makro to narzędzie umożliwiające automatyzację zadań w programie Access. Jest to inne narzędzie niż mechanizm nagrywania makr Worda, który pozwala na nagranie serii czynności i późniejsze ich odtworzenie. Od makr Worda Różni się też tym, że w Wordzie makra są oparte na kodzie w VBA, natomiast makra Accessa to coś zupełnie innego. Makra programu Access umożliwiają przeprowadzanie określonych czynności oraz dodawanie funkcji do formularzy i raportów. O makrach należy myśleć w kategoriach uproszczonego języka programowania — buduje się listę czynności, jakie mają być wykonane, i decyduje, kiedy mają one nastąpić. Budowanie makra obejmuje wybór akcji z listy rozwijanej i następnie wypełnienie sekcji argumentów (wartości, które przenoszą informacje do akcji). Makra pozwalają na wybór akcji bez pisania nawet jednego wiersza kodu VBA. Akcje te stanowią podzbiór komend dostępnych w VBA. Dla większości osób łatwiejsze jest zbudowanie makra niż napisanie kodu VBA. Jeżeli ktoś nie zna tego języka programowania, wówczas tworzenie makr stanowi duży krok naprzód pozwalający zapoznać się z niektórymi z dostępnych poleceń i wzbogacić aplikacje Accessa. Załóżmy, że chcesz zbudować główny ekran zawierający przyciski, które będą otwierać inne formularze w danej aplikacji. Można dodać przycisk do formularza, zbudować makro otwierające kolejny formularz w aplikacji i następnie przypisać to makro do zdarzenia Przy kliknięciu danego obiektu. Makro może być osobnym obiektem, który pojawi się w panelu nawigacyjnym, ale może być również obiektem, który jest częścią samego zdarzenia (zobacz punkt „Makra osadzone”).
Tworzenie makr Prostym sposobem na zademonstrowanie, jak utworzyć makro, jest zbudowanie makra wyświetlającego okno z komunikatem Witaj świecie!. Aby stworzyć nowe, autonomiczne makro, należy kliknąć polecenie Makro znajdujące się w grupie Makra i kod w zakładce TWORZENIE (zobacz rysunek 22.1).
Rysunek 22.1. Aby utworzyć nowe, autonomiczne makro, należy użyć zakładki TWORZENIE
Polecenie Makro otwiera okno projektu makra i wyświetla wstążkę NARZĘDZIA MAKR PROJEKTOWANIE (zobacz rysunek 22.2). Początkowo w oknie projektowym makra dostępnych jest niewiele funkcji. Okno makra obejmuje tylko listę rozwijaną z akcjami makr. Po prawej stronie okna makra widoczny jest wykaz akcji. Istnieją dziesiątki różnych akcji, dlatego czasem nie wiadomo, którą z nich zastosować do wykonania danego zadania. Wykaz akcji wyświetla drzewo z wszystkimi dostępnymi akcjami makr i pomaga ustalić, która akcja jest potrzebna. Wykaz ten dokładniej opisano w dalszej części rozdziału.
Rozdział 22. Korzystanie z makr programu Access
657
Rysunek 22.2. Okno projektowania makra wyświetla okno makra i wykaz akcji
Należy wybrać opcję OknoKomunikatu z listy rozwijanej w oknie makra. W oknie pojawi się wtedy obszar, w którym można wprowadzić argumenty (Komunikat, Sygnalizuj dźwiękiem, Typ i Tytuł) powiązane z akcją OknoKomunikatu. Należy ustawić następujące argumenty:
Komunikat: Witaj świecie!
Sygnalizuj dźwiękiem: Nie
Typ: Brak
Tytuł: Proste makro
Ekran bazy danych powinien wyglądać podobnie jak ten przedstawiony na rysunku 22.3. Argument Komunikat określa tekst, jaki zostanie wyświetlony w oknie wiadomości (jest to jedyny argument, który jest wymagany i nie ma wartości domyślnej). Argument Sygnalizuj dźwiękiem definiuje, czy w momencie wyświetlenia okna słyszalny będzie sygnał dźwiękowy. Argument Typ ustawia rodzaj ikony pokazywanej w oknie komunikatu: Brak, Krytyczny, Ostrzeżenie?, Ostrzeżenie!, Informacje. Argument Tytuł definiuje tekst wyświetlany w pasku tytułu okna komunikatu. Rysunek 22.3. Makro Witaj świecie korzysta z akcji OknoKomunikatu do wyświetlenia wiadomości
658
Część VI Podstawy programowania w Accessie
Aby uruchomić makro, należy kliknąć polecenie Uruchom znajdujące się w grupie Narzędzia w zakładce PROJEKTOWANIE. Przycisk ten znajduje się po lewej stronie wstążki i widoczny jest na nim duży czerwony wykrzyknik. Przy tworzeniu nowego lub modyfikacji już istniejącego makra Access poprosi o jego zapisanie (makro przed uruchomieniem trzeba zapisać). Kiedy odpowiedni komunikat zostanie wyświetlony, należy kliknąć Tak, zmienić nazwę na mcrHelloWorld i kliknąć OK. Makro zostanie uruchomione i wyświetli okno komunikatu o określonych argumentach (zobacz rysunek 22.4). Rysunek 22.4. Uruchomienie makra Witaj świecie spowoduje wyświetlenie okna komunikatu
Makro można również uruchomić, korzystając z Okienka nawigacji. W tym celu należy najpierw zamknąć okno projektowania makra i wyświetlić w Okienku nawigacji grupę Makra. Następnie klika się dwukrotnie na makrze mcrHelloWorld, aby je uruchomić. Pojawi się dokładnie takie samo okno, jakie wyświetlone było przy uruchomieniu makra z poziomu okna projektu. Warto zauważyć, że okno komunikatu zawsze pojawia się na środku ekranu i do czasu kliknięcia przycisku OK uniemożliwia pracę z Accessem. Generowane w ten sposób okno komunikatu działa tak samo jak okno komunikatu wyświetlane za pomocą kodu VBA. Jeśli makro „Witaj, świecie” działa w pożądany sposób, można kliknąć przycisk zamykania w prawym górnym rogu okna makra, aby wrócić do głównego okna Accessa.
Przypisanie makra do zdarzenia Kiedy ktoś tworzy makro, to prawdopodobnie nie chce, by użytkownicy końcowi do uruchamiania go używali Okienka nawigacji lub, co gorsza, uruchamiali je z poziomu okna projektowania. Przeznaczeniem makr jest automatyzacja aplikacji bez pisania kodu VBA. Aby uczynić aplikację łatwą w użyciu, należy przypisać makra do zdarzeń obiektów. Najpopularniejszym zdarzeniem jest zdarzenie Przy kliknięciu. Aby stworzyć formularz z przyciskiem, który uruchamia makro mcrHelloWorld, wykonaj następujące czynności: 1. Kliknij zakładkę TWORZENIE, a następnie kliknij polecenie Projekt formularza, które znajduje się w grupie Formularze. 2. W zakładce PROJEKTOWANIE wyłącz opcję Użyj kreatorów formantów, która znajduje się w grupie Formanty. W tym przykładzie nie należy korzystać z kreatora przy określaniu, co ma robić przycisk. 3. Kliknij formant Przycisk i dodaj przycisk do formularza. 4. Ustaw nazwę przycisku na cmdHelloWorld. Jeśli arkusz właściwości nie jest widoczny na ekranie, wciśnij klawisz F4. 5. W polu Tytuł wpisz Witaj, świecie. 6. Kliknij menu rozwijane przy zdarzeniu Przy kliknięciu i wybierz opcję mcrHelloWorld (zobacz rysunek 22.5).
Rozdział 22. Korzystanie z makr programu Access
659
Rysunek 22.5. Można przypisywać właściwość zdarzenia obiektu do makra, które zostanie uruchomione, kiedy dane zdarzenie wystąpi
To wszystko, czego potrzeba do utworzenia i uruchomienia makra. Wystarczy wybrać akcję, ustawić jej argumenty oraz przypisać makro do właściwości zdarzenia. Należy zapamiętać, że nie jest się ograniczonym do zdarzenia przycisku Przy kliknięciu. Jeżeli ktoś chce uruchomić makro w trakcie ładowania formularza, wystarczy, że ustawi odpowiednią nazwę makra w zdarzeniu formularza Przy otwarciu. Dostępne zdarzenia dla danego obiektu znajdują się na zakładce Zdarzenie we właściwościach. Nazwy zdarzeń i powiązanych z nimi właściwości mogą rodzić pewne wątpliwości. Zdarzenie to zawsze operacja (np. zdarzenie kliknięcia — Click), natomiast właściwość zdarzenia to OnClick lub Przy kliknięciu. Jest to prawie to samo, jednak w kontekście technicznym zdarzenie (np. Click lub Open) to operacja obsługiwana przez obiekt Accessa (np. formularz lub przycisk polecenia), a właściwość zdarzenia (OnClick lub Przy kliknięciu) służy do dołączania zdarzeń do obiektów.
Makra a bezpieczeństwo Makro „Witaj, świecie” utworzone w poprzednim podrozdziale w obecnej postaci jest nieszkodliwe. Jednak niektóre makra są niebezpieczne. Za pomocą makra można wykonać niemal dowolną operację, jaką można uruchomić w Accessie za pomocą interfejsu użytkownika. Niektóre z takich operacji, np. uruchomienie kwerendy usuwającej, mogą prowadzić do utraty danych. Access ma wbudowane zabezpieczenia, które pomagają chronić użytkowników przed włączeniem niepożądanych, szkodliwych makr. Gdy uruchamiane są formularze, raporty, kwerendy, makra i kod VBA w aplikacji, Access za pomocą centrum zaufania ustala, które polecenia mogą być niebezpieczne i które z nich można wykonać. W centrum zaufania zarówno makra, jak i kod VBA są traktowane jako makra, którym domyślnie nie należy ufać. Niebezpieczne polecenia mogą pozwolić złośliwemu napastnikowi uzyskać dostęp do dysku twardego lub innych zasobów środowiska.
660
Część VI Podstawy programowania w Accessie
Napastnik może wtedy usunąć pliki z dysku, zmienić konfigurację komputera i wyrządzić inne szkody na komputerze, a nawet w środowisku sieciowym. Przy każdym otwarciu formularza, raportu lub innego obiektu Access sprawdza listę niebezpiecznych poleceń. Po napotkaniu takiego polecenia blokuje jego wykonanie. Aby nakazać Accessowi blokowanie potencjalnie szkodliwych instrukcji, trzeba włączyć tryb bezpieczny. Włączanie trybu bezpiecznego W trybie bezpiecznym Access może blokować niebezpieczne polecenia, gdy napotka je w trakcie uruchamiania formularzy, raportów, kwerend, makr, stron dostępu do danych i kodu w języku Visual Basic. Tryb ten można włączyć w następujący sposób: 1. Otwórz Accessa, kliknij przycisk Plik i wybierz Opcje. Pojawi się okno dialogowe Opcje programu Access. 2. Otwórz zakładkę Centrum zaufania, a następnie kliknij przycisk Ustawienia centrum zaufania. Pojawi się okno dialogowe Centrum zaufania. 3. Otwórz zakładkę Ustawienia makr (zobacz rysunek 22.6.).
Rysunek 22.6. Włączanie trybu bezpiecznego
4. Zaznacz opcję Wyłącz wszystkie makra bez powiadomienia lub Wyłącz wszystkie makr i wyświetl powiadomienie. 5. Ponownie uruchom Accessa, aby aktywować zmiany w zabezpieczeniach. W zakładce Ustawienia makr dostępne są cztery poziomy zabezpieczeń:
Wyłącz wszystkie makra bez powiadomienia — wszystkie makra i kod VBA są wyłączane, a użytkownik nie otrzymuje powiadomienia o tym, że może je włączyć.
Wyłącz wszystkie makra i wyświetl powiadomienie — wszystkie makra i kod VBA są wyłączane, ale użytkownik otrzymuje powiadomienie o tym, że może je włączyć.
Wyłącz wszystkie makra oprócz makr podpisanych cyfrowo — dla podpisanych cyfrowo makr sprawdzany jest stan podpisu. Jeśli makro nie jest podpisane, pojawia
Rozdział 22. Korzystanie z makr programu Access
661
się komunikat, który pozwala użytkownikowi włączyć makro lub anulować otwieranie bazy danych.
Włącz wszystkie makra (niezalecane, może zostać uruchomiony niebezpieczny kod) — nie są sprawdzane podpisy cyfrowe makr i kodu VBA. Ponadto dla niepodpisanych makr nie jest wyświetlane ostrzeżenie.
Podpis cyfrowy (zawarty w certyfikacie cyfrowym) to zaszyfrowany plik dołączony do makra lub dokumentu. Stanowi potwierdzenie, że makro lub dokument pochodzą z zaufanego źródła. Podpisy cyfrowe zwykle stosowane są przez duże firmy, gotowe zainwestować w zakup podpisów cyfrowych i zarządzanie nimi. Ty lub dział informatyczny możecie uzyskać podpis cyfrowy od komercyjnej jednostki certyfikacyjnej, takiej jak VeriSign Inc. lub Thawte. Aby zapoznać się z informacjami na temat uzyskiwania podpisów cyfrowych, wpisz zapytanie „Microsoft root certificate program members” na stronie http://msdn.microsoft.com. Zwykle najlepszy jest tryb domyślny, czyli Wyłącz wszystkie makra i wyświetl powiadomienie. W trakcie tworzenia aplikacji i jej konserwowania kod i makra powinny być uruchamiane bez zakłócania pracy programisty wyświetlaniem okien dialogowych z prośbą o pozwolenie. W dalszej części opisujemy zaufane lokalizacje. Można umieścić tworzoną bazę danych w takiej lokalizacji, aby uniknąć konieczności zezwalania na wykonywanie niepodpisanego kodu, a jednocześnie zachować ochronę przed innymi otwieranymi bazami danych. Jeśli uzyskałeś podpis cyfrowy, możesz go użyć do podpisywania projektów Accessa: 1. Otwórz bazę danych Accessa, którą chcesz podpisać. Następnie otwórz dowolny moduł, aby uruchomić edytor kodu VBA. 2. Wybierz opcję Tools/Digital signature z menu edytora VBA. Pojawi się okno dialogowe Podpis cyfrowy (zobacz rysunek 22.7). Rysunek 22.7. Podpisywanie projektu Accessa
3. Kliknij przycisk Wybierz, aby wyświetlić okno dialogowe wybierania certyfikatu, i wybierz certyfikat z listy (zobacz rysunek 22.8). 4. Wybierz certyfikat, który chcesz dołączyć do projektu Accessa. 5. Kliknij przycisk OK, aby zamknąć okno dialogowe wybierania certyfikatu. Następnie ponownie kliknij przycisk OK, by zamknąć okno dialogowe Podpis cyfrowy i zapisać ustawienia zabezpieczeń.
662
Część VI Podstawy programowania w Accessie
Rysunek 22.8. Wybieranie certyfikatu cyfrowego
Projekt Accessa podpisuj dopiero po gruntownym przetestowaniu aplikacji, gdy nie planujesz wprowadzać w niej dalszych zmian. Modyfikacja kodu w projekcie powoduje unieważnienie podpisu cyfrowego.
Aby zapobiec wprowadzaniu nieuprawnionych zmian w kodzie projektu przez użytkowników, koniecznie zablokuj projekt i zastosuj do niego hasło.
Centrum zaufania W centrum zaufania znajdziesz ustawienia dotyczące zabezpieczeń i prywatności dla programu Microsoft Access. Zastępuje ono okno dialogowe Zabezpieczenia z wcześniejszych wersji Accessa. Aby otworzyć centrum zaufania, wybierz najpierw opcję Plik/Opcje. Pojawi się okno dialogowe Opcje programu Access. Otwórz zakładkę Centrum zaufania, a następnie kliknij przycisk Ustawienia Centrum zaufania. Poniżej opisano poszczególne sekcje i kontrolowane przez nie ustawienia:
Zaufani wydawcy — tu wyświetlona jest lista zaufanych wydawców dla pakietu Microsoft Office (są to wydawcy, dla których po napotkaniu potencjalnie niebezpiecznego makra kliknięto opcję akceptowania wszystkich udostępnianych przez nich dokumentów). Aby usunąć wydawcę z tej listy, zaznacz go, a następnie kliknij przycisk Usuń. Zaufani wydawcy muszą mieć poprawny podpis cyfrowy, którego ważność nie wygasła.
Zaufane lokalizacje — tu widoczna jest lista zaufanych lokalizacji na komputerze lub w sieci. W tej sekcji można dodawać, usuwać i modyfikować katalogi komputera, w których zawsze znajdują się zaufane pliki. Pliki z zaufanych lokalizacji są otwierane bez sprawdzania przez centrum zaufania. Można też nie zezwalać na podawanie zaufanych lokalizacji z sieci, a także wyłączyć wszystkie zaufane lokalizacje i akceptować tylko podpisane pliki.
Zaufane dokumenty — jeśli włączona jest opcja zaufanych dokumentów, nazwa danej aplikacji Accessa jest dodawana do specjalnego obszaru w rejestrze systemu komputera. Następnie aplikacja przy każdym uruchomieniu jest wykrywana jako zaufany dokument, dzięki czemu wszystkie makra, cały kod i inne elementy aplikacji są uruchamiane bez zakłócania pracy użytkowników.
Rozdział 22. Korzystanie z makr programu Access
663
Dodatki — tu można określić, jak Access ma obsługiwać dodatki. Możesz wybrać, czy dodatki mają być cyfrowo podpisane przez zaufane źródło i czy system ma wyświetlać komunikaty po wykryciu niepodpisanych dodatków. Można też wyłączyć wszystkie dodatki, co może zakłócić działanie aplikacji.
Ustawienia formantów ActiveX — tu można ustawić poziom zabezpieczeń dla formantów ActiveX.
Ustawienia makr — pozwala ustawić zabezpieczenia dla makr, które nie znajdują się w zaufanych lokalizacjach. Więcej informacji znajdziesz w poprzednim punkcie, we fragmencie poświęconym trybowi bezpiecznemu.
Pasek komunikatów — pozwala ustawić, czy Access ma wyświetlać pasek komunikatów z ostrzeżeniem o blokowaniu zawartości, czy ma nie pokazywać informacji na ten temat.
Opcje prywatności — tu można wybrać, w jaki sposób witryna pakietu Microsoft Office komunikuje się z komputerem. Możesz używać tej witryny do wyświetlania pomocy, wyświetlania wybranych odnośników w trakcie rozruchu lub pobierania plików w celu diagnozy problemów z systemem. Możesz też zapisać się do programu poprawy jakości obsługi klienta.
Makra z wieloma akcjami Prawdziwa moc makr kryje się w wykonywaniu wielu akcji przy jednym kliknięciu przycisku. Tworzenie makra, które uruchamia serię kwerend funkcjonalnych, jest lepsze niż uruchamianie każdej kwerendy funkcjonalnej w Okienku nawigacji. Możliwe jest bowiem pominięcie jednej z nich lub wywołanie ich w złej kolejności. Oto kolejny przykład. W pliku Rozdział22.accdb znajdują się dwie kwerendy usuwające, które kasują dane z dwóch tabel ― tblContacts_Backup oraz tblProducts_Backup ― oraz dwie kwerendy dołączające, które kopiują rekordy z tabel tblContacts oraz tblProducts do tabel z kopiami. Tabela 22.1 pokazuje akcje makra oraz jego argumenty znajdujące się w makrze mcrBackupContactsAndProducts (zobacz rysunek 22.9). Tabela 22.1. mcrBackupContactsAndProducts Akcja
Argument akcji
Ustawienie argumentu akcji
Klepsydra
Klepsydra włączona
Tak
UstawOstrzeżenia
Ostrzeżenia włączone
Nie
Echo
Echo włączone
Nie
Tekst paska stanu
Krok 1.: Kasowanie danych
Nazwa kwerendy
qryDeleteContactsBackup
Widok
Arkusz danych
Tryb danych
Edycja
Nazwa kwerendy
qryDeleteProductsBackup
OtwórzKwerdendę
OtwórzKwerdendę
664
Część VI Podstawy programowania w Accessie
Tabela 22.1. mcrBackupContactsAndProducts — ciąg dalszy Akcja
Argument akcji
Ustawienie argumentu akcji
Widok
Arkusz danych
Tryb danych
Edycja
Echo włączone
Nie
Tekst paska stanu
Krok 2.: Dołączanie danych
Nazwa kwerendy
qryAppendContactsBackup
Widok
Arkusz danych
Tryb danych
Edycja
Nazwa kwerendy
qryAppendProductsBackup
Widok
Arkusz danych
Tryb danych
Edycja
Echo włączone
Tak
Tekst paska stanu
UstawOstrzeżenia
Ostrzeżenia włączone
Tak
Klepsydra
Klepsydra włączona
Nie
OknoKomunikatu
Komunikat
Zarchiwizowano kontakty i produkty
Sygnalizuj dźwiękiem
Tak
Typ
Informacje
Tytuł
Archiwizacja zakończona
Echo
OtwórzKwerdendę
OtwórzKwerdendę
Echo
Jeżeli na liście rozwijanej Akcja nie pokazują się wszystkie akcje, należy kliknąć polecenie Pokaż wszystkie akcje, które znajduje się w grupie Pokazywanie/ukrywanie w zakładce PROJEKTOWANIE. Niektóre akcje wymagają utworzenia zaufanej bazy danych lub włączenia makr za pomocą opcji zabezpieczeń. Ponadto pewne akcje makr są uważane za niebezpieczne, ponieważ modyfikują dane w bazie lub wykonują operacje, które mogą wyrządzić szkody, jeśli będą niewłaściwie używane. Akcje makr uznawane za niebezpieczne są oznaczone w oknie projektowym makr ikoną ostrzeżenia (żółty trójkąt z wykrzyknikiem). Domyślnie Access pokazuje jedynie zaufane akcje makr, które uruchamiane są bez względu na poziom ustawień bezpieczeństwa.
Oto opis akcji, jakie to makro wykonuje:
Klepsydra — zmienia kursor na klepsydrę lub strzałkę za pomocą argumentu Klepsydra włączona. W przypadku makr, których wykonanie może chwilę potrwać, należy ustawić ten argument na Tak na początku makra i na Nie na jego końcu. Trzeba pamiętać o wyłączeniu klepsydry po zakończeniu pracy makra. W przeciwnym razie cały czas widoczny będzie kursor w postaci klepsydry.
Rozdział 22. Korzystanie z makr programu Access
665
Rysunek 22.9. Makro mcrBackup ContactsAndProducts archiwizuje dane z tabel roboczych do tabel kopii zapasowej
UstawOstrzeżenia — włącza lub wyłącza wiadomości systemowe, korzystając z argumentu Ostrzeżenia włączone. Podczas uruchamiania kwerend funkcjonalnych użytkownik zostanie poproszony o potwierdzenie, że system ma usunąć 58 rekordów, a następnie o potwierdzenie przy kolejnej kwerendzie funkcjonalnej. Należy ustawić wartość argumentu Ostrzeżenia włączone na Nie na początku makra, aby wyłączyć te komunikaty (zakładając, że i tak kliknęłoby się przycisk OK lub Tak w tych oknach). Na końcu makra należy ustawić ten argument ponownie na Tak. Także tu należy pamiętać o ponownym włączeniu ostrzeżeń po zakończeniu pracy makra. Gdy ostrzeżenia są wyłączone, Access nie wyświetla użytkownikom komunikatów z prośbą o potwierdzenie ważnych operacji (takich jak usuwanie rekordów).
Echo — na podstawie wartości argumentu Echo włączone pokazuje lub ukrywa wyniki makra podczas jego pracy. Należy ustawić ten argument na Nie, aby ukryć efekty działania makra, lub na Tak, aby je pokazać. Należy również ustawić argument Tekst paska stanu, aby dać użytkownikowi wskazówkę, co się dzieje. Jest to użyteczne rozwiązanie w przypadku makr, których wykonanie trwa dość długo, gdyż dzięki temu wiadomo, w którym miejscu proces makr aktualnie się znajduje. Akcja Echo blokuje ekran, dlatego użytkownik nie wie, jakie operacje wykonuje makro. Echo pod pewnymi względami przypomina akcje Klepsydra i UstawOstrzeżenie. Należy ustawić w nim wartość Tak, aby przywrócić
666
Część VI Podstawy programowania w Accessie
standardowy wygląd Accessa. Jeśli tego nie zrobisz, użytkownik może podejrzewać, że aplikacja zablokowała się z powodu problemów.
OtwórzKwerendę — jest to najważniejszy element makra mcrBackupContactsAnd Products. Otwiera kwerendę wybierającą, krzyżową lub funkcjonalną. Argument Nazwa kwerendy zawiera nazwę kwerendy do otwarcia lub uruchomienia. Argument Widok pozwala na wybór jednego z dostępnych widoków, w którym otwarta zostanie kwerenda wybierająca lub krzyżowa: Widok projektu, Widok arkusza danych, Podgląd wydruku, Widok tabeli przestawnej lub Widok wykresu przestawnego. Argument Tryb danych pozwala wybrać jedną z opcji: Dodawanie, Edycja lub Tylko do odczytu, aby określić, jakie czynności może wykonywać użytkownik w przypadku kwerendy wybierającej. W kwerendach funkcjonalnych opcje Widok oraz Tryb Danych nie są dostępne.
Sercem tego makra są cztery akcje OtwórzKwerendę, które wywołują cztery kwerendy funkcjonalne. Kwerendy qryDeleteContactsBackup oraz qryDeleteProductsBackup usuwają zawartość tabel tblContacts_Backup oraz tblProducts_Backup, dzięki czemu bieżące dane mogą zostać do nich skopiowane. Kwerendy qryAppendContactsBackup oraz qryAppend ProductsBackup dołączają dane z tabel tblContacts oraz tblProducts do tabel z kopią zapasową. Można by łatwo zbudować makro, używając jedynie czterech akcji OtwórzKwerendę, ale wykonywanie ich byłoby nieporęczne, szczególnie jeśli wykonanie jednej z kwerend zajmuje kilka minut lub godzin. Korzystanie z akcji Klepsydra, UstawOstrzeżenia, Echo oraz OknoKomunikatu pozwala wyeliminować potrzebę interakcji z użytkownikiem i poinformować go o tym, co się aktualnie dzieje.
Podmakra Podczas procesu automatyzacji aplikacji przy użyciu makr można łatwo zapełnić panel nawigacyjny makrami do otwierania każdego raportu i formularza. Jeśli trzeba wykonywać szereg akcji w różnych miejscach, najlepiej jest utworzyć tylko jedną wersję kodu, aby móc wprowadzać zmiany tylko w niej. Podmakra to umożliwiają. Wystarczy zdefiniować zbiór akcji w jednym miejscu jako podmakro, a następnie wywoływać je tam, gdzie jest potrzebne. W okienku nawigacji pojawia się tylko podmakro, a nie zestaw mniejszych makr. Na liście z akcjami makr znajduje się pozycja Podmakro. W trakcie pracy nad makrem wybierz opcję Podmakro z listy akcji. W makrze pojawi się wtedy obszar, w którym można wprowadzić akcje powiązane z podmakrem. Bez używania podmakr trzeba byłoby tworzyć trzy osobne makra do automatyzowania formularza menu głównego składającego się z trzech przycisków do otwierania formularzy frmContacts, frmProducts i frmSales. Korzystając z podmakr, wystarczy utworzyć jedno makro, które otwiera każdy formularz indywidualnie. Każde podmakro otwiera jeden formularz, a w okienku nawigacji widoczne jest tylko główne makro. Tabela 22.2 pokazuje podmakra, akcje oraz ich argumenty dla makra mcrMainMenu.
Rozdział 22. Korzystanie z makr programu Access
667
Tabela 22.2. mcrMainMenu Podmakro
Akcja
Argumenty
Ustawienia argumentów
OpenContacts
OtwórzFormularz
Nazwa formularza
frmContacts
Widok
Formularz
Nazwa filtru
Warunek WHERE
Tryb danych
Tryb okna
Normalny
Nazwa formularza
frmProducts
Widok
Formularz
Nazwa filtru
Warunek WHERE
[ProductID]=3
Tryb danych
Tylko do odczytu
OpenProducts
OpenSales
OtwórzFormularz
OtwórzFormularz
Tryb okna
Okno dialogowe
Nazwa formularza
frmSales
Widok
Układ
Nazwa filtru
qrySales2012
Warunek WHERE
Tryb danych
Edycja
Tryb okna
Ikona
Na rysunku 22.10 pokazano tworzenie makra mcrMainMenu. Programista wybrał opcję Podmakro z listy Dodaj nową akcję, podał nazwę podmakra (OpenContacts) i określił jego właściwości. Rysunek 22.10. Dodawanie drugiego podmakra do makra
668
Część VI Podstawy programowania w Accessie Na liście rozwijanej Dodaj nową akcję znajduje się posortowana alfabetycznie lista dostępnych akcji. Jednak cztery pierwsze pozycje (Grupa, Jeżeli, Komentarz i Podmakro) znajdują się na początku listy, a nie w miejscu wyznaczonym przez porządek sortowania. Są to elementy sterowania przebiegiem programu, dlatego oddzielono je od pozycji reprezentujących akcje.
Następnie programista ponownie wybrał opcję Podmakro z listy Dodaj nową akcję. Tym razem nazwał podmakro OpenProducts. Na razie żadne argumenty drugiego podmakra nie są określone. Na rysunku 22.10 widoczne są dwie listy Dodaj nową akcję, co może mylić programistów. Jedna lista znajduje się na samym dole głównego makra, a druga — w drugim podmakrze. Rozwijane właśnie podmakro (OpenProducts) znajduje się w wyróżnionym polu, natomiast gotowe podmakro (OpenContacts) widoczne jest w górnej części głównego makra i nie ma ramki. Na rysunku 22.10 warto zwrócić uwagę na znak minus po lewej stronie podmakra w pierwszym wierszu makra. Znak ten informuje, że dane podmakro jest obecnie rozwinięte i można zobaczyć wszystkie operacje. Kliknięcie tego znaku powoduje zwinięcie makra do jednego wiersza. Pozwala to zobaczyć większą część makra i jego operacji. Na kilku rysunkach w tym rozdziale fragmenty makr są zwinięte (wskazuje na to mały znak plus po lewej stronie danego bloku), dlatego można odnieść wrażenie, że na zrzutach brakuje niektórych elementów makra.
Aby zaimplementować makro korzystające z podmakr, należy utworzyć formularz (frmMainMenu) z trzema przyciskami, w tym przypadku cmdContacts, cmdProducts, cmdSales. Następnie ustawić właściwość Przy kliknięciu dla tych trzech przycisków wedle wzoru (zobacz rysunek 22.11): Nazwa przycisku
Właściwość Przy kliknięciu
cmdContacts
mcrMainMenu.OpenContacts
cmdProducts
mcrMainMenu.OpenProducts
cmdSales
mcrMainMenu.OpenSales
Rysunek 22.11. Nazwy podmakr pojawiają się po obiekcie makra we właściwościach zdarzenia wyświetlanych w liście rozwijanej
Rozdział 22. Korzystanie z makr programu Access
669
Po otwarciu formularza frmMainMenu w widoku formularza i kliknięciu przycisku Klienci otwarty zostanie formularz frmContacts wyświetlający wszystkie rekordy. Aby wyświetlić formularz frmProducts, należy kliknąć przycisk Produkty. Wyświetli on tylko jeden rekord. Kliknięcie przycisku Sprzedaż spowoduje wyświetlenie transakcji z 2012 roku. Aby zobaczyć, dlaczego formularze otwierają się w różny sposób, należy przyjrzeć się argumentom akcji o nazwie OtwórzFormularz:
Nazwa formularza — jest nazwą formularza, jaki ma być otwarty przez makro.
Widok — umożliwia wybór sposobu otwarcia formularza. Dostępne są następujące opcje: Formularz, Projekt, Podgląd wydruku, Arkusz danych, Tabela przestawna, Wykres przestawny oraz Układ. W tym przykładzie formularze frmContacts oraz frmProducts otwierają się w widoku Formularz, podczas gdy frmSales otwiera się w widoku Układ.
Nazwa filtru — umożliwia wybór kwerendy lub filtra zapisanego w formie kwerendy, aby ograniczyć i (lub) posortować rekordy formularza. W tym przykładzie argument dla makra OpenSales ustawiony jest na wartość qrySales2012. Kwerenda qrySales2012 wyświetla wiersze tabeli, w których pole daty sprzedaży zawiera daty między 01.01.2012 a 31.12.2012 roku. Kwerenda ta sortuje dane na podstawie pola SaleDate.
Warunek WHERE — umożliwia wprowadzenie SQL-owego wyrażenia WHERE, które powoduje pobranie rekordów do formularza z powiązanej tabeli lub kwerendy. Tu argument ten ustawiony jest dla makra OpenProducts i ma wartość [ProductID]=3, co oznacza, że przy otwarciu formularza frmProducts wyświetlony zostanie tylko jeden rekord.
Tryb danych — pozwala wybrać tryb danych formularza. Aby użytkownicy mogli jedynie dodawać nowe rekordy, należy wybrać opcję Dodawanie. Aby mogli dodawać i edytować rekordy, należy skorzystać z opcji Edycja. Natomiast opcja Tylko do odczytu ogranicza prawa użytkownika jedynie do przeglądania rekordów. Ustawienie to ma zastosowanie jedynie do formularza otwartego w widoku Formularz lub Arkusz danych i nadpisuje następujące ustawienia właściwości formularza: Edycja dozwolona, Usuwanie dozwolone, Dodawanie dozwolone oraz Wprowadzanie danych. W tym przykładzie formularz frmProducts otwiera się w trybie tylko do odczytu, a formularze frmContacts oraz frmSales pozwalają na edycję.
Tryb okna — umożliwia wybór trybu okna, w którym wyświetlony będzie formularz. Opcja Normalny używa właściwości formularza, Ukryty otwiera formularz z ustawieniem Widoczny na Nie. Opcja Ikona pozwala uruchomić zminimalizowany formularz, a Okno dialogowe otwiera formularz z ustawieniami Modalny i Podręczny ustawionymi na Tak oraz Styl linii na Okno dialogowe. W tym przykładzie formularz frmContacts otwiera się Normalnie, frmProducts otwiera się w Oknie dialogowym, a frmSales jest minimalizowany. Więcej informacji o właściwościach formularza znajduje się w rozdziale 17.
670
Część VI Podstawy programowania w Accessie
Kiedy uruchamia się makro z podmakrami z poziomu okienka nawigacyjnego, wykonywane jest tylko pierwsze podmakro.
Jeżeli makra zaplanuje się ostrożnie, można stworzyć jeden obiekt makra dla każdego formularza lub raportu oraz używać podmakr dla każdej akcji w formularzu lub raporcie, którą chce się przeprowadzić. Podmakra pozwalają ograniczyć liczbę makr pojawiających się w Okienku nawigacyjnym, a przez to znacznie upraszczają zarządzanie makrami.
Korzystanie z warunków Podmakra umożliwiają umieszczenie wielu grup akcji w pojedynczym obiekcie makra, natomiast warunek określa pewne okoliczności, które muszą zostać spełnione, by makro wykonało akcję. W Accessie 2007 i starszych wersjach dostępna była kolumna Warunek, w której można było wpisać dowolne wyrażenie o wartości Prawda lub Fałsz. W Accessie 2010 wprowadzono akcję makr Jeżeli, która zastępuje warunki. Akcja Jeżeli także przyjmuje wyrażenie logiczne. Jeżeli wyrażenie będzie miało wynik Fałsz, Nie lub 0 (zero), wówczas akcja nie będzie wywołana. Jeżeli jednak wyrażenie zakończy się jakimkolwiek innym wynikiem, to akcja zostanie przeprowadzona.
Otwieranie raportów za pomocą warunków Do zademonstrowania działania warunków i akcji Jeżeli posłuży formularz frmRaportMenu (zobacz rysunek 22.12), który składa się z trzech przycisków i ramki (fraView) z dwoma przyciskami opcji: Drukuj oraz Podgląd. Kliknięcie Drukuj ustawia wartość ramki na 1, a kliknięcie Podgląd na 2. Rysunek 22.12. Formularz frmRaportMenu używa ramki do wybierania, w jakim podglądzie maja być uruchomione raporty klientów, produktów oraz transakcji
Rozdział 22. Korzystanie z makr programu Access
671
Makro, które otwiera raporty, korzysta z podmakr oraz akcji Jeżeli. Tabela 22.3 pokazuje podmakra, warunki, akcje i argumenty akcji dla makra mcrReportMenu (zobacz rysunek 22.13), które otwiera jeden z trzech raportów. Pola Nazwa filtru i Warunek WHERE pozostawione są puste dla każdej akcji omawianego makra. Tabela 22.3. mcrMenuRaportu Nazwa makra
Warunek akcji Jeżeli
Akcja
Argument akcji
Ustawienie argumentu akcji
OpenContacts
[Formularze]![frm ReportMenu]! [fraView]=1
OtwórzRaport
Nazwa raportu
rptContacts _Landscape
Widok
Wydruk
Tryb okna
Normalny
Nazwa raportu
rptContacts _Landscape
Widok
Podgląd wydruku
Tryb okna
Normalny
Nazwa raportu
rptProducts
Widok
Wydruk
Tryb okna
Normalny
Nazwa raportu
rptProducts
Widok
Podgląd wydruku
Tryb okna
Normalny
Nazwa raportu
rptSales_Portrait
Widok
Wydruk
Tryb okna
Normalny
Nazwa raportu
rptSales_Portrait
Widok
Podgląd wydruku
Tryb okna
Normalny
[Formularze]![ frm ReportMenu]! [ fraView]=2
OpenProducts
[Formularze]![ frm ReportMenu]! [ fraView]=1
[Formularze]![ frm ReportMenu]! [ fraView]=2
OpenSales
[Formularze]![ frm ReportMenu]! [ fraView]=1
[Formularze]![ frm ReportMenu]! [ fraView]=2
OtwórzRaport
OtwórzRaport
OtwórzRaport
OtwórzRaport
OtwórzRaport
672
Część VI Podstawy programowania w Accessie
Rysunek 22.13. Makro mcrReportMenu używa akcji Jeżeli do otwierania określonego raportu w widoku wydruku lub podglądzie wydruku
Aby zaimplementować to makro, należy ustawić w sposób następujący zdarzenie Przy kliknięciu we właściwościach przycisków (cmdContacts, cmdProducts, cmdSales) w formularzu frmReportMenu: Nazwa przycisku
Właściwość Przy kliknięciu
cmdContacts
mcrReportMenu.OpenContacts
cmdProducts
mcrReportMenu.OpenProducts
cmdSales
mcrReportMenu.OpenSales
Akcja Jeżeli makra mcrReportMenu posiada dwa wyrażenia, które sprawdzają ramkę fraView formularza frmReportMenu, aby określić, czy zaznaczona jest opcja Drukuj, czy też Podgląd: [Formularze]![frmReportMenu]![fraView]=1:
Jeżeli wybrana jest opcja Drukuj na formularzu frmReportMenu, wywołana zostanie akcja OtwórzRaport z argumentem Wydruk. Jeżeli na formularzu wybrana jest opcja Podgląd, wówczas wykonywana jest akcja OtwórzRaport z argumentem Podgląd wydruku. Taka struktura ustawiona jest dla wszystkich nazw makr.
Wiele akcji w warunku Jeżeli zachodzi potrzeba uruchomienia wielu akcji w jednym warunku, należy dodać je pomiędzy instrukcjami Jeżeli wyrażenie i Koniec warunku „jeżeli”. Przedstawiono to na rysunku 22.14.
Rozdział 22. Korzystanie z makr programu Access
673
Rysunek 22.14. Zbiór akcji między instrukcjami Jeżeli wyrażenie i Koniec warunku „jeżeli” jest wykonywany jako grupa
Akcja Jeżeli umożliwia wybiórcze uruchamianie akcji opartych na innych wartościach w danej aplikacji. W akcji Jeżeli można na podstawie formantów z formularzy lub raportów albo innych obiektów ustalać, które operacje należy wykonać.
Korzystanie ze zmiennych tymczasowych W starszych wersjach Accessa używanie zmiennych było możliwe jedynie w kodzie VBA. Makra były ograniczone do wykonywania serii czynności bez pamiętania czegokolwiek z poprzedniej operacji. Od Accessa 2007 trzy nowe akcje makr ― UstawZmiennąTymczasową, UsuńZmiennąTymczasową, UsuńWszystkieZmienneTymczasowe ― pozwalają na używanie zmiennych tymczasowych w makrach. Zmienne te można wykorzystać w wyrażeniach warunkowych, aby kontrolować, które czynności będą wykonywane, lub do przekazywania danych do i z formularzy oraz raportów. Można nawet uzyskać dostęp do tych zmiennych z poziomu języka VBA, aby przekazywać dane do i z modułów.
Rozszerzanie utworzonego makra Prostym sposobem na zademonstrowanie, jak w makrach korzystać ze zmiennych, jest rozszerzenie przykładowego makra „Witaj, świecie” stworzonego wcześniej w tym rozdziale (w punkcie „Tworzenie makr”). Tabela 22.4 pokazuje akcje makra i ich argumenty dla makra mcrHelloWorldEnhanced (które pokazane jest na rysunku 22.15). Tabela 22.4. Makro mcrHelloWorldEnhanced Akcja
Argument akcji
UstawZmiennąTymczasową Nazwa
OknoKomunikatu
Ustawienia argumentu akcji MyName
Wyrażenie
InputBox("Podaj swoje imię.")
Komunikat
="Witaj " & [ZmienneTymczasowe]![ MyName] & "."
Sygnalizuj dźwiękiem
Tak
Typ
Informacje
Tytuł
Korzystanie ze zmiennych
UsuńZmiennąTymczasową Nazwa
MyName
674
Część VI Podstawy programowania w Accessie
Rysunek 22.15. Makro mcrHelloWorld Enhanced korzysta z akcji UstawZmiennąTymczasową, aby pobrać wartość od użytkownika i wyświetlić ją w oknie komunikatu
Akcja UstawZmiennąTymczasową posiada dwa argumenty: Nazwa i Wyrażenie. Argument Nazwa (tu jest to MyName) jest po prostu nazwą zmiennej tymczasowej. Argument Wyrażenie jest określeniem tego, jaka ma być wartość zmiennej. W tym przykładzie funkcja InputBox() pyta użytkownika o imię. Argument Komunikat akcji OknoKomunikatu zawiera następujące wyrażenie: ="Witaj " & [ZmienneTymczasowe]![MyName] & "."
Wyrażenie to łączy wyraz „Witaj” z tymczasową zmienną MyName, stworzoną w akcji UstawZmiennąTymczasową makra. Kiedy wartość przekazuje się do zmiennej tymczasowej za pomocą akcji UstawZmiennąTymczasową, korzysta się z następującej składni: [ZmienneTymczasowe]![NazwaZmiennej]
Więcej informacji dotyczących łączenia łańcuchów przy użyciu ampersandu (&) znajduje się w rozdziale 9.
Akcja UsuńZmiennąTymczasową usuwa pojedynczą zmienną tymczasową z pamięci (tu jest to zmienna MyName). Jednocześnie zdefiniowanych może być tylko 255 zmiennych tymczasowych. Zmienne te pozostają w pamięci do momentu zamknięcia bazy danych, chyba że zostaną usunięte z pamięci za pomocą akcji UsuńZmiennąTymczasową lub UsuńWszystkieZmienneTymczasowe. Dobrą praktyką jest usuwanie zmiennych tymczasowych, kiedy już skończy się z nich korzystać. Korzystanie z akcji UsuńWszystkieZmienneTymczasowe powoduje usunięcie wszystkich zmiennych tymczasowych stworzonych za pomocą akcji UstawZmiennąTymczasową. Jeżeli nie ma się całkowitej pewności, lepiej używać akcji UsuńZmiennąTymczasową.
Zmienne tymczasowe są zmiennymi globalnymi. Po utworzeniu zmiennej tymczasowej można ją wykorzystać w procedurach VBA, kwerendach, makrach lub właściwościach obiektów. Na przykład jeżeli z makra mcrHelloWorldEnhanced usunięta zostanie akcja
Rozdział 22. Korzystanie z makr programu Access
675
UsuńZmiennąTymczasową, można utworzyć pole tekstowe na formularzu i ustawić jego właściwość Źródło formantu w sposób pokazany poniżej, aby wyświetlić wprowadzone imię: [ZmienneTymczasowe]![MyName]
Upraszczanie makr za pomocą zmiennych tymczasowych Korzystanie ze zmiennych tymczasowych pozwala na wyeliminowanie z makra niektórych kroków. Można pobrać nazwę formularza lub raportu z innej kontrolki na formularzu. Za pomocą zmiennej tymczasowej można wyeliminować konieczność tworzenia wielu akcji OtwórzFormularz lub OtwórzRaport. Można również używać więcej niż jednej zmiennej w makrze. W tym przykładzie używane jest makro mcrReportMenuEnhanced (zobacz rysunek 22.16), które zawiera taką samą ramkę fraView, jaka widoczna była na rysunku 22.12, ale dodatkowo zawiera pole kombi (cboRaport) z listą raportów do uruchomienia. Przycisk Uruchom raport wywołuje makro mcrReportMenuEnhanced, które nie używa podmakr do decydowania, który raport uruchomić. Rysunek 22.16. Formularz frmReportMenu Enhanced wykorzystuje pole kombi do decydowania, który raport otworzyć
W tabeli 22.5 znajdziesz warunki, akcje i ich argumenty używane w makrze mcrReportMenu Enhanced (zobacz rysunek 22.17), które otwiera jeden z trzech raportów.
Dwie pierwsze akcje UstawZmiennąTymczasową w makrze mcrReportMenuEnhanced ustawiają wartości zmiennych tymczasowych ReportName oraz ReportView z elementów cboRaport oraz fraView z formularza frmReportMenuEnhanced. Akcje OtwórzRaport używają zmiennych tymczasowych w kolumnie Warunek i dla argumentu ReportName. Przy korzystaniu ze zmiennych tymczasowych jako ustawień argumentu należy użyć znaku równości (=) przed wyrażeniem: =[ZmienneTymczasowe]![ReportName]
Nadal pozostały do omówienia dwie akcje OtwórzRaport. Pewne argumenty, takie jak Widok, nie pozwalają na korzystanie ze zmiennych tymczasowych w wyrażeniach. Ponieważ jedną ze zmiennych tymczasowych jest ustawienie podglądu wydruku, nadal trzeba skorzystać z kolumny Warunek, aby zdecydować, w którym widoku otworzyć raport. Dwie ostatnie akcje, czyli UsuńZmiennąTymczasową, kasują z pamięci zmienne tymczasowe ReportName oraz ReportView. Ze względu na to, że zmienne te prawdopodobnie nie będą używane w przyszłych aplikacjach, ważne jest, aby je usunąć.
Rysunek 22.17. Makro mcrReportMenu Enhanced korzysta ze zmiennych tymczasowych do otwarcia pożądanego raportu w widoku wydruku lub w podglądzie wydruku
Rozdział 22. Korzystanie z makr programu Access
677
Dzięki zmiennym tymczasowym w Accessie 2013 makra dają znacznie większe możliwości niż w wersjach wcześniejszych niż 2007. Można używać tych zmiennych do przechowywania wartości do późniejszego wykorzystania w makrze lub gdziekolwiek w aplikacji. Pamiętać należy jedynie o ograniczeniu dotyczącym tworzenia maksymalnie 255 zmiennych jednocześnie. Dlatego nie należy zapominać o usuwaniu z pamięci nieużywanych już zmiennych tymczasowych.
Korzystanie ze zmiennych tymczasowych w kodzie VBA Możesz rozpocząć korzystanie z makr, aby zautomatyzować aplikację, ale w miarę upływu czasu zaczniesz używać kodu VBA do automatyzacji i dodawania nowych funkcji do innych obszarów programu. Co zrobić ze zmiennymi tymczasowymi zastosowanymi już w makrach? Nie trzeba się ich pozbywać — takie zmienne można wykorzystać bezpośrednio w kodzie VBA. Aby uzyskać dostęp do zmiennej tymczasowej w kodzie VBA, należy użyć tej samej składni, co w makrach: X = [TempVars]![NazwaZmiennej]
Jeżeli nie używa się spacji w nazwach zmiennych, można pominąć nawiasy kwadratowe: X = TempVars!NazwaZmiennej
Taką samą składnię należy zastosować, by przypisać w kodzie VBA nową wartość do istniejącej zmiennej tymczasowej. Jedyna różnica polega na tym, że zmienna tymczasowa występuje wtedy po lewej stronie równania: TempVars!NazwaZmiennej = NowaWartość
Obiekt TempVars wykorzystuje się do tworzenia i usuwania zmiennych tymczasowych bezpośrednio w kodzie VBA. Obiekt ten posiada trzy metody: Add (dodaj), Remove (usuń) oraz RemoveAll (usuń wszystkie). Aby stworzyć nową zmienną tymczasową i ustawić jej wartość, należy wywołać metodę Add obiektu TempVars w następujący sposób: TempVars.Add "NazwaZmiennej", Wartość
Metody Remove obiektu TempVars używa się do usuwania pojedynczej zmiennej tymczasowej z pamięci: TempVars.Remove "NazwaZmiennej"
Przy dodawaniu lub usuwaniu zmiennych tymczasowych za pomocą kodu VBA należy pamiętać, by ich nazwy ująć w cudzysłów.
Aby usunąć z pamięci wszystkie zmienne tymczasowe, należy skorzystać z metody RemoveAll obiektu TempVars w następujący sposób: TempVars.RemoveAll
Dowolna utworzona zmienna VBA jest dostępna w makrach i na odwrót. Każda zmienna tymczasowa usunięta w kodzie VBA nie jest już dostępna w makrach i vice versa. Korzystanie ze zmiennych tymczasowych powoduje, że makra i kod VBA nie są już od siebie niezależne.
678
Część VI Podstawy programowania w Accessie
Obsługa błędów i debugowanie makr Jeśli w poprzednich wersjach Accessa w makrze wystąpił błąd, to następowało przerwanie jego wykonywania i użytkownik widział nieprzyjemne okno dialogowe (zobacz rysunek 22.18), które nie wyjaśniało, o co chodzi. Jeśli użytkownik nie znał dobrze Accessa, szybko stawał się niezadowolony z pracy z nim. Brak obsługi błędów w makrach jest jednym z głównych powodów, dla którego wielu programistów wybiera do automatyzacji aplikacji język VBA zamiast makr. Rysunek 22.18. Błędy w makrach powodują, że makro przerywa pracę
Powszechnym błędem, który jest łatwy do zademonstrowania, jest błąd dzielenia przez zero. W następnym przykładzie makro mcrDivision (zobacz rysunek 22.19) zawiera dwie zmienne tymczasowe o nazwach MyNum oraz MyDenom, które ustawiane są za pomocą funkcji InputBox() proszącej odpowiednio o licznik i mianownik. Akcja OknoKomunikatu pokazuje wynik działania [TempVars]![MyNum]/[TempVars]![MyDenom] w wyświetlanym oknie komunikatu, a akcje UsuńZmienneTymczasowe kasują zmienne z pamięci. Rysunek 22.19. Makro mcrDivision dzieli licznik przez mianownik i generuje błąd, jeżeli mianownik jest wartością zero
Rozdział 22. Korzystanie z makr programu Access
679
Uruchom makro i wpisz wartość 1 dla licznika i 2 dla mianownika. Makro się wykona i wyświetli komunikat: 1 podzielone przez 2 równa się 0,5. Uruchom makro ponownie i tym razem wprowadź 0 dla mianownika. Nastąpi dzielenie przez zero, a makro przestanie działać. Bez obsługi błędów obie akcje UsuńZmiennąTymczasową nie zadziałają i nie usuną zmiennych tymczasowych z pamięci. Jeżeli błąd wystąpi w innym makrze, na przykład w łańcuchu kwerend funkcjonalnych, wówczas żadna kwerenda po miejscu wystąpienia błędu się nie uruchomi. Dodanie obsługi błędów do makra pozwala na wybór tego, co ma nastąpić po wystąpieniu błędu podczas pracy makra.
Akcja PrzyBłędzie Akcja PrzyBłędzie pozwala na zdecydowanie, co ma nastąpić, jeżeli w makrze pojawi się błąd. Ta akcja posiada dwa argumenty: Przejdź do oraz Nazwa makra. Argument Przejdź do posiada trzy ustawienia, a argument Nazwa makra używany jest jedynie z jednym z tych trzech ustawień wedle poniższego opisu:
Następne — umożliwia zapisanie szczegółów błędu w obiekcie MacroError, ale nie zatrzymuje makra. Makro nadal się wykonuje i przechodzi do kolejnej akcji.
Nazwa makra — zatrzymuje aktualne makro i uruchamia makro o nazwie podanej w argumencie Nazwa makra akcji PrzyBłędzie.
Niepowodzenie — zatrzymuje bieżące makro i wyświetla komunikat błędu. Tak samo, jak gdyby nie było obsługi błędu.
Oto odpowiedniki tych ustawień w kodzie VBA: On Error Resume Next On Error Goto NazwaEtykiety On Error Resume 0
'Następne 'Nazwa makra 'Niepowodzenie
Najprostszym sposobem na dodanie obsługi błędów do makra jest skorzystanie z akcji PrzyBłędzie i ustawienie argumentu Następne dla argumentu Przejdź do. Spowoduje to wykonanie makra bez zatrzymywania się, ale użytkownik nie wie wtedy, które akcje zostały wykonane, a które nie. Zamiast tego warto stworzyć strukturę obsługi błędów. Tabela 22.6 pokazuje nazwy makr, akcje oraz ich argumenty dla makra mcrDivisionErrorHandling (zobacz rysunek 22.20). Pierwsza akcja PrzyBłędzie pozwala Accessowi na przejście do podmakra o nazwie ErrorHandler w momencie, gdy wystąpi błąd. Jeżeli pojawi się błąd (po wprowadzeniu 0 w mianowniku), makro się zatrzyma i przejdzie do podmakra o nazwie ErrorHandler. Podmakro wyświetli okno komunikatu, używając obiektu MacroError (opisanego w kolejnej części), aby pokazać opis błędu w komunikacie i jego numer w tytule przy użyciu następujących wyrażeń: [MacroError].[Description] [MacroError].[Number]
680
Część VI Podstawy programowania w Accessie
Tabela 22.6. Makro mcrDivisionErrorHandling Nazwa makra Akcja PrzyBłędzie UstawZmienną Tymczasową UstawZmienną Tymczasową
OknoKomunikatu
ErrorHandler
Argument akcji
Ustawienie argumentu akcji
Przejdź do
Nazwa makra
Nazwa makra
ErrorHandler
Nazwa
MyNum
Wyrażenie
InputBox("Podaj licznik.")
Nazwa
MyDenom
Wyrażenie
InputBox("Podaj mianownik.")
Komunikat
=[ZmienneTymczasowe]![MyNum] & " podzielone przez " & [ZmienneTymczasowe] ![MyDenom] & "równa się " & [ZmienneTymczasowe]![MyNum]/ [ZmienneTymczasowe]![MyDenom]
Rysunek 22.20. Makro mcrDivision ErrorHandling wykorzystuje akcję PrzyBłędzie do wyświetlenia przyjaznego dla użytkownika komunikatu błędu i usunięcia zmiennych tymczasowych
Po wyświetleniu komunikatu akcja WyczyśćBłądMakra czyści obiekt MacroError. Akcja RunMacro uruchamia wywołanie podmakra o nazwie Cleanup. Część Cleanup makra powoduje wyczyszczenie zmiennych tymczasowych. W obsłudze błędów makr nie ma opcji przywracania. Jeżeli ktoś chce uruchomić dodatkowy kod po akcjach obsługi błędów, musi wykorzystać akcję UruchomMakro, aby uruchomić inne makro, lub umieścić potrzebne akcje w makrze obsługi błędu.
Akcja UruchomMakro wykonywana jest również po pojawieniu się komunikatu w głównej części makra. Ponieważ wykorzystano w tym miejscu podmakra, makro zatrzymuje się po dojściu do podmakra ErrorHandler. Aby wymusić usunięcie zmiennych tymczasowych, należy użyć akcji UruchomMakro, aby uruchomić podmakro o nazwie Cleanup. Inaczej trzeba będzie umieścić akcje UsuńZmienneTymczasowe w głównej sekcji i w sekcji ErrorHandler makra.
Obiekt MacroError Obiekt MacroError zawiera informacje o ostatnim błędzie makra, jaki wystąpił. Obiekt przechowuje tę informację, dopóki nie wystąpi nowy błąd, albo do momentu, gdy nie zostanie wywołana akcja WyczyśćBłądMakra. Obiekt ten zawiera pewną liczbę właściwości tylko do odczytu, do których można uzyskać dostęp z poziomu samego makra lub kodu VBA. Tymi właściwościami są:
Nazwa akcji — zawiera nazwę akcji makra, które było wykonywane w momencie pojawienia się błędu.
682
Część VI Podstawy programowania w Accessie
Argumenty — zawiera argumenty dla akcji makra, które było wykonywane w momencie pojawienia się błędu.
Warunek — zawiera warunek dla akcji makra, które było wykonywane w momencie pojawienia się błędu.
Opis — zawiera tekst reprezentujący bieżący komunikat błędu, np. Dzielenie przez zero lub Niezgodność typów.
Nazwa makra — zawiera nazwę makra, które było uruchomione, gdy nastąpił błąd.
Liczba — zawiera bieżący numer błędu, np. 11 lub 13.
Obiektu MacroError należy używać jako narzędzia do debugowania błędów lub do wyświetlania komunikatów dla użytkowników, którzy mogą później przekazać tę informację do autora aplikacji. Można nawet zapisać te właściwości w tabeli, aby śledzić błędy występujące w danym makrze. Obiekt ten w akcji Jeżeli służy do określania na podstawie błędu, które akcje należy wykonywać. Jeśli obiekt używany jest w połączeniu z akcją PrzyBłędzie, daje autorowi makra dodatkową możliwość obsługi błędów, wyświetlania użytecznych komunikatów i przekazywania informacji autorowi i użytkownikom.
Debugowanie makr Próba dojścia do tego, co się dzieje w makrze, może być trudna. Akcja PrzyBłędzie i obiekt MacroError ułatwiają debugowanie makr w porównaniu z poprzednimi wersjami Accessa. Istnieją też inne narzędzia i techniki użyteczne przy debugowaniu makr. Warto zapoznać się z następującą listą, będącą przewodnikiem po rozwiązywaniu problemów z makrem.
Pojedynczy krok — kliknij polecenie Pojedynczy krok znajdujące się w grupie Narzędzia na wstążce NARZĘDZIA MAKR PROJEKTOWANIE, aby włączyć makro w trybie wykonywania krok po kroku. Okno dialogowe Praca krokowa makra (zobacz rysunek 22.21) pozwala na podejrzenie nazwy makra, warunku, nazwy akcji, argumentów i numeru błędu przed wykonaniem akcji. W tym oknie dialogowym kliknij przycisk Krok, aby wykonać akcję, przycisk Zatrzymaj wszystkie makra, by zatrzymać wykonywanie makra, lub Kontynuuj, aby zakończyć działanie makra z wyłączonym trybem krok po kroku.
Rysunek 22.21. Okno dialogowe Praca krokowa makra służy do wykonania makra krok po kroku
Rozdział 22. Korzystanie z makr programu Access
683
OknoKomunikatu — akcja ta może być wykorzystana do wyświetlenia wartości zmiennych, komunikatów błędów, ustawień kontrolnych i wszystkich innych rzeczy, które ktoś może chcieć obejrzeć, gdy makro jest uruchomione. Aby zobaczyć wartość pola kombi na formularzu przy uruchomionym makrze, należy ustawić argument Komunikat w następujący sposób: [Formularze]![frmReportMenuEnhanced]![cboRaport]
ZatrzymajMakro — akcję tę można wykorzystana do zatrzymania wykonywania makra. Powinna się ona znaleźć w miejscu, w którym makro ma się zatrzymać. Warto używać tego narzędzia wraz z oknem debugowania, aby sprawdzać wartości.
Okno debugowania — używa się go do podglądu dowolnych wartości, zmiennych tymczasowych lub właściwości obiektu MacroError po zatrzymaniu makra. Wciśnięcie Ctrl+G powoduje wyświetlenie okna kodu po zatrzymaniu makra. Wystarczy wpisać znak zapytania (?) i zmienną lub wyrażenie, jakie chce się sprawdzić, i nacisnąć Enter. Oto przykładowe wyrażenia, które można wyświetlić w oknie debugowania: ? ZmienneTymczasowe!MyNum ? MacroError!Description ? [Formularze]![frmReportMenuEnhanced]![cboRaport]
Techniki te są podobne do technik znanych z debugowania kodu VBA. Można przechodzić przez fragment kodu, zatrzymywać kod, sprawdzać wartości w oknie debugowania i wyświetlać okna komunikatów, aby zbadać zmienne lub błędy, które wystąpiły. To prawda, że niektóre narzędzia są niedostępne (np. nie można podglądać wartości zmiennych i używać instrukcji Debug.Print), jednak można korzystać z nowego obiektu MacroError, który obejmuje informacje potrzebne do ustalenia, co poszło nie tak. Więcej informacji o obsłudze błędów i debugowaniu kodu VBA znajdziesz w rozdziale 26.
Makra osadzone Makro osadzone przechowywane jest we właściwościach zdarzenia i jest częścią obiektu, do którego jest przypisane. Przy modyfikowaniu makra osadzonego nie trzeba martwić się o inne formanty, które mogą korzystać z makra. Każde makro osadzone jest niezależne. Makra osadzone nie są widoczne w Okienku nawigacji i dostępne są jedynie z poziomu okna Właściwości. Załóżmy, że chcesz dodać do formularza przycisk polecenia, który otwiera raport. Do wyświetlania raportu można wykorzystać makro globalne (widoczne w okienku nawigacji) lub makro osadzone powiązane z przyciskiem polecenia. Makra osadzone są makrami zaufanymi. Są uruchamiane, nawet jeżeli ustawienia zabezpieczeń zapobiegają wykonywaniu kodu. Korzystanie z tych makr pozwala na udostępnianie aplikacji jako programów zaufanych, ponieważ są one automatycznie chronione przed wykonywaniem niebezpiecznych czynności.
684
Część VI Podstawy programowania w Accessie
Dużą zmianą, jaka zaszła w Accessie od wersji 2003 jest to, że kiedy korzysta się z kreatora tworzenia przycisku, kreator nie generuje już procedury zdarzenia. Zamiast tego tworzy makro osadzone. Jeżeli więc ktoś przyzwyczajony jest do uruchamiania kreatora i korzystania z wygenerowanego kodu VBA, będzie musiał zrezygnować z tej techniki. Wykorzystanie makr osadzonych zamiast kodu ma dwa skutki:
Umożliwia szybkie tworzenie aplikacji, którą można rozpowszechniać.
Pozwala użytkownikom, którzy nie potrafią programować w języku VBA, na modyfikowanie działania przycisków tworzonych za pomocą kreatora.
Aby utworzyć makro osadzone, które otwiera formularz frmContacts, wykonaj następujące czynności: 1. Kliknij zakładkę TWORZENIE na wstążce, a następnie kliknij polecenie Projekt formularza w grupie Formularze. 2. W zakładce NARZĘDZIA PROJEKTOWANIA FORMULARZY PROJEKTOWANIE wyłącz opcję Użyj kreatorów formantów, która znajduje się w grupie Formanty. W tym przykładzie nie będziesz używać kreatora do określania funkcji przycisku. 3. Kliknij ikonę Przycisk i umieść przycisk na formularzu. 4. Ustaw właściwość Nazwa przycisku na cmdContacts i Tytuł na Kontakty. 5. Wyświetl okno Właściwości dla przycisku cmdContacts, kliknij zakładkę Zdarzenie, a następnie kliknij właściwość Przy kliknięciu. 6. Kliknij przycisk konstruktora (przycisk z wielokropkiem). Pojawi się okno Wybieranie konstruktora (zobacz rysunek 22.22). 7. Wybierz polecenie Konstruktor makr i kliknij przycisk OK, aby wyświetlić okno makra (zobacz rysunek 22.23). 8. Dodaj akcję OtwórzFormularz do makra, a następnie ustaw argument Nazwa formularza na frmContacts. 9. Zamknij makro osadzone i kliknij przycisk OK, gdy poproszony zostaniesz o zapisanie zmian i aktualizację właściwości. Właściwość Przy kliknięciu przycisku cmdContacts ma teraz wartość [Makro osadzone]. Korzystanie z makr osadzonych ma pewne zalety w porównaniu z używaniem procedury zdarzenia napisanej w języku VBA. Jeżeli przycisk zostanie skopiowany i wklejony do innego formularza, makro osadzone zostanie przeniesione wraz z nim. Nie trzeba osobno kopiować i wklejać kodu. Analogicznie jeżeli wytnie się przycisk i wklei na tym samym formularzu (np. przenosząc do zakładki), nie trzeba ponownie podłączać do niego kodu. Makra osadzone mają jeszcze inne zalety w porównaniu z makrami z poprzednich wersji. Jeżeli automatyzuje się aplikację za pomocą makr osadzonych i importuje formularz lub raport z innej bazy danych (lub nawet kopiuje formant w obrębie tej samej bazy), nie trzeba martwić się o importowanie do bazy powiązanych makr. Przy korzystaniu z makr osadzonych cała kod automatyzacji przenoszony jest razem z formularzem lub raportem. To powoduje, że zarządzanie aplikacjami i ich budowanie jest łatwiejsze.
Rozdział 22. Korzystanie z makr programu Access
685
Rysunek 22.22. Przycisk konstruktora we właściwości zdarzenia służy do uruchomienia okna Wybieranie konstruktora, które pozwala stworzyć makro osadzone Rysunek 22.23. Makro osadzone nie posiada nazwy. Pasek tytułu wyświetla formant i zdarzenie, do którego makro jest przypisane
Makra kontra kod VBA W Accessie makra często są idealnym rozwiązaniem do wykonywania prostych zadań, takich jak uruchamianie raportów i formularzy. Przy korzystaniu z makr tworzenie aplikacji i przypisywanie do nich akcji odbywa się szybciej, gdyż argumenty akcji makra są wyświetlane na ekranie z makrem (w dolnej części okna makra). Nie trzeba pamiętać skomplikowanej lub trudnej składni.
686
Część VI Podstawy programowania w Accessie
Niektóre zadania, które można wykonać za pomocą kodu VBA, łatwiej wykonuje się za pomocą makr. Poniższe operacje są często wydajniejsze, gdy obsługiwane są przez makra:
Używanie makr na całym zbiorze rekordów z wykorzystaniem kwerend funkcjonalnych, np. do manipulowania wieloma rekordami w tabeli lub kilku tabelach (np. do uaktualniania wartości pól lub kasowania rekordów).
Otwieranie i zamykanie formularzy.
Uruchamianie raportów. Język VBA udostępnia obiekt DoCmd, który pozwala uruchomić wiele akcji makr. Obiekt ten na zapleczu uruchamia zadanie makra, aby osiągnąć ten sam efekt co samo makro. Możliwe jest na przykład zdefiniowanie polecenie DoCmd.Close, aby uruchomić akcję zamykania i zamknąć aktywny formularz.
Makra czy VBA? Chociaż makra czasami są lepszym rozwiązaniem, to w innych przypadkach wybieranym narzędziem jest język VBA. VBA to zwykle lepszy wybór, jeżeli chce się wykonać jedną z następujących czynności:
Utworzyć własne funkcje i ich użyć. Można tworzyć własne funkcje w kodzie VBA, a nie tylko korzystać z wbudowanych funkcji Accessa.
Wykorzystać automatyzację do komunikacji z innymi aplikacjami systemu Windows lub uruchamiania akcji na poziomie systemu. Można napisać kod, by przed wykonaniem jakiejś akcji sprawdzić, czy plik istnieje. Można też nawiązać komunikację z inną aplikacją systemu Windows (np. z arkuszem kalkulacyjnym) i przekazywać dane tam i z powrotem.
Korzystać z funkcji zapisanych w zewnętrznych bibliotekach DLL. Makra nie pozwalają na wywoływanie funkcji zawartych w innych bibliotekach DLL systemu Windows.
Pracować z pojedynczymi rekordami. Jeżeli zachodzi potrzeba przejrzenia rekordów lub przeniesienia wartości z rekordu do zmiennej, aby nimi manipulować, to rozwiązaniem jest kod.
Tworzyć lub zmieniać obiekty. W większości przypadków najłatwiej jest tworzyć obiekty i nimi manipulować przy użyciu widoku projektu. W niektórych sytuacjach można jednak chcieć zmienić definicję obiektu przy użyciu kodu. Za pomocą kodu VBA można manipulować praktycznie dowolnymi obiektami w bazie danych, w tym samą bazą danych.
Wyświetlić wskaźnik postępu na pasku stanu. Jeżeli zachodzi potrzeba wyświetlania wskaźnika postępu, to rozwiązaniem jest kod VBA. W Accessie 2013 znajduje się nowy typ baz danych używany tylko w programie SharePoint. W takich internetowych bazach danych w formularzach i raportach trzeba używać makr zamiast kodu w języku VBA.
Rozdział 22. Korzystanie z makr programu Access
687
Konwersja istniejących makr na kod VBA Po oswojeniu się z pisaniem kodu VBA można zachcieć przepisać pewne makra aplikacji na procedury VBA. Gdy przystąpisz do pracy i zaczniesz analizować każde makro z różnych bibliotek makr, szybko zauważysz, jak bardzo wymagające jest to zadanie. Nie można po prostu wyciąć makra z okna makr i wkleić go do okna modułu. Dla każdego warunku, akcji i argumentu akcji w makrze trzeba przeanalizować zadanie, jakie ono realizuje, i następnie napisać analogiczny fragment kodu w procedurze VBA. Na szczęście Access udostępnia funkcję, która automatycznie zmienia makra na kod VBA. W grupie Narzędzia zakładki PROJEKTOWANIE na wstążce znajduje się przycisk Konwertuj makra na język Visual Basic. Opcja ta umożliwia przekonwertowanie w ciągu kilku sekund całej grupy makr na moduł. Na kod VBA można przekształcić automatycznie tylko makra widoczne w okienku nawigacji. Makra osadzone w formularzach i raportach trzeba przekształcać ręcznie.
Aby wypróbować proces konwersji, przekonwertuj makro mcrHelloWorldEnhanced z wcześniejszej części tego rozdziału. Postępuj zgodnie z następującym opisem: 1. Kliknij grupę Makra w okienku nawigacji. 2. Wybierz makro mcrHelloWorldEnhanced. 3. Kliknij przycisk Konwertuj makra na język Visual Basic na zakładce PROJEKTOWANIE. Pojawi się okno dialogowe Konwertuj makro (zobacz rysunek 22.24). Rysunek 22.24. Okno dialogowe Konwertuj makro
4. Zaznacz opcje, które obejmują obsługę błędów i komentarze makra, a następnie kliknij przycisk Konwertuj. Gdy konwersja dojdzie do końca, pojawi się edytor kodu VBA i okno komunikatu Konwersja zakończona!. 5. Kliknij przycisk OK, aby zamknąć okno komunikatu. 6. W edytorze VBA za pomocą menu View (lub kombinacji klawiszy Ctrl+R) otwórz okno Project Explorer i kliknij dwukrotnie moduł o nazwie Przekonwertowane makro — mcrHelloWorldEnhanced. Kod i okno Project Explorer przedstawia rysunek 22.25. Kiedy Edytor VBA otwarty zostaje do edycji nowego modułu, można zobaczyć procedurę stworzoną przez makro. Rysunek 22.25 pokazuje funkcję mcrHelloWorldEnhanced, którą Access utworzył na podstawie makra o tej samej nazwie. Na górze funkcji Access umieszcza cztery wiersze komentarza dotyczące nazwy funkcji. Po nich znajduje się polecenie Function. Access nazywa funkcje, korzystając z nazwy makra (mcrHelloWorldEnhanced).
688
Część VI Podstawy programowania w Accessie
Rysunek 22.25. Nowo skonwertowany moduł
Jeżeli podczas konwersji zaznaczy się opcję uwzględnienia obsługi błędów, Access automatycznie wprowadzi polecenie OnError w pierwszym wierszu kodu procedury. Mówi ono Accessowi, by ten przeszedł do innych poleceń, które wyświetlają odpowiedni komunikat i kończą pracę funkcji. Polecenie rozpoczynające się od TempVars.Add jest kodem, który Access wygenerował na podstawie makra. Każdy wiersz makra jest przekształcany na wiersz kodu VBA (z obiektem TempVars, metodą Beep i funkcją MsgBox). Jeżeli ktoś jest początkującym adeptem VBA i chce nauczyć się kodowania, dobrym punktem wyjścia jest konwersja makr na moduły. Warto po prostu zapisać makra jako moduły i następnie przeanalizować utworzony kod VBA, aby zapoznać się z jego składnią. Z uwagi na nowe funkcje dostępne w makrach Accessa 2013 trudniej się zdecydować, czy używać makr, czy też języka VBA.
Rozdział 23.
Podstawy programowania w języku VBA W tym rozdziale:
Posługiwanie się językiem VBA
Przegląd pojęć związanych z językiem VBA
Wprowadzenie do pisania kodu w języku VBA
Tworzenie pierwszej procedury
Dodawanie instrukcji sterujących
Wprowadzenie do pętli
Wprowadzenie do obiektów i kolekcji
Przegląd edytora VBE
Większość programistów Accessa od czasu do czasu stosuje makra. Choć umożliwiają one szybkie i łatwe automatyzowanie aplikacji, najlepszym sposobem tworzenia programów jest tworzenie modułów z kodem w języku VBA. Język ten zapewnia dostęp do danych, umożliwia stosowanie pętli i instrukcji sterujących, a także posiada inne funkcje, które w makrach są nieobecne lub nie dają możliwości oczekiwanych przez programistów. Z tego rozdziału dowiesz się, jak za pomocą języka VBA zwiększyć możliwości i przydatność rozwijanych aplikacji. Z witryny poświęconej tej książce pobierz plik bazy danych Rozdział23.accdb.
690
Część VI Podstawy programowania w Accessie
Ograniczenia makr Z pewnych przyczyn w tej książce nie opisano zbyt szeroko tworzenia makr Accessa. Po pierwsze, jest wystarczająco dużo ważnych tematów, aby trzeba było wybierać, które z nich mają być omówione szczegółowo. Poza tym makr można dosyć łatwo nauczyć się samodzielnie i są one stosunkowo dobrze udokumentowane w pomocy internetowej Accessa. Istnieją jednak dwa obszary, w których makra trudno jest zastąpić. Dotyczy to makr danych w tabelach i osadzonych makr w formularzach i formantach. Możliwość osadzania makr w tabelach i formularzach sprawia, że są one znacznie przydatniejsze niż w wersjach wcześniejszych niż Access 2007. Jednak najważniejszą przyczyną rezygnacji z dokumentowania makr jest fakt, iż makr Accessa nie można wykorzystać nigdzie poza Accessem. Z kolei kod VBA można przenieść do Worda, Excela, Outlooka, Visio, a nawet (po wprowadzeniu pewnych zmian) do środowiska Visual Studio .NET. Nigdy nie wiadomo, gdzie ostatecznie używana będzie aplikacja Accessa. Takie aplikacje bardzo często przenosi się do bardziej zaawansowanych środowisk, takich jak SQL Server i Visual Studio .NET. Kod VBA z aplikacji Accessa można łatwo przekształcić na język Visual Basic .NET, a liczne procedury z Accessa można wykorzystać (po wprowadzeniu pewnych modyfikacji) w Wordzie lub Excelu. VBA to bardzo przenośny i użyteczny język, a jego znajomość przydaje się także w sytuacjach innych niż rozwijanie aplikacji Accessa. Nie oznacza to, że makra nie mają swojego miejsca w aplikacjach Accessa lub są gorsze od kodu VBA. Firma Microsoft ulepszyła makra w porównaniu z poprzednimi wersjami Accessa. W szczególności makra w wersji 2013 zawierają prosty mechanizm obsługi błędów (w większości polegający na przejściu do lokalizacji o określonej nazwie) oraz możliwość używania zmiennych. Są to istotne aktualizacje mechanizmu obsługi makr Accessa, choć w opinii wielu osób nie są na tyle poważne, aby uzasadniały używanie makr zamiast języka VBA w profesjonalnych aplikacjach.
Wprowadzenie do języka Visual Basic for Applications Visual Basic for Applications (VBA) to wbudowany język programowania w Accessie. VBA jest wykorzystywany we wszystkich aplikacjach pakietu Microsoft Office, w tym w Wordzie, Excelu, Outlooku, PowerPoincie, a nawet w Visio. Jeśli ktoś nie jest jeszcze programistą VBA, nauczenie się składni języka VBA oraz sposobów wiązania kodu VBA z modelem zdarzeń Accessa z całą pewnością przyczyni się do rozwoju jego kariery. VBA to bardzo ważny element w większości profesjonalnych aplikacji Accessa. Microsoft udostępnił obsługę VBA w Accessie, ponieważ język ten pozwala dodać do aplikacji bazodanowych Accessa rozbudowane możliwości. Bez kompletnego języka programowania (jakim jest VBA) w aplikacjach Accessa dostępny byłby tylko dość ograniczony zestaw operacji obsługiwanych w makrach Accessa. Choć makra także pozwalają dodać nowe możliwości do aplikacji Accessa, język VBA umożliwia znacznie łatwiejsze rozwijanie skomplikowanych funkcji zarządzania danymi i zaawansowanych mechanizmów interfejsu użytkownika. Więcej informacji na temat makr (m.in. o przekształcaniu makr na kod VBA) znajdziesz w rozdziale 22.
Rozdział 23. Podstawy programowania w języku VBA
691
Co to za nazwa? Wyrażenie „Visual Basic” jest źródłem nieustannego zamieszania dla osób pracujących z produktami Microsoftu. Firma Microsoft zastosowała nazwę Visual Basic do wielu różnych produktów i technologii. Przez ponad 10 lat sprzedawała niezależny produkt o nazwie Visual Basic. Pod wieloma względami był on porównywalny i konkurencyjny z systemem Microsoft Access. Visual Basic był wbudowany w Visual Studio od pierwszej wersji tego środowiska. W 1995 roku Microsoft dodał język programowania Visual Basic for Applications (VBA) do Accessa, Worda i Excela w produktach Microsoft Office (choć do Accessa 2000 język ten nosił nazwę Access Basic). Nazwę Visual Basic for Applications wybrano dlatego, że składnia tego języka jest identyczna w aplikacjach Access, Word i Excel. Chociaż język VBA wykorzystywany w produkcie Visual Basic .NET jest bardzo podobny do języka VBA używanego w Accessie, nie są one dokładnie takie same. Pewnych operacji, które można wykonać za pomocą języka VB .NET, nie można wykonać za pomocą języka VBA z Accessa i vice versa. W tej książce określenia „VBA” i „Visual Basic” odnoszą się do języka programowania wbudowanego w Accessie i nie należy ich mylić z produktem VB .NET firmy Microsoft.
Dla nowicjuszy w programowaniu ważne jest, aby nie ulegać frustracji z powodu pozornej złożoności języka VBA. Tak jak w przypadku każdej nowej umiejętności najlepiej zdobywać wiedzę o programowaniu w VBA krok po kroku. Jest bardzo istotne, aby dokładnie poznać możliwości tworzenia aplikacji w języku VBA, a także ogólną składnię języka, strukturę instrukcji oraz sposoby budowania procedur z jego wykorzystaniem. W tej książce zamieszczono mnóstwo przykładów użycia języka VBA do realizacji przydatnych zadań. Wszystkie procedury zamieszczone w tej książce szczegółowo przetestowano i sprawdzono pod kątem prawidłowego działania. Gdyby się okazało, że kod pochodzący z tej książki nie działa tak, jak powinien, należy dokładnie sprawdzić, czy wykorzystano go dokładnie w takiej postaci, w jakiej zaprezentowano go w tekście. Bardzo często najtrudniejsze problemy z implementacją technik programistycznych wynikają z prostych błędów, na przykład nieprawidłowej pisowni, brakującego przecinka lub brakujących nawiasów. Język programowania bardzo przypomina język naturalny. Ludzie posługują się słowami, zdaniami i akapitami do porozumiewania się ze sobą, a w języku programowania słowa, instrukcje i procedury służą do informowania komputera o tym, co ma zrobić. Podstawowa różnica między językami naturalnymi a komputerowymi polega na tym, że te ostatnie mają bardzo ścisły format. Każe słowo i zdanie musi być precyzyjnie skonstruowane, ponieważ komputer nie rozumie kontekstu i niuansów. Każde zadanie dla komputera musi być starannie zdefiniowane za pomocą składni języka programowania.
Terminologia związana z językiem VBA Przed przystąpieniem do omawiania języka VBA warto przedstawić podstawową terminologię związaną z tym językiem.
Słowo kluczowe — słowo o specjalnym znaczeniu w języku VBA. Na przykład w języku angielskim słowo now (teraz) oznacza moment w czasie. W języku VBA Now jest nazwą wbudowanej funkcji VBA, która zwraca bieżącą datę i godzinę.
Instrukcja — pojedyncze słowo w języku VBA lub kombinacja słów, które tworzą instrukcję do wykonania dla silnika języka VBA.
692
Część VI Podstawy programowania w Accessie
Procedura — zbiór instrukcji VBA pogrupowanych w celu wykonania określonego zadania. Można na przykład napisać procedurę, która pobiera dane z tabeli, łączy dane w określony sposób i wyświetla je w formularzu. Można również napisać trzy mniejsze procedury, z których każda wykonuje pojedynczy etap całego procesu. W języku VBA występują dwa rodzaje procedur — podprogramy i funkcje:
Podprogramy wykonują jedną operację i kończą działanie.
Funkcje wykonują zadanie, a następnie zwracają wartość (np. wynik obliczeń).
Przykład opisanej wcześniej procedury (pobierającej dane z tabeli) to w rzeczywistości podprogram. Wykonuje określone zadanie, po czym po prostu kończy pracę. Przykład, w którym operację podzielono na trzy mniejsze procedury, zawiera funkcję. W tym przypadku pierwsza procedura, która otwiera bazę danych i pobiera z niej dane, najprawdopodobniej zwraca dane w postaci zestawu rekordów, a następnie zestaw ten jest przekazywany do innych procedur, które łączą dane i je wyświetlają.
Moduł — procedury są zapisane w modułach. Jeśli instrukcje można porównać do zdań, a procedury do akapitów, moduły spełniają rolę rozdziałów lub dokumentów w języku VBA. Moduł zawiera pewną liczbę procedur oraz innych elementów połączonych w oddzielną jednostkę w aplikacji.
Zmienna — zrozumienie zmiennych bywa trudne. Ponieważ Access to narzędzie do projektowania baz danych, jest zrozumiałe, że w kodzie VBA muszą istnieć sposoby zarządzania danymi wykorzystywanymi w aplikacji. Zmienna nie jest niczym innym jak nazwą, której zadaniem jest reprezentowanie wartości danych. Niemal we wszystkich programach VBA tworzy się i wykorzystuje zmienne do przechowywania wartości takich jak nazwiska klientów, daty oraz wartości liczbowe przetwarzane za pomocą kodu VBA.
Właściwa definicja VBA to język. Tak jak każdy język naturalny VBA zawiera pewną liczbę słów, zdań i akapitów zorganizowanych w specyficzny sposób. Każde zdanie w języku VBA to instrukcja. Zbiór instrukcji tworzy procedurę, a procedury znajdują się w modułach. Funkcja to specyficzny typ procedury — takiej, która po uruchomieniu zwraca wartość. Na przykład Now() jest wbudowaną funkcją VBA, która zwraca bieżącą datę i godzinę z dokładnością do sekund. Z funkcji Now() można skorzystać w aplikacji wszędzie tam, gdzie trzeba odczytać bieżącą datę i godzinę, na przykład w celu przypisania wartości znacznika czasu do rekordu.
Wprowadzenie do pisania kodu w języku VBA Każda instrukcja w procedurze to polecenie, które Access ma wykonać. Istnieje dosłownie nieskończona liczba różnych instrukcji języka VBA, które mogą wystąpić w aplikacjach Accessa. Instrukcje języka VBA są stosunkowo czytelne i łatwe do zrozumienia. Najczęściej można zrozumieć ich znaczenie na podstawie słów kluczowych (np. DoCmd.OpenForm) i występujących w poleceniach referencji do obiektów bazodanowych.
Rozdział 23. Podstawy programowania w języku VBA
693
Każda instrukcja VBA to kod przetwarzany i wykonywany przez wbudowany w Accessa silnik języka VBA. Oto przykład typowej instrukcji VBA otwierającej formularz: DoCmd.OpenForm "frmMójFormularz", acNormal
Zauważ, że instrukcja ta obejmuje operację (OpenForm) i rzeczownik (frmMójFormularz). Większość instrukcji języka VBA zbudowanych jest w podobny sposób — z operacji i referencji (do obiektu, który wykonuje zadanie lub na którym wykonywana jest dana operacja). DoCmd to wbudowany obiekt Accessa, który umożliwia wykonywanie różnych zadań. Instrukcję DoCmd można porównać do niewielkiego robota wykonującego wiele różnych operacji. OpenForm występujące za słowem kluczowym DoCmd to zadanie, które ma wykonać obiekt DoCmd, natomiast frmMójFormularz to nazwa formularza, który ma zostać otwarty. Wreszcie acNormal to specyfikator, który informuje DoCmd, że formularz ma być otwarty w jego „normalnym” widoku. Jak łatwo wywnioskować, istnieją również inne tryby widoków, które można wykorzystać podczas otwierania formularza. Są to: tryb projektu (acDesign), tryb arkusza danych (acFormDS) oraz tryb podglądu wydruku (w przypadku raportów acPreview). Choć w tym i w dalszych rozdziałach znajdziesz tylko podstawy programowania w języku VBA, dowiesz się znacznie więcej, niż potrzebujesz, by dodawać zaawansowane funkcje do aplikacji Accessa. Zdobędziesz też solidne podstawy, które pomogą Ci stwierdzić, czy chcesz lepiej poznać ten ważny język programowania.
Tworzenie programów w języku VBA Access zawiera wiele przydatnych narzędzi umożliwiających pracę z tabelami, zapytaniami, formularzami i raportami bez potrzeby wpisywania choćby wiersza kodu. Tworząc coraz bardziej rozbudowane aplikacje, z pewnością będziesz chciał korzystać z coraz precyzyjniejszych metod sprawdzania poprawności wprowadzanych danych i obsługi błędów, czyniąc te aplikacje bardziej odpornymi na nieprawidłowe dane. Niektórych operacji nie da się wykonać z poziomu interfejsu użytkownika, nawet za pomocą makr. Może się zdarzyć, że projektując kolejną aplikację, pomyślisz: „Chciałbym mieć sposób na zrobienie tego” albo „Tu powinna być funkcja, która umożliwi realizację tej operacji”. Może także się zdarzyć, że w trakcie projektowania danej aplikacji będziesz kilkakrotnie wpisywał tę samą formułę lub wyrażenie w zapytaniu czy filtrze. Wówczas najprawdopodobniej pomyślisz: „Mam dość ciągłego wpisywania formuły w tym miejscu” albo „Znów wpisałem nieprawidłową formułę…”. W takich przypadkach pomocą staje się wydajny język programowania wysokiego poziomu, na przykład VBA. VBA jest nowoczesnym językiem strukturalnym zawierającym wiele struktur programistycznych dostępnych w większości języków programowania. Język można rozszerzać (poprzez wywoływanie standardowych procedur Windows API). VBA pozwala na współpracę z ADO (od ang. ActiveX Data Objects), DAO (od ang. Data Access Objects) i wszystkimi typami danych, które są dostępne w Accessie i VBA. Przed rozpoczęciem tworzenia własnych programów w języku VBA trzeba zapoznać się z jego środowiskiem opartym na zdarzeniach.
694
Część VI Podstawy programowania w Accessie
Moduły i procedury W tym punkcie zobaczysz, jak utworzyć bardzo prostą procedurę. Najpierw wykonasz operacje prowadzące do zbudowania procedury — utworzysz moduł, wprowadzisz instrukcje i uruchomisz procedurę. Dalej szczegółowo opisaliśmy wszystkie elementy procedury. Procedura tworzona w tym punkcie wyświetla liczbę podniesioną do kwadratu. Aby utworzyć procedurę SquareIt, wykonaj następujące czynności: 1. Otwórz zakładkę TWORZENIE na wstążce i kliknij przycisk Moduł. Otworzy się edytor VBE z pustym oknem kodu, co pokazano na rysunku 23.1. Rysunek 23.1. Przy tworzeniu modułu pojawia się puste okno kodu
2. W oknie kodu wprowadź następujące instrukcje: Sub SquareIt() Dim lNumber As Long lNumber = 2 MsgBox lNumber & " do kwadratu równa się " & lNumber ^ 2 End Sub
3. Umieść kursor w dowolnym miejscu wprowadzonego kodu i wybierz opcję Run Sub/Userform z menu Run. Powinno się pojawić okno komunikatu podobne do tego z rysunku 23.2.
Rysunek 23.2. Po uruchomieniu kodu pojawia się okno komunikatu
Rozdział 23. Podstawy programowania w języku VBA
695
4. Kliknij przycisk OK, aby zamknąć okno komunikatu i wrócić do edytora VBE. 5. Wybierz opcję File/Save i podaj nazwę modułu, gdy pojawi się prośba o jej wpisanie (zobacz rysunek 23.3).
Rysunek 23.3. Przy zapisywaniu bazy danych pojawi się pytanie o zachowanie niezapisanych modułów
Jeśli wykonałeś opisane czynności, właśnie utworzyłeś procedurę i ją uruchomiłeś. Gratulacje! W kilku następnych podpunktach szczegółowo opisaliśmy wszystkie wykonane kroki. Moduły Pierwszy z wykonanych wcześniej kroków polegał na utworzeniu nowego modułu. Moduły to kontenery na procedury. W przedstawionym przykładzie utworzony został moduł standardowy. Innym typem modułów są moduły klas. Moduły standardowe
Moduły standardowe są niezależne od innych obiektów Accessa (np. formularzy lub raportów). W takich modułach można przechowywać kod, który można potem wykorzystać w dowolnym miejscu aplikacji. Procedury zapisane w modułach standardowych często określa się jako globalne lub publiczne, ponieważ są dostępne z dowolnego miejsca w aplikacji Accessa. Procedury publiczne można wykorzystywać w aplikacji w wyrażeniach, makrach, procedurach obsługi zdarzeń i innym kodzie VBA. Aby skorzystać z procedury publicznej, wystarczy wywołać ją z kodu VBA w procedurze obsługi zdarzenia lub dowolnej innej procedurze w aplikacji.
696
Część VI Podstawy programowania w Accessie Procedury się uruchamia, moduły jedynie zawierają kod. Procedury są uruchamiane i wykonują określone działania. Natomiast moduły można traktować jak proste kontenery, w których grupuje się procedury i deklaracje. Modułu nie można uruchomić — uruchamiane są tylko poszczególne procedury, które znajdują się w module.
Moduły standardowe są zapisane w sekcji Moduły okienka nawigacji. Jak wyjaśniono wcześniej, moduły formularzy i raportów (opisane w następnym podpunkcie) są związane ze swoimi hostami. Dostęp do nich można uzyskać za pośrednictwem arkusza właściwości formularza lub raportu. Procedury warto grupować w ramach modułów. Na przykład wszystkie procedury przeznaczone do przekształcania danych w aplikacji należy zapisać w jednym module. Logiczne pogrupowanie procedur znacznie ułatwia zarządzanie nimi, ponieważ w aplikacji znajduje się jedno miejsce z wszystkimi procedurami wykonującymi określone zadanie. Ponadto większość modułów obejmuje powiązane ze sobą procedury. Podział powiązanych procedur na moduły czasem pozwala też przyspieszyć działanie aplikacji. W dodatku B opisaliśmy, jak uporządkować moduły, aby zoptymalizować szybkość aplikacji i zużycie pamięci. Moduły klas
Moduły drugiego rodzaju to moduły klas. Klasa określa działanie obiektu. Można tworzyć własne klasy (klasy niestandardowe), jednak najczęściej używa się modułów klas powiązanych z formularzami lub raportami. W przedstawionym przykładzie utworzony został standardowy moduł za pomocą wstążki. Moduły klas powiązane z formularzami lub raportami są generowane automatycznie przez Accessa przy dodawaniu kodu VBA do formularza lub raportu. Najważniejsza różnica między modułami standardowymi a modułami klas polega na tym, że moduły klas obsługują zdarzenia. Zdarzenia reagują na działania użytkowników i uruchamiają kod VBA z procedury obsługi zdarzenia. Więcej informacji o modułach i procedurach obsługi zdarzeń znajdziesz w rozdziale 25. Sekcje modułów
Może zauważyłeś, że w utworzonym module znajdował się już kod. W zależności od opcji środowiska Access może automatycznie wstawiać kod do nowych modułów. Obszar nad pierwszą procedurą w module to sekcja deklaracji. Umieszcza się w niej opcje i zmienne dotyczące wszystkich procedur z modułu. Dwie często stosowane opcje deklaracji to Option Compare Database i Option Explicit. Pierwsza określa, jak należy porównywać łańcuchy znaków ze sobą. Przy tym ustawieniu VBA stosuje tę samą metodę porównywania co baza danych. Inne dostępne opcje porównywania łańcuchów znaków to Option Compare Text i Option Compare Binary. Ustawienie Option Compare Text sprawia, że wielkość znaków nie jest brana pod uwagę (przy ustawieniu Option Compare Binary wielkość znaków jest istotna). W uproszczeniu można stwierdzić, że zazwyczaj najlepszą opcją jest Option Compare Database.
Rozdział 23. Podstawy programowania w języku VBA
697
Przy ustawieniu Option Explicit VBA ostrzega o stosowaniu niezadeklarowanych zmiennych. Ustawiając tę opcję, informujesz VBA, że zamierzasz bezpośrednio deklarować używane zmienne. Więcej o deklarowaniu zmiennych dowiesz się w dalszej części rozdziału. Cały kod pod sekcją deklaracji to sekcja procedur (inaczej sekcja kodu). To tu znajdują się podprogramy i funkcje modułu. Ważne jest, aby znać różnice między dwiema opisanymi sekcjami, ponieważ nie można umieszczać instrukcji z sekcji deklaracji w sekcji kodu i na odwrót. Gdy umieścisz instrukcje w nieodpowiednim miejscu, edytor VBE Cię o tym poinformuje. Procedury i funkcje Następny krok po utworzeniu przeznaczonego na procedurę modułu to utworzenie samej procedury. Tu utworzono bardzo prostą procedurę, która przeprowadza nieskomplikowane obliczenia matematyczne i wyświetla wynik. Każda instrukcja musi być zgodna ze składnią języka, co oznacza, że ważne są pisownia słów kluczowych i kolejność słów w instrukcji. Podprogramy
Podprogramy (procedury Sub) to najprostszy typ procedur w projektach VBA. Są one niczym więcej jak kontenerem na instrukcje VBA wykonujące takie zadania, jak otwieranie formularzy lub raportów albo uruchamianie kwerend. W podprogramach muszą występować dwie instrukcje: Sub nazwapodprogramu i End Sub. Gdyby były to jedyne instrukcje, podprogram byłby nieciekawy, ale poprawny. W przykładowym kodzie podprogram rozpoczyna się instrukcją Sub SquareIt() i kończy instrukcją End Sub. Przy określaniu nazwy procedury trzeba przestrzegać pewnych reguł. Najważniejsze dotyczą tego, że nazwa musi rozpoczynać się literą, większość znaków przestankowych jest niedozwolona, a maksymalna długość nazwy to 255 znaków. Ponadto należy stosować nazwy opisujące działanie procedury, tak aby można było je zrozumieć przy późniejszym przeglądaniu kodu. Trudno będzie domyślić się przeznaczenia procedury PobierzDane(), natomiast nazwa PobierzDaneZTabeliPracowników() jest oczywista. Lepiej nie dochodzić do limitu 255 znaków w nazwach procedur, jednak nie bój się tworzyć długich i opisowych nazw. Deklaracje zmiennych
Pierwsza instrukcja w prostym przykładowym podprogramie to deklaracja zmiennej. Rozpoczyna się od słowa Dim (od ang. dimension, czyli wymiar). Dalej znajduje się nazwa zmiennej lNumber. Nazwy zmiennych tworzy się według tych samych (opisanych w poprzednim podpunkcie) reguł co nazwy procedur. Po nazwie znajduje się słowo kluczowe As i typ danych. Tu zmienna lNumber jest typu Long. Dokładne omówienie zmiennych i typów danych znajdziesz w rozdziale 24.
698
Część VI Podstawy programowania w Accessie
Zmienne przechowują dane, które można później wykorzystać w procedurze. Gdy za pomocą słowa kluczowego Dim deklarujesz zmienną, informujesz VBA, że ma zarezerwować w pamięci komputera miejsce na zapisanie tych danych. Ilość rezerwowanej pamięci zależy od typu danych. Tu VBA ma zająć pamięć wystarczającą na zapisanie wartości typu Long (czyli 32 bity). Człon As datatype w deklaracji zmiennej jest opcjonalny. Zmienną lNumber można też zadeklarować w następujący sposób: Dim lNumber
Jeśli nie podasz typu danych, VBA określi go na podstawie wartości przypisanej do zmiennej. Może się wydawać, że to przydatne udogodnienie, jednak nie należy polegać na tym rozwiązaniu. VBA przypisuje typ danych do zmiennej przy pierwszym jej użyciu, jednak nie wie, jak zamierzasz z niej korzystać. Dlatego może zastosować typ danych za mały do potrzeb. Przypisywanie typów danych za pomocą języka VBA jest też wolniejsze niż określanie ich w kodzie. Jeśli dopiero poznajesz język VBA, nie zastanawiaj się zbyt długo przy wyborze typu danych zmiennej. Stosuj typ String dla tekstu, Long dla liczb bez części ułamkowej, Double dla liczb z częścią ułamkową i Boolean dla wartości typu prawda/fałsz. Te cztery typy danych dają bardzo duże możliwości. W trakcie uczenia się języka VBA będziesz mieć wiele okazji do poznania innych typów danych. Przypisywanie wartości do zmiennych
Gdy deklarujesz zmienną za pomocą instrukcji Dim, rezerwujesz w pamięci miejsce, gdzie można zapisać dane w celu ich późniejszego wykorzystania. Następny wiersz procedury zapisuje liczbę 2 w zmiennej lNumber. Oto jak wygląda ten wiersz w procedurze: lNumber = 2
Przypisywanie wartości do zmiennych jest łatwe. Trzeba pamiętać tylko o dwóch kwestiach:
Trzeba przypisać wartość odpowiednią dla typu danych zmiennej. Tu liczba bez części ułamkowej zapisywana jest w zmiennej typu Long. Jeśli spróbujesz zapisać dane niedostosowane do typu danych zmiennej, język VBA spróbuje przekształcić wartość na właściwy typ. Na przykład przy próbie zapisu wartości 8.26 w zmiennej typu Long VBA przekształci liczbę na 8 i usunie przy tym część ułamkową. Jeśli język VBA nie będzie mógł przekształcić danych, wystąpi błąd.
Nazwa zmiennej musi się znajdować po lewej stronie znaku równości, a przypisywana wartość — po prawej. Całe wyrażenie umieszczone na prawo od znaku równości jest obliczane przed przypisaniem do zmiennej. W przykładzie nie trzeba nic obliczać, ponieważ przypisywana jest liczba 2. Przyjrzyj się jednak innej instrukcji, która oblicza iloczyn dwóch wartości i przypisuje wynik do zmiennej: dProduct = 3 * 6.1
W tej instrukcji 3 jest mnożone przez 6.1, a wynik (18.3) zostaje przypisany do zmiennej. To prosty przykład. Teraz przyjrzyj się innej instrukcji: bIsEqual = dProduct = 18.3
Rozdział 23. Podstawy programowania w języku VBA
699
W tej instrukcji bIsEqual to zmienna typu Boolean, a dProduct to zmienna typu Double. W instrukcji występują dwa znaki równości. Pierwszy to operator przypisania, który ustawia wartość zmiennej. Pozostałe znaki równości (tu występuje tylko jeden dodatkowy znak tego rodzaju) to operatory porównywania. Zwracają one wartość True lub False. Jeśli zmienna dProduct ma wartość 18.3, w zmiennej bIsEqual zapisana zostanie wartość True. Najpierw obliczana jest wartość całego wyrażenia na prawo od pierwszego znaku równości (operatora przypisania), a następnie wynik zostaje przypisny do zmiennej. Funkcje
Funkcje są bardzo podobne do podprogramów, choć różnią się od nich jedną ważną cechą: zwracają wartość. Prostym przykładem jest wbudowana funkcja Now() języka VBA, która zwraca obecną datę i godzinę. Funkcję tę można wykorzystać w dowolnym miejscu aplikacji, w którym trzeba zastosować lub wyświetlić aktualną datę i godzinę. Funkcję Now() można zastosować na przykład w nagłówku lub stopce raportu, aby użytkownik wiedział, kiedy dokładnie wygenerowano dany raport. Now() to jedna z kilkuset wbudowanych funkcji języka VBA. W trakcie lektury tej książki przekonasz się, że wbudowane funkcje języka VBA pozwalają dodać przydatne i rozbudowane możliwości do rozwijanych aplikacji Accessa.
Oprócz funkcji wbudowanych można stosować funkcje niestandardowe, które wykonują zadania potrzebne w aplikacjach. Na przykład funkcja do przekształcania danych może wykonywać operacje matematyczne (takie jak przeliczanie walut lub określanie kosztów wysyłki) na wejściowych wartościach. Nie ma przy tym znaczenia, skąd pochodzą dane (z tabeli, formularza, kwerendy itd.). Funkcje niezależnie od miejsca ich wywołania zawsze zwracają poprawnie obliczoną wartość. W treści funkcji następuje przypisanie zwracanej wartości do nazwy funkcji (przyznajemy, że używanie nazwy funkcji w jej treści wygląda dość dziwnie). Zwracaną wartość można wykorzystać jako składnik bardziej złożonego wyrażenia. Poniżej przedstawiono funkcję, której zadaniem jest wyznaczenie pola powierzchni pokoju: Function SquareFeet(dHeight As Double, _ dWidth As Double) As Double ' Przypisanie wartości funkcji SquareFeet = dHeight * dWidth End Function
Pokazana funkcja pobiera dwa parametry (dHeight i dWidth). Zwróć uwagę, że do nazwy funkcji (SquareFeet) w treści funkcji przypisano wartość. Wartość zwracaną przez funkcję zadeklarowano jako typu Double, zatem interpreter języka VBA rozpoznaje ją jako liczbę typu Double. Najważniejszą rzeczą, jaką należy zapamiętać na temat funkcji, jest to, że zwracają one wartości. Zwracaną wartość często przypisuje się do zmiennej lub formantu w formularzu albo raporcie: dAnswer = SquareFeet(dHeight, dWidth) Me!txtAnswer = SquareFeet(dHeight, dWidth)
700
Część VI Podstawy programowania w Accessie
Jeśli funkcja (lub podprogram) potrzebuje danych (takich jak dHeight i dWidth w funkcji SquareFeet), należy je przekazać jako argumenty w nawiasach w deklaracji funkcji. Argumenty (nazywane też parametrami) zostały szczegółowo opisane w rozdziale 24.
Korzystanie z okna kodu Korzystanie z okna kodu jest bardzo nieustrukturyzowane w porównaniu z projektowaniem tabeli lub umieszczaniem formantów w sekcjach raportu. Kod VBA to zwykły tekst, dlatego dostępnych jest niewiele wizualnych wskazówek informujących o tym, jak pisać kod lub gdzie umieszczać poszczególne instrukcje. W tym punkcie opisaliśmy wybrane mechanizmy dostępne w oknie kodu i techniki pomagające porządkować kod i zapewniać jego czytelność. Odstępy Możliwe, że zwróciłeś uwagę na wcięcia i puste wiersze w kodzie przedstawionym w tym rozdziale. W kontekście programowania nazywa się je odstępami lub białymi znakami. Są to: spacje, znaki tabulacji i puste wiersze. Język VBA zwykle ignoruje odstępy (choć występują tu pewne wyjątki). Dla kompilatora języka VBA dwie poniższe procedury są identyczne: Function BMI(dPounds As Double, lHeight As Long) As Double BMI = dPounds / (lHeight ^ 2) * 703 End Function Function BMI(dPounds As Double, lHeight As Long) As Double BMI = dPounds / (lHeight ^ 2) * 703 End Functio
W pierwszej funkcji po instrukcji Function znajduje się jeden pusty wiersz, a przed instrukcją End Function — drugi. Ponadto przed pierwszą instrukcją w treści procedury dodano znak tabulacji. W drugiej funkcji wszystkie odstępy usunięto. Choć funkcje te różnią się wyglądem, kompilator języka VBA wczytuje je w ten sam sposób. Ponadto obie funkcje zwracają identyczne wyniki. W niektórych językach programowania odstępy są ważne i mają określone znaczenie. W języku VBA jest inaczej: odstępy mają tu zwiększać czytelność kodu. Programiści formatują pisany kod za pomocą odstępów w różny sposób. Niezależnie od tego, jaką konwencję przyjmiesz, ważne jest, aby stosować ją spójnie. Jednolite formatowanie pozwoli Ci łatwiej przeczytać i zrozumieć kod, gdy wrócisz do niego po miesiącach lub latach. Kontynuacja wiersza Okno edytora VBE można rozszerzyć na cały ekran. Czasem instrukcje są jednak tak długie, że nie mieszczą się nawet w oknie o maksymalnej szerokość. W języku VBA dostępny jest mechanizm kontynuowania wiersza w następnym. Gdy instrukcje są długie, pozwala to poprawić czytelność kodu. Symbol kontynuacji wiersza to spacja, po której następuje podkreślenie. Gdy kompilator języka VBA natrafi na spację i podkre-
Rozdział 23. Podstawy programowania w języku VBA
701
ślenie, wie, że następny wiersz jest kontynuacją bieżącego. Rysunek 23.4 przedstawia prostą procedurę z jedną bardzo długą instrukcją. Rozciąga się ona poza okno kodu, dlatego aby przeczytać całą instrukcję, trzeba przewinąć zawartość okna.
Rysunek 23.4. Długa instrukcja wykracza poza okno kodu
Za pomocą symboli kontynuacji wiersza można dzielić długie instrukcje na kilka wierszy. Dzięki temu można zobaczyć całe polecenie. Instrukcję z rysunku 23.4 można zapisać w następujący sposób: Function GetDatedFooter() As String GetDatedFooter = "Data wydrukowania raportu: " _ & Format(Now, "dd-mmm-yyyy") & _ ". Później wprowadzone zmiany nie są " & _ "odzwierciedlone w danych." End Function
Znakiem kontynuacji wiersza nazywane jest zwykle podkreślenie, jednak występująca przed nim spacja jest równie ważna. Do kontynuowania wiersza potrzebne są oba znaki — spacja i podkreślenie. Symboli kontynuacji wiersza nie można używać w środku łańcucha znaków. W przedstawionym przykładzie długi łańcuch znaków jest dzielony na cztery krótsze i złączany za pomocą ampersandów. Aby rozdzielić długi łańcuch znaków na kilka wierszy, trzeba go podzielić, co pozwala na dodanie symboli kontynuacji wiersza. Wiersze z wieloma instrukcjami Inny sposób na poprawę czytelności kodu polega na umieszczeniu dwóch lub więcej instrukcji w jednym wierszu. W VBA do rozdzielania instrukcji w jednym wierszu służy dwukropek. Jeśli wpisałeś wiele krótkich instrukcji, które zajmują dużo miejsca w pionie,
702
Część VI Podstawy programowania w Accessie
możesz umieścić kilka z nich w tym samym wierszu, aby zwiększyć przejrzystość kodu. Poniżej zgrupowano wiele podobnych instrukcji: i = 12: j = 45: k = 32 l = 87: m = 77: n = 2 o = 89: p = 64: q = 52
Tych dziewięć instrukcji przypisuje wartości do dziewięciu różnych zmiennych. Gdyby instrukcje zapisano jedna pod drugą, zajmowałyby dużo miejsca. Dzięki umieszczeniu w każdym wierszu trzech instrukcji ilość zajmowanego miejsca jest mniejsza. Technika ta jest przydatna przy stosowaniu krótkich instrukcji, które wykonują podobne zadania. Jeżeli instrukcje są długie lub różnią się od siebie, opisana metoda zmniejsza czytelność kodu, dlatego nie należy jej stosować. IntelliSense Załóżmy, że w tworzonym programie chcesz skorzystać ze znanego polecenia, ale nie pamiętasz jego składni. Access jest wyposażony w cztery mechanizmy IntelliSense ułatwiające pisanie poszczególnych wierszy kodu:
Uzupełnianie słów — gdy wpisujesz słowo kluczowe, możesz wcisnąć kombinację klawiszy Ctrl+Spacja, aby wyświetlić listę słów kluczowych. Lista ta jest automatycznie otwierana w miejscu, w którym znajduje się słowo kluczowe pasujące do wpisywanego. Jeśli do wpisanego tekstu pasuje tylko jedno słowo kluczowe, lista się nie pojawia — słowo zostaje wprowadzone automatycznie. Na rysunku 23.5 pokazano, co się dzieje po wpisaniu liter „do” i wciśnięciu kombinacji klawiszy Ctrl+Spacja.
Rysunek 23.5. Mechanizm uzupełniania słów wyświetla listę słów kluczowych
Gdybyś wpisał „doc” zamiast „do”, mechanizm zamiast wyświetlać listę słów kluczowych wstawiłby instrukcję DoCmd, ponieważ tylko ona zaczyna się od członu doc.
Auto List Members (automatyczne wyświetlanie składowych obiektu) — jest to rozwijana lista, która automatycznie wyświetla się po wpisaniu początku słowa kluczowego, z którym związane są obiekty, właściwości lub metody. Na przykład jeśli wpiszesz DoCmd.Open, na ekranie pojawi się lista możliwych instrukcji do wyboru (zobacz rysunek 23.6). Wystarczy przewinąć listę i wcisnąć Enter, aby wybrać pożądaną instrukcję.
Rozdział 23. Podstawy programowania w języku VBA
703
Rysunek 23.6. Pomoc w postaci automatycznej listy składowych w module
W pokazanym przykładzie wybrano metodę OpenForm (akcje związane z obiektami określa się terminem metody). Po wybraniu pozycji na liście wyświetli się kolejne okno z wykazami dalszych składowych. Jeśli z danym słowem kluczowym powiązane są parametry, pojawia się okno pomocy innego rodzaju — z automatycznym wyświetlaniem podpowiedzi (zobacz rysunek 23.7 i przeczytaj następny punkt).
Rysunek 23.7. Pomoc w postaci automatycznej podpowiedzi w module
Auto Quick Info (automatyczne wyświetlanie podpowiedzi) — wyświetla pomoc dotyczącą wszystkich opcji (nazywanych parametrami) określonego polecenia. Pogrubione słowo (FormName) to następny parametr dostępny dla obiektu DoCmd. Na rysunku 23.7 widać, że dla polecenia OpenForm dostępnych jest wiele parametrów. Parametry są rozdzielone przecinkami. W miarę wprowadzania kolejnych parametrów następny parametr jest wyróżniony pogrubieniem. Kolejność parametrów ma znaczenie. Ich zamiana może spowodować problemy. Aby ukryć automatyczną podpowiedź, należy wcisnąć klawisz Esc. W niektórych instrukcjach VBA nie trzeba podawać wszystkich parametrów. Parametry w nawiasach kwadratowych (np. View na rysunku 23.7) są opcjonalne. Access ustawia sensowne wartości domyślne dla wszystkich parametrów opcjonalnych, które pominięto w instrukcji.
Auto Constants (automatyczne wyświetlanie stałych) — lista rozwijana, która jest wyświetlana, gdy do parametru trzeba przypisać wbudowaną stałą. Na rysunku 23.7 w okienku podpowiedzi drugi parametr (View) jest opisany jako [View As
704
Część VI Podstawy programowania w Accessie acFormView = acNormal]. Nawiasy kwadratowe, w które ujęty jest parametr, oznaczają, że jest to parametr opcjonalny. Typ acFormView to grupa wbudowanych
stałych, które można przypisać do tego parametru. Jeśli pominiesz ten parametr, zastosowana zostanie stała domyślna, acNormal. Na rysunku 23.8 pokazano listę dostępnych stałych typu acFormView. Wystarczy wybrać jedną z nich i wpisać przecinek. Stała i przecinek pojawią się w instrukcji, po czym będzie można wprowadzić następny parametr.
Rysunek 23.8. Pomoc w postaci automatycznie wyświetlanych stałych Obszar okna kodu można podzielić na dwie niezależne części. Aby to zrobić, należy przeciągnąć pasek podziału w dół (pasek podziału to niewielka pozioma linia w górnej części pionowego paska przewijania wyświetlającego się z prawej strony okna kodu). Podział okna umożliwia pracę nad dwiema procedurami jednocześnie. Każdą część podzielonego okna kodu VBA można niezależnie przewijać. Zmiany wprowadzane w jednej części podzielonego okna wyświetlają się w drugiej. Aby przywrócić początkowy stan okna, kliknij dwukrotnie pasek podziału. Możesz też za pomocą myszy przeciągnąć pasek podziału w górę okna. Powoduje to zamknięcie drugiego obszaru. W aplikacjach Word i Excel dostępny jest podobny przycisk podziału. Pozwala on na bardzo łatwe edytowanie różnych części tego samego dokumentu Worda lub arkusza Excela.
Kompilacja procedur Po zakończeniu wpisywania kodu procedury należy ją skompilować, aby zakończyć proces tworzenia kodu. W trakcie kompilacji przypominająca składnię języka angielskiego składnia języka VBA jest przekształcana na łatwy do wykonania format binarny. Ponadto kod jest sprawdzany pod kątem błędów składni i innych usterek, które mogą powodować problemy w czasie korzystania z aplikacji przez użytkowników. Jeżeli nie skompilujesz aplikacji Accessa w trakcie jej rozwijania, Access zrobi to w momencie, gdy użytkownik otworzy dany program i zacznie z niego korzystać. W tej sytuacji błędy w kodzie mogą zniechęcić użytkownika do posługiwania się aplikacją. Jest to niekorzystne dla wszystkich zainteresowanych stron. Aby skompilować aplikację, skorzystaj z polecenia Debug/Compile w oknie Code. Jeśli proces kompilacji się nie powiedzie, na ekranie wyświetli się informacja o błędzie. Rysunek 23.9 przedstawia efekt kompilacji nieudanej z powodu literówki w nazwie zmiennej.
Rozdział 23. Podstawy programowania w języku VBA
705
Rysunek 23.9. Kompilator informuje o błędzie
Access kompiluje wszystkie procedury zawarte w danym module oraz wszystkie moduły w bazie danych, a nie tylko bieżącą procedurę i moduł.
Zapisywanie modułu Moduły różnią się od pozostałych obiektów Accessa tym, że nie istnieje sposób na bezpośrednie zapisanie modułu. Nowe moduły nie pojawiają się w okienku nawigacji do momentu ich zapisania. Moduły widoczne w okienku można dwukrotnie kliknąć, aby otworzyć w edytorze VBE. Moduły są zachowywane w momencie zapisywania bazy danych. Należy wtedy odpowiednio zareagować na komunikaty wyświetlane w Accessie. W edytorze VBE można zapisać bazę danych za pomocą polecenia File/Save. Pojawi się wtedy pytanie o zachowanie wszystkich niezapisanych modułów i obiektów. Nie pojawia się natomiast pytanie o zapisanie zachowanych modułów, nawet jeśli wprowadzono w nich zmiany. Moduły te są zapisywane pod podaną wcześniej nazwą. Moduły klas dołączone do formularza lub raportu są zachowywane w momencie zapisywania formularza lub raportu.
Konstrukcje sterujące języka VBA Jednym z najpotężniejszych elementów języka programowania są instrukcje umożliwiające podejmowanie przez program decyzji na podstawie określonych warunków. W języku VBA występują dwie grupy takich instrukcji: instrukcje warunkowe i pętle.
Instrukcje warunkowe Często decyzja o dalszym przebiegu programu jest podejmowana na podstawie wartości zmiennych. Jeśli warunek jest spełniony (wartość True), program wykonuje określone zadanie. Jeśli warunek nie jest spełniony (wartość False), program przechodzi do wykonania innego zadania. Możliwość analizy przez program wartości zmiennej i na tej podstawie podjęcia decyzji o dalszym jego przebiegu nazywana jest warunkowym wykonywaniem kodu. Wykonywanie kodu można sobie wyobrazić jak podążanie określoną ścieżką. Po dojściu do rozwidlenia można pójść w lewo lub w prawo. Załóżmy, że lewa ścieżka prowadzi do domu, a prawa do pracy. Jeśli wiesz, że masz iść do pracy, pójdziesz prawą ścieżką, jeśli jednak chcesz iść do domu — wybierzesz lewą. W podobny sposób program analizuje wartość zmiennej i decyduje, który zestaw instrukcji ma być wykonany.
706
Część VI Podstawy programowania w Accessie
W języku VBA są dwie grupy instrukcji warunkowych: If...Then...Else...End If Select Case...End Select
Słowo kluczowe If Słowo kluczowe If (w różnych postaciach) umożliwia sprawdzenie określonego warunku i na tej podstawie wykonanie określonego zadania. Warunek musi przyjąć jedną z dwóch wartości logicznych: True (prawda) lub False (fałsz). Jeśli warunek ma wartość True, program wykonuje kolejny wiersz procedury po instrukcji If. Jeśli warunek ma wartość False, następuje skok do bloku instrukcji znajdującego się po słowie kluczowym Else. Jeśli takiego bloku nie ma, program przechodzi do słowa kluczowego End If. Instrukcja If…Then
Instrukcja If ma kilka różnych wersji. Pierwsza z nich to If…Then. Jest to jednowierszowa instrukcja, w której warunek i akcja znajdują się w tym samym poleceniu. W poniższym kodzie zmienna sState jest ustawiana, jeśli w zmiennej sCity zapisano określone dane: If sCity = "Dallas" Then sState = "Texas"
VBA najpierw sprawdza wartość wyrażenia sCity = "Dallas" i na tej podstawie określa, czy warunek jest spełniony czy nie. Jeśli warunek jest spełniony (do sCity przypisana jest wartość Dallas), wykonywane są polecenia po słowie kluczowym Then (tu powoduje to przypisanie wartości Texas do zmiennej sState). Jeżeli warunek nie jest spełniony, program przechodzi do następnego wiersza w procedurze, a zmienna sState nie zmienia wartości. Instrukcja If…End If
Następną wersją jest instrukcja If…End If. Ta i dalsze postacie to tak zwane bloki If, ponieważ mogą zawierać kilka wierszy kodu (blok kodu), różnią się więc od instrukcji If…Then, która może wykonywać tylko jeden wiersz. Oto wcześniejszy przykład przekształcony na postać If…End If. If sCity = "Dallas" Then sState = "Texas" End If
Ten kod działa dokładnie tak samo jak wcześniejszy. Jeśli warunek jest spełniony, wykonywany jest (jedyny) wiersz w bloku If. Gdy warunek nie jest spełniony, program przechodzi bezpośrednio do wiersza po instrukcji End If i kontynuuje działanie. Zaletą wersji If…End If jest to, że pozwala wykonywać wiele instrukcji, gdy warunek jest spełniony. Jeśli w poniższym kodzie warunek ma wartość True, program przypisuje wartości do dwóch zmiennych: If sCity = "Dallas" Then sState = "Texas" dTaxRate = 0.075 End If
Rozdział 23. Podstawy programowania w języku VBA
707
Gdy warunek jest spełniony, wykonywane są obie instrukcje z bloku. W przeciwnym razie program przechodzi do wiersza pod instrukcją End If i kontynuuje działanie. Instrukcja If…Else…End If
We wcześniejszych przykładach, gdy warunek był spełniony, program wykonywał jedną lub więcej instrukcji. Jeśli warunek nie był spełniony, program przechodził dalej. W bloku If można umieścić słowo kluczowe Else, aby określić instrukcje wykonywane, gdy warunek nie jest spełniony: If sCity = "Dallas" Then sState = "Texas" dTaxRate = 0.075 Else sState = "Michigan" dTaxRate = 0.05 End If
Gdy warunek jest spełniony, wykonywane są dwie pierwsze instrukcje (zmienna sState jest ustawiana na Texas, a dTaxRate — na 0.075). Następnie program przechodzi do wiersza pod instrukcją End If i kontynuuje działanie. Dwa polecenia między Else a End If nie są wykonywane. Jeśli jednak warunek nie jest spełniony, program pomija dwa pierwsze polecenia i przechodzi do instrukcji pod Else. Jest to bardzo często stosowana technika — program wykonuje określone wiersze kodu, gdy warunek jest spełniony, a inne, jeśli warunek nie jest spełniony. Instrukcję Else można stosować tylko w bloku If. Nie działa ona w pierwszej wersji instrukcji If (w konstrukcji If…Then). Instrukcja If…ElseIf…End If
Ostatnia wersja instrukcji If także zawiera blok If. Jednak zamiast jednego warunku stosuje się tu ich kilka. Za pomocą instrukcji ElseIf można zdefiniować dowolną liczbę warunków. If sCity = "Dallas" Then sState = "Texas" dTaxRate = 0.075 ElseIf sCity = "Detroit" Then sState = "Michigan" dTaxRate = 0.05 Else sState = "Oregon" dTaxRate = 0.0625 End If
Program wykonuje instrukcję If…ElseIf…End If w podobny sposób jak inne wersje instrukcji If. Jeśli pierwszy warunek jest spełniony, wykonywane są instrukcje z pierwszego bloku, a następnie program przechodzi do wiersza pod End If. Jeżeli pierwszy warunek nie jest spełniony, program przechodzi do drugiego (pierwszej instrukcji ElseIf) i sprawdza go. Jeśli żaden z warunków nie jest spełniony, wykonywane są polecenia z sekcji Else (jest ona opcjonalna, gdy stosuje się instrukcję ElseIf). Jeżeli pominiesz instrukcję
708
Część VI Podstawy programowania w Accessie Else, a żaden z warunków nie jest spełniony, program nie wykona żadnych instrukcji z bloku If. Zagnieżdżone instrukcje If
Zagnieżdżanie instrukcji polega na umieszczaniu ich w bloku innej instrukcji. W kontekście instrukcji If zagnieżdżanie oznacza umieszczanie jednego bloku If w innym bloku tego rodzaju: If sState = "Michigan" Then If sCity = "Detrioit" Then dTaxRate = 0.05 ElseIf sCity = "Kalamazoo" Then dTaxRate = 0.045 Else dTaxRate = 0 End If End If
Zewnętrzny blok If sprawdza wartość zmiennej sState. Jeśli warunek jest spełniony, program wykonuje wewnętrzny blok If i sprawdza wartość zmiennej sCity. Jeżeli warunek w zewnętrznym bloku If nie jest spełniony, program przechodzi do wiersza pod instrukcją End If, która kończy blok If powiązany z tym warunkiem. Wcięcia w takim kodzie nie są niezbędne, jednak pomagają zobaczyć, które instrukcje Else i End If są powiązane z poszczególnymi instrukcja If. Wartości logiczne a warunki
Instrukcje If są bardzo przydatne i występują w wielu miejscach kodu. Jednak w dwóch sytuacjach programiści często ich nadużywają. Przyjrzyj się poniższemu fragmentowi kodu: If bIsBuyer = True Then bIsInPurchasing = True Else bIsInPurchasing = False End If
Jest to prosta instrukcja If…Else…End If, w której warunku program sprawdza, czy zmienna logiczna bIsBuyer ma wartość True. Na podstawie tego warunku inna zmienna logiczna jest ustawiana na True lub False. W tym rozwiązaniu nie ma nic złego — można je skompilować i uruchomić. Jednak można uprościć kod i poprawić jego czytelność. Po pierwsze, porównywanie zmiennej logicznej z wartościami True i False jest niepotrzebne, ponieważ sama zmienna ma jedną z tych wartości. Pierwszy wiersz można więc uprościć w następujący sposób: If bIsBuyer Then
Jeśli zmienna bIsBuyer ma wartość True, w pierwszym przykładowym fragmencie kompilator sprawdzi warunek bIsBuyer = True, czyli True = True, co oczywiście daje wartość True. W drugiej, prostszej wersji sprawdzony zostanie warunek bIsBuyer, co też da wartość True. Ponieważ bIsBuyer to zmienna logiczna, jej porównywanie z wartościami logicznymi jest zbędne.
Rozdział 23. Podstawy programowania w języku VBA
709
Drugie uproszczenie polega na całkowitym pominięciu instrukcji If. Gdy ustawiasz wartość logiczną w bloku If, sprawdź, czy nie można ustawić jej bezpośrednio: bIsInPurchasing = bIsBuyer
Ten jeden wiersz kodu działa tak samo jak pięć początkowych. Jeśli bIsBuyer ma wartość True, bIsInPurchasing też przyjmie taką wartość. Jeżeli bIsBuyer to False, program przypisze do bIsInPurchasing wartość False. Czasem trzeba przypisać do zmiennej zanegowaną wartość innej zmiennej. Język VBA udostępnia słowo kluczowe Not, które pozwala przekształcać wartości logiczne z True na False i w odwrotną stronę: bIsInPurchasing = Not bIsTruckDriver
Zmienna bIsTruckDriver ma wartość True lub False, a słowo kluczowe Not sprawia, że zwracana jest wartość przeciwna. Jeśli bIsTruckDriver to True, program przypisze do zmiennej bIsInPurchasing wartość False. Gdy trzeba sprawdzić wiele warunków, instrukcja If…Then…ElseIf…Else staje się skomplikowana. Lepiej jest wtedy zastosować instrukcję Select Case…End Select. Instrukcja Select Case…End Select Język VBA umożliwia sprawdzenie wielu warunków za pomocą instrukcji Select Case. Oto składnia tej instrukcji: Select Case Wyrażenie Case Wartość1 [Operacje wykonywane w przypadku, gdy Wyrażenie = Wartość1] Case Wartość2 [Operacje wykonywane w przypadku, gdy Wyrażenie = Wartość2] Case ... Case Else [Domyślne działanie wykonywane, gdy żadna z wartości nie pasuje do wyrażenia Wyrażenie] End Select
Zwróć uwagę, że ta składnia jest podobna do składni instrukcji If...Then. Instrukcja Select Case różni się od omówionej poprzednio tym, że zamiast warunku logicznego wykorzystuje umieszczone na początku wyrażenie kontrolne. Każdy element Case znajdujący się wewnątrz omawianej instrukcji ma wartość sprawdzaną na podstawie wyrażenia kontrolnego. Gdy wartość ta pasuje do wyrażenia kontrolnego, program wykonuje fragment kodu aż do następnego elementu Case albo do elementu End Select kończącego omawianą instrukcję. Kolejne wyrażenia nie są już sprawdzane. Jeśli do wyrażenia kontrolnego pasuje kilka elementów Case, w programie zostanie wykonany tylko blok kodu znajdujący się po pierwszym pasującym elemencie Case. Wszystkie pozostałe zostaną przez VBA zignorowane.
710
Część VI Podstawy programowania w Accessie
Na rysunku 23.10 pokazano instrukcję Select...Case wykorzystaną w formularzu frm DialogContactPrint do podjęcia decyzji o tym, który spośród kilku raportów ma być otwarty. Rysunek 23.10. Używanie instrukcji Select Case
Na rysunku 23.10 wyrażenie kontrolne instrukcji Select Case to Me![grpTypeOfPrint]. Wyrażenie to powiązane jest z grupą przycisków opcji z formularza. Zwraca wartości 1, 2 lub 3 w zależności od tego, który przycisk opcji jest wybrany. Wartość każdej instrukcji Case jest następnie porównywana z wartością wyrażenia. Jeśli program znajdzie pasującą wartość, wykona instrukcje między dopasowaną instrukcją Case a następną instrukcją Case (lub poleceniem End Select). Element Case Else jest opcjonalny, ale warto pamiętać o umieszczeniu tej klauzuli. Klauzula Case Else jest zawsze wpisywana na końcu wszystkich wyrażeń, za ostatnim elementem Case. Można z niej skorzystać w celu wykonania jakiejś operacji w sytuacji, gdy żadne wyrażenie Case nie pasuje do wartości wyrażenia kontrolnego podanego na początku instrukcji Select Case. Słowo kluczowe Is pozwala na sprawdzanie w instrukcjach Case nierówności: Select Case dTaxRate Case Is < 0.03 MsgBox "Niskie podatki" Case Is > 0.07 MsgBox "Wysokie podatki" Case Else MsgBox "Umiarkowane podatki" End Select
Słowo kluczowe Is pozwala przeprowadzać porównania w instrukcjach Case. Tu w instrukcji Select Case określono, że sprawdzana jest zmienna dTaxRate. W pierwszej instrukcji Case wartość tej zmiennej porównywana jest z 0.03. Jeśli wartość zmiennej jest niższa, wykonywany jest kod z tej instrukcji Case. Jeżeli zmienna dTaxRate ma wartość z przedziału od 0.03 do 0.07, uruchamiane są polecenia z bloku Case Else, ponieważ warunek z żadnej z dwóch poprzednich instrukcji Case nie jest spełniony. W instrukcjach Case można podać kilka wartości. Należy rozdzielić je wtedy przecinkami. Można też podać przedział wartości, używając słowa kluczowego To. W poniższym przykładzie zastosowano obie te techniki:
Rozdział 23. Podstawy programowania w języku VBA
711
Select Case dSalesAmt Case 0.99, 1.99 dCommissionPct = 0.1 Case 2 To 4.99 dCommissionPct = 0.15 Case Is >= 5 dCommissionPct = 0.17 End Select
Istnieją przypadki, w których trzeba wykonać określoną instrukcję (lub grupę instrukcji) więcej niż raz. W języku VBA jest kilka konstrukcji umożliwiających realizację takiego zadania.
Pętle Pętle są kolejnym elementem języka VBA o bardzo dużych możliwościach. Pętla to taka konstrukcja, która umożliwia wykonanie jednej instrukcji (lub całego bloku kodu) wiele razy. Instrukcja (lub blok instrukcji) jest wykonywana tak długo, aż nie zostanie spełniony warunek wyjścia z pętli. W języku VBA dostępne są dwie pętle: Do...Loop For...Next
Instrukcję Do…Loop stosuje się, gdy trzeba wielokrotnie wykonać dane polecenie lub blok, ale liczba powtórzeń nie jest znana. Instrukcja For…Next jest używana, gdy wiadomo, ile razy należy wykonać polecenia. Pętle powszechnie wykorzystuje się do przetwarzania rekordów w zestawie rekordów, zmiany wyglądu formantów w formularzu oraz wielu innych procesów wymagających wykonania tych samych instrukcji VBA wiele razy. Pętla Do…Loop Pętla Do...Loop jest wykorzystywana do wielokrotnego wykonania bloku tak długo, jak długo warunek jest spełniony (ma wartość True). Omawiana konstrukcja to jedna z najczęściej stosowanych technik wielokrotnego powtarzania fragmentu kodu w VBA. Do [While | Until Warunek] [Instrukcje VBA] [Exit Do] [Instrukcje VBA] Loop
Słowo kluczowe While (lub Until) można też umieścić na końcu konstrukcji: Do [Instrukcje VBA] [Exit Do] [Instrukcje VBA] Loop [While | Until Warunek]
712
Część VI Podstawy programowania w Accessie
Zwróć uwagę na występowanie kilku wariantów instrukcji Do...Loop. Zastosowanie klauzuli While powoduje, że instrukcje VBA wewnątrz bloku Do...Loop wykonują się w czasie, kiedy warunek ma wartość True. Sterowanie przechodzi poza pętlę Do...Loop natychmiast po tym, kiedy warunek przyjmie wartość False. Klauzula Until działa dokładnie odwrotnie. Kod wewnątrz konstrukcji Do...Loop wykonuje się tylko wtedy, gdy warunek ma wartość False. Umieszczenie klauzuli While lub Until na początku instrukcji Do...Loop oznacza, że pętla nigdy się nie wykona, jeśli warunek nie będzie spełniony. Umieszczenie klauzuli While lub Until na końcu pętli oznacza, że pętla wykona się co najmniej raz, ponieważ warunek będzie sprawdzony dopiero po wykonaniu się pętli po raz pierwszy. Wykonanie instrukcji Exit Do powoduje natychmiastowe zakończenie pętli Do...Loop. Instrukcję Exit Do można wykorzystać do sprawdzania warunków wewnątrz pętli: Do While Warunek1 [Instrukcje VBA] If Warunek2 Then Exit Do [Instrukcje VBA] Loop
Konstrukcje Exit Do często wykorzystuje się w celu zapobieżenia pętlom nieskończonym. Pętla nieskończona występuje w przypadku, gdy stan warunku (True lub False) nigdy się nie zmienia wewnątrz pętli. Warunki Warunek1 i Warunek2 wewnątrz pętli mogą być takie same. Nie ma obowiązku, aby drugi warunek był inny niż ten wykorzystywany na początku instrukcji Do...Loop. Przykład wykorzystania pętli Do...Loop pokazano na rysunku 23.11. W tym konkretnym przypadku otwarto zestaw rekordów. Wewnątrz pętli Do...Loop przetwarzany jest każdy z nich. W pokazanym przykładzie w oknie Immediate wyświetla się nazwa firmy, ale dane nie są modyfikowane ani wykorzystywane w żaden sposób. Rysunek 23.11. Używanie instrukcji Do…Loop
Klauzule While i Until zapewniają duże możliwości w zakresie przetwarzania pętli Do...Loop w kodzie. Instrukcja For…Next Instrukcja For...Next służy do powtarzania bloku instrukcji określoną liczbę razy. Ogólny format instrukcji For...Next jest następujący:
Rozdział 23. Podstawy programowania w języku VBA
713
For ZmiennaSterująca = Początek To Koniec [Blok instrukcji] [Exit For] [Blok instrukcji] Next ZmiennaSterująca
W poniższej procedurze wykorzystano wbudowaną funkcję Beep do generowania dźwięku określoną liczbę razy. Liczbę powtórzeń określa pętla For…Next: Sub BeepWarning() Dim lBeep As Long Dim lBeepCount As Long lBeepCount = 5 For lBeep = 1 To lBeepCount Beep Next lBeep End Sub
W pokazanej procedurze lBeep jest zmienną sterującą o początkowej wartości 1 i końcowej wartości równej zmiennej lBeepCount. Gdy program dochodzi do wiersza ze słowem For, zmienna lBeep jest ustawiana na 1. Dopóki wartość tej zmiennej jest mniejsza lub równa względem wartości zmiennej lBeepCount, wykonywane są instrukcje z bloku For…Next. Po dojściu programu do wiersza Next wartość zmiennej lBeep jest zwiększana o 1, a następnie ponownie porównywana z wartością zmiennej lBeepCount. Jeśli zmienna lBeep nadal nie jest większa niż lBeepCount, kod z pętli jest wykonywany ponownie. Jeżeli zmienna lBeep jest większa niż lBeepCount, pętla kończy pracę i wykonywany jest dalszy kod procedury. Instrukcja For Each…Next to specjalna wersja instrukcji For…Next przeznaczona do przechodzenia w pętli po kolekcjach. Omówienie instrukcji For Each…Next znajdziesz w punkcie „Obiekty i kolekcje” w dalszej części rozdziału. Instrukcja For...Next może przyjąć następującą postać: For ZmiennaSterująca = Początek To Koniec Step WartośćKroku [Blok instrukcji] Next ZmiennaSterująca
Jedyną różnicą w porównaniu z instrukcją w poprzedniej postaci jest klauzula Step WartośćKroku. Użycie słowa kluczowego Step wraz z wartością kroku powoduje inkrementację zmiennej sterującej o wartość kroku przy każdej iteracji pętli. Na przykład jeśli Początek ma wartość 10, Koniec wartość 100, a WartośćKroku — 10, wówczas zmienna sterująca przyjmuje wartości począwszy od 10 i zwiększa się o 10 przy każdej iteracji pętli. W poprzednim przykładzie pokazano, że jeśli pominie się klauzulę Step, ZmiennaSterująca będzie domyślnie zwiększana o 1. Wartości w pętlach For...Next zwykle rosną. Początkowa wartość licznika jest zwiększana o określoną wartość kroku. Jednak w niektórych sytuacjach potrzebna jest pętla, w której wartość licznika jest początkowo duża, a następnie zmniejsza się do wartości
714
Część VI Podstawy programowania w Accessie
końcowej. Wtedy jako wartość kroku należy podać liczbę ujemną. Do odliczania wstecz niezbędne jest słowo kluczowe Step. Jeśli je pominiesz, instrukcja For wykryje, że ZmiennaSterująca ma wartość większą niż Koniec i kod z pętli nie zostanie wykonany. Do tego miejsca stosowałeś proste zmienne, np. zmienne logiczne, liczby całkowite i łańcuchy znaków. W następnym podrozdziale omawiamy specjalną składnię używaną przy korzystaniu z obiektów zamiast z prostych zmiennych.
Obiekty i kolekcje W aplikacjach Accessa bardzo często trzeba posługiwać się obiektami — na przykład formantami na formularzu lub zestawem rekordów zawierającym dane pobrane z bazy danych. W języku VBA dostępnych jest kilka konstrukcji, które są przeznaczone specjalnie do pracy z obiektami i kolekcjami obiektów.
Wprowadzenie do obiektów Choć Microsoft Access nie jest obiektowy, często się mówi, że jest oparty na obiektach. Wiele elementów używanych w Accessie to obiekty, a nie proste liczby lub łańcuchy znaków. Obiekt to złożona jednostka, która wykonuje pewne zadania w aplikacji Accessa. Do łączenia podobnych obiektów w odrębne grupy służą w Accessie kolekcje. Gdy budujesz w Accessie formularz, w rzeczywistości tworzysz obiekt typu Form. W trakcie umieszczania formantów na formularzu dodajesz je do kolekcji Controls. Choć na formularzu można umieścić różnego rodzaju formanty (np. przyciski i pola tekstowe), w kolekcji Controls umieszczany jest każdy z nich. W książce tej zetkniesz się z bardzo dużą liczbą przykładów korzystania z pojedynczych obiektów i ich kolekcji. Zrozumienie różnicy między obiektami a prostymi zmiennymi jest ważnym krokiem na drodze do tego, by stać się sprawnym programistą Accessa. Każdy typ obiektów w Accessie ma własne właściwości i metody, a także liczne właściwości (np. Name) i metody wspólne wielu obiektom. Nazwa kolekcji to zwykle nazwa przechowywanych w niej obiektów w liczbie mnogiej. Na przykład kolekcja Forms zawiera obiekty typu Form, a kolekcja Reports — obiekty typu Report. Zdarzają się jednak wyjątki, np. kolekcja Controls. Choć zawiera ona obiekty typu Control, każdy obiekt typu Control jest jednocześnie obiektem innego typu. Może to być obiekt typu Textbox, Combobox lub jednego z innych bardziej wyspecjalizowanych typów obiektów. Kolekcje mają niewiele właściwości i metod. Poniżej wymieniono dwie najważniejsze właściwości kolekcji w Accessie: — jest to liczba elementów przechowywanych w kolekcji. Jeśli właściwość ta ma wartość 0, kolekcja jest pusta. Kolekcje mogą obejmować dowolną liczbę elementów, jednak przy bardzo dużych wartościach właściwości Count (powyżej 50 000) wydajność aplikacji spada.
Count
Item — po zapisaniu obiektów w kolekcji potrzebny jest sposób ich wskazywania.
Właściwość Item wskazuje pojedynczy element kolekcji.
Rozdział 23. Podstawy programowania w języku VBA
715
Poniżej pokazano, jak ustawić właściwość jednego z elementów kolekcji: MojaKolekcja.Item(9).Właściwość = Wartość
lub: MojaKolekcja.Item("NazwaElementu").Właściwość = Wartość
MojaKolekcja to nazwa kolekcji, Właściwość to nazwa właściwości danego elementu, a Wartość to wartość przypisywana tej właściwości. Kolekcje Forms i Reports są nietypowe, ponieważ zawierają jedynie otwarte obiekty typu Form i Report. W kolekcji TableDefs znajdują się wszystkie tabele bazy danych (niezależnie od tego, czy są otwarte).
W tym krótkim fragmencie przedstawiono kilka ważnych zagadnień związanych z kolekcjami:
Elementy przechowywane w kolekcji można wskazywać na różne sposoby. Zwykle każdy element kolekcji (np. kolekcji Controls formularzy) ma nazwę, za pomocą której można go wskazać: MójFormularz.Controls("txtNazwisko").FontBold = True
Dlatego nazwa każdego obiektu w kolekcji musi być niepowtarzalna. Nie można na przykład utworzyć w formularzu Accessa dwóch formantów o tej samej nazwie. Obiekty w kolekcji można też wskazywać w inny sposób, za pomocą liczby określającej miejsce elementu w danej kolekcji. Pierwszy element dodany do kolekcji ma numer 0 (zero), następny — 1 itd.
Kolekcje mają właściwości domyślne. Może zauważyłeś, że w ostatnim fragmencie kodu do pobrania formantu txtNazwisko nie wykorzystano właściwości Item. Właściwość Item jest w większości kolekcji właściwością domyślną, którą często się pomija. Dwa poniższe wiersze kodu działają tak samo: MyForm.Controls.Item(1).Text = "Name" MyForm.Controls(1).Text = "Name"
Kolekcja może obejmować wiele tysięcy obiektów. Choć gdy kolekcja zawiera kilkadziesiąt tysięcy obiektów, wydajność aplikacji spada, kolekcje są wygodnym narzędziem do zapisywania dowolnej liczby elementów w trakcie działania programu. W kilku przykładach z tej książki zobaczysz, jak wykorzystać kolekcje jako mechanizmy przechowywania danych. Kropka między nazwą obiektu a nazwami jej właściwości lub metod to operator kropki. Zapewnia on dostęp do właściwości i metod obiektu.
Metody i właściwości Obiekty są powiązane z właściwościami i metodami, a także ze zdarzeniami (te ostatnie szczegółowo opisaliśmy w rozdziale 25.).
716
Część VI Podstawy programowania w Accessie
Właściwości Właściwości umożliwiają wczytywanie i modyfikowanie prostych wartości, które są cechami obiektu. Na przykład obiekt Label ma właściwość Caption, która określa łańcuch znaków wyświetlany w danej etykiecie. Inne właściwości obiektu Label to Height i Width. Przechowują one liczby określające wielkość obiektu. Są to przykładowe właściwości do przechowywania prostych wartości. Właściwości mogą też zwracać inny obiekt. Wiesz już, że obiekt Form ma właściwość Controls. Czy jednak Controls nie jest obiektem kolekcji? Jest, a każdy taki obiekt ma zwracającą go właściwość. W wyrażeniu MyForm.Controls.Count właściwość Controls formularza MyForm zapewnia dostęp do obiektu kolekcji Controls. Na szczęście model obiektowy Accessa jest tak dobrze zaprojektowany, że nie trzeba się martwić o rozróżnienie na proste właściwości i właściwości zwracające obiekty. Gdy w jednej instrukcji występują dwa operatory kropki, możesz mieć pewność, że jeden z nich daje dostęp do innego obiektu. Wprowadzenie operatora kropki po właściwości zwracającej zwykłą wartość nie daje dostępu do żadnych opcji. Metody Za pomocą operatora kropki można też uzyskać dostęp do metod obiektu. Metody różnią się od właściwości, ponieważ nie zwracają wartości. Metody można podzielić na dwie kategorie — modyfikujące więcej niż jedną właściwość i wykonujące operacje poza danym obiektem. Metody pierwszego typu wprowadzają zmiany jednocześnie w dwóch lub więcej właściwościach. Na przykład obiekt Commandbutton udostępnia metodę SizeToFit, która zmienia wartości właściwości Height i Width, tak aby można było wyświetlić cały tekst z właściwości Caption. Metody drugiego rodzaju wykonują pewne operacje poza macierzystym obiektem. Zwykle modyfikują kilka właściwości. Na przykład obiekt Form udostępnia metodę Undo, która wychodzi poza formularz i sprawdza stos wykonanych operacji w Accessie, aby ustalić ostatnie ukończone zadanie. Gdy metodę tę wywołasz po wprowadzeniu zmiany w polu tekstowym, przywrócona zostanie poprzednia wartość właściwości Text tego pola.
Instrukcja With Instrukcja With zapewnia dostęp do właściwości i metod obiektu bez konieczności wielokrotnego wpisywania jego nazwy. Właściwości i metody używane między słowami With i End With automatycznie dotyczą obiektu określonego w instrukcji With. Pomiędzy instrukcją With a instrukcją End With można umieścić dowolną liczbę instrukcji. Instrukcje With można zagnieżdżać. Właściwości i metody zawsze dotyczą obiektu podanego w bloku With, w którym występują. Przeanalizuj kod z poniższą konstrukcją For...Next. Kod ten przetwarza w pętli wszystkie elementy kolekcji Controls formularza i sprawdza każdy z nich. Jeśli formant jest przyciskiem polecenia, jego czcionka jest ustawiana na pogrubioną wersję kroju Times New Roman o rozmiarze 12 punktów.
Rozdział 23. Podstawy programowania w języku VBA
717
Private Sub cmdOld_Click() Dim i As Integer Dim MyControl As Control For i = 0 To Me.Controls.Count - 1 Set MyControl = Me.Controls(i) 'Pobieranie formantu If TypeOf MyControl Is CommandButton Then 'Ustawianie właściwości formantu MyControl.FontName = "Times New Roman" MyControl.FontBold = True MyControl.FontSize = 12 End If Next End Sub
Jak można zauważyć, w powyższym przykładzie użyto innego wyrażenia. Sercem tej procedury jest pętla For...Next. Pętla rozpoczyna się od zera (wartość początkowa) i wykonuje się do momentu, kiedy zmienna i osiągnie wartość liczby formantów minus 1 (formanty w formularzach Accessa numeruje się, począwszy od zera, a właściwość Count informuje o tym, ile formantów zawiera formularz). Zmienna MyControl wewnątrz pętli wskazuje na formant o numerze równym zmiennej i. Instrukcja If TypeOf sprawdza typ formantu wskazywanego przez zmienną MyControl. W treści instrukcji If...Then następuje ustawienie właściwości formantu (FontName, FontBold i FontSize). Kod tego rodzaju, który manipuluje wszystkimi składowymi z kolekcji, jest często stosowany. Zwróć uwagę na to, że odwołanie do zmiennej formantu występuje w każdej instrukcji przypisania. Odwoływanie się do właściwości formantów pojedynczo to dość powolny proces. Gdyby formularz zawierał wiele formantów, powyższy kod działałby stosunkowo wolno. W ulepszonej wersji tego kodu wykorzystano instrukcję With w celu odizolowania jednego elementu kolekcji Controls i zastosowania dla niego więcej niż jednej instrukcji. Na poniższym listingu wykorzystano instrukcję With w celu zmiany kilku ustawień czcionek pojedynczego formantu. Private Sub cmdWith_Click() Dim i As Integer Dim MyControl As Control For i = 0 To Me.Controls.Count - 1 Set MyControl = Me.Controls(i) 'Pobieranie formantu If TypeOf MyControl Is CommandButton Then With MyControl 'Ustawianie właściwości formantu .FontName = "Arial" .FontBold = True .FontSize = 8 End With End If Next End Sub
718
Część VI Podstawy programowania w Accessie
Kod w powyższym przykładzie (cmdWith_Click) wykonuje się szybciej od poprzedniego przykładu (cmdOld_Click). Kiedy Access uzyska uchwyt do formantu (With MyControl), może zastosować wszystkie polecenia z treści instrukcji With bez konieczności pobierania formantu z kolekcji, co w procedurze cmdOld_Click było konieczne. Jest bardzo mało prawdopodobne, że w tym przykładzie dostrzeżesz jakąkolwiek różnicę w czasie wykonania starszej wersji i kodu z instrukcją With. Jeśli jednak zbiór danych jest bardzo duży, instrukcja With pozwala poprawić wydajność aplikacji. Niezależnie od tego instrukcja ta zmniejsza ilość kodu oraz ułatwia jego czytanie i zrozumienie. Pozwala też ograniczyć ilość wpisywanego tekstu, gdy trzeba zmodyfikować dużą liczbę właściwości obiektu. Wykonanie instrukcji With można porównać do wręczenia Accessowi określonego elementu i polecenia „Ustaw, proszę, wszystkie właściwości tego elementu”. Z kolei poprzedni przykład można było porównać do wielokrotnego wydawania polecenia „Weź element x i ustaw jego właściwość”. Różnica w szybkości działania tych poleceń jest znacząca.
Instrukcja For Each Kod procedury cmdWith_Click można usprawnić jeszcze bardziej poprzez zastosowanie instrukcji For Each do przeglądania kolekcji Controls. Konstrukcja For Each przechodzi przez poszczególne elementy kolekcji i udostępnia je do odczytu lub modyfikowania właściwości. Sposób, w jaki konstrukcja For Each pozwala uprościć omawiany przykład, zaprezentowano w poniższym kodzie: Private Sub cmdForEach_Click() Dim MyControl As Control For Each MyControl In Me.Controls If TypeOf MyControl Is CommandButton Then With MyControl .FontName = "MS Sans Serif" .FontBold = False .FontSize = 8 End With End If Next End Sub
Usprawnienie nie polega tylko na użyciu kodu mniejszej objętości do wykonania tych samych działań. Zwróć uwagę, że nie jest już potrzebna zmienna całkowitoliczbowa do zliczania elementów kolekcji Controls. Nie trzeba również odwoływać się do właściwości Count kolekcji Controls w celu określenia momentu, w którym należy zakończyć pętlę For. Wszystkie te dodatkowe działania są wykonywane automatycznie przez mechanizm obsługi języka VBA. Kod na powyższym listingu jest bardziej zrozumiały od wszystkich poprzednich wersji. Cel każdego poziomu zagnieżdżenia jest oczywisty i czytelny. Nie trzeba śledzić wartości indeksu, aby wiedzieć, jakie działania należy wykonać. Nie trzeba też martwić się tym, czy pętlę For należy rozpocząć od 0, czy od 1. Kod przykładu wykorzystującego konstrukcję For...Each jest nieznacznie szybszy od kodu z konstrukcją With...End With,
Rozdział 23. Podstawy programowania w języku VBA
719
ponieważ nie trzeba zwiększać wartości zmiennej całkowitoliczbowej używanej w roli licznika pętli. Access nie musi też wyszukiwać w kolekcji formantu, dla którego należy przeprowadzić działania. W przykładowej bazie danych Rozdział23.accdb znajduje się formularz frmDemoWith (zobacz rysunek 23.12) zawierający kod omówiony w tym podrozdziale. Z każdym z trzech przycisków w dolnej części tego formularza jest związany inny kod przetwarzający w pętli kolekcję formantów formularza w celu modyfikacji atrybutów czcionki formantu. Rysunek 23.12. Baza danych Rozdział23.accdb zawiera przykładowy formularz frmWithDemo
Przegląd edytora VBE Aby wydajnie programować w Accessie, trzeba poznać edytor VBE (ang. Visual Basic Editor). W tym podrozdziale opisaliśmy mechanizmy tego edytora oraz sposoby korzystania z nich.
Okno Immediate Po wpisaniu kodu procedury można sprawdzić jej działanie, nie opuszczając okna z kodem modułu, a także sprawdzić wynik zastosowanego wyrażenia. Za pomocą okna Immediate (zobacz rysunek 23.13) można wypróbować procedurę bez konieczności zamykania modułu. Okno to pozwala uruchomić moduł i sprawdzić wartości zmiennych. Rysunek 23.13. Okno Immediate
720
Część VI Podstawy programowania w Accessie
Aby otworzyć okno Immediate, należy wcisnąć klawisze Ctrl+G. Można też wybrać polecenie View/Immediate Window w edytorze VBE. Warto zauważyć, że w edytorze VBE nie ma wstążki. Okno edytora kodu wygląda tak samo jak we wszystkich wersjach Accessa od edycji 2000. Dlatego w książce tej w opisach pracy z modułami VBA Accessa podajemy opcje z paska narzędzi i menu edytora. Nie należy mylić paska narzędzi edytora kodu ze wstążką z głównego okna Accessa.
Uruchomienie procedury BeepWarning jest łatwe. Wystarczy wpisać BeepWarning w oknie Immediate i wcisnąć Enter. Powinieneś usłyszeć pięć dźwięków (lub jeden ciągły dźwięk, jeśli przerwa pomiędzy kolejnymi sygnałami jest zbyt krótka). Okno Immediate jest doskonałym narzędziem diagnostycznym. Omówienie debugowania kodu VBA znajdziesz w rozdziale 26.
Project Explorer Project Explorer to okno w edytorze VBE wyświetlające wszystkie moduły projektu (zarówno standardowe, jak i moduły formularzy oraz raportów). Narzędzie to pozwala łatwo przechodzić między modułami bez konieczności powrotu do głównego okna Accessa. Aby wyświetlić okno Project Explorer, wciśnij kombinację klawiszy Ctrl+R lub wybierz opcję View/Project Explorer z menu edytora VBE. Domyślnie okno to jest zadokowane po lewej stronie edytora VBE, co pokazano na rysunku 23.14. Rysunek 23.14. W oknie Project Explorer widoczne są wszystkie moduły bazy danych
W górnej części zwijanej listy okna Project Explorer widoczna jest nazwa projektu. Odpowiada ona nazwie bazy danych, ale jest pozbawiona rozszerzenia .accdb. Pod nazwą projektu znajdują się foldery. Na rysunku 23.14 widać, że w projekcie znajdują się foldery na obiekty klas Accessa i na moduły. Folder Class Objects zawiera moduły klas powiązane z formularzami i raportami, natomiast w folderze Modules znajdują się moduły standardowe.
Rozdział 23. Podstawy programowania w języku VBA
721
W górnej części okna Project Explorer widoczne są trzy ikony:
View Code — gdy klikniesz tę ikonę, kursor zostanie przeniesiony do okna kodu — dużego obszaru, w którym można wprowadzać i modyfikować kod VBA. Ten sam efekt można osiągnąć, klikając myszą w oknie kodu.
View Objects — kliknięcie tej ikony powoduje wyświetlenie obiektu powiązanego z danym modułem. Jeśli otwarty jest moduł powiązany z formularzem lub raportem, pojawi się odpowiedni formularz lub raport. Ikona ta to wygodny skrót pozwalający wrócić do głównego okna Accessa. Dla modułów standardowych ikona jest nieaktywna.
Toggle Folders — moduły domyślnie są wyświetlane w folderach. Aby usunąć foldery i zobaczyć wszystkie moduły na jednej liście, kliknij ikonę Toggle Folders. Gdy klikniesz ją ponownie, wrócisz do widoku folderów. Jeśli stosowane są odpowiednie konwencje nazewnicze, nie trzeba wyświetlać folderów w oknie Project Explorer. Dodanie dla wszystkich modułów standardowych przedrostka mod sprawi, że w każdym widoku znajdą się one w jednej grupie.
Object Browser Object Browser to okno w edytorze VBE, które pozwala zobaczyć wszystkie obiekty, właściwości, metody i zdarzenia projektu. W odróżnieniu od okien Immediate i Project Explorer domyślnie nie jest zadokowane i zwykle zajmuje całe okno kodu. Okno Object Browser to przydatne narzędzie do wyszukiwania właściwości i metod. Na rysunku 23.15 w polu wyszukiwania wprowadzono słowo font. Okno Object Browser wyświetla wszystkie elementy zawierające to słowo. Rysunek 23.15. W oknie Object Browser można znaleźć właściwości i metody
722
Część VI Podstawy programowania w Accessie
W omawianym oknie znajduje się lista rozwijana z bibliotekami, które pozwala ograniczyć listę wyników wyszukiwania. Jeśli nie wiesz, w której bibliotece szukać wystąpień danego tekstu, możesz wybrać opcję All Libraries. Na rysunku 23.15 wyszukiwanie dotyczy tylko biblioteki Accessa. Zawiera ona elementy modelu obiektowego Accessa i w czasie tworzenia aplikacji Accessa jest używana najczęściej. Dla wyszukiwania z rysunku 23.15 znaleziono dużo wyników. W kolumnie Class widoczna jest nazwa obiektu, a w kolumnie Member — właściwość lub metoda. W dolnej części okna Object Browser można przejść do dowolnego obiektu, aby zobaczyć jego właściwości i metody.
Opcje edytora VBE Wiele spośród najbardziej istotnych własności Accessa dotyczy tylko programistów. Dla zwykłych użytkowników są one ukryte — korzystają z nich tylko osoby tworzące aplikację. Warto poświęcić trochę czasu na zapoznanie się z tymi funkcjami, tak aby w pełni zdać sobie sprawę z korzyści, jakie one przynoszą. Dzięki temu można dobrać ustawienia opcji odpowiadające sposobowi pracy oraz wybrać rodzaje pomocy potrzebne podczas pisania kodu VBA. Zakładka Editor w oknie dialogowym Options Okno dialogowe Options zawiera kilka istotnych ustawień, które mają znaczący wpływ na sposób komunikowania się z Accessem podczas wprowadzania kodu w aplikacjach. Aby uzyskać dostęp do tych opcji, należy w edytorze VBE wybrać polecenie Tools/Options. Zakładkę Editor okna dialogowego Options przedstawia rysunek 23.16. Rysunek 23.16. Zakładka Editor okna dialogowego Options
Auto Indent
Opcja Auto Indent powoduje automatyczne generowanie wcięć w kodzie do bieżącej głębokości dla wszystkich kolejnych wierszy kodu. Na przykład jeśli wstawisz dwie tabulacje na początku bieżącego wiersza kodu, to każdy kolejny wiersz utworzony w wyniku wciśnięcia klawisza Enter będzie automatycznie przesunięty o tę samą odległość.
Rozdział 23. Podstawy programowania w języku VBA
723
Auto Syntax Check
Jeśli zaznaczysz opcję Auto Syntax Check, to w miarę wprowadzania kolejnych wierszy kodu Access będzie na bieżąco sprawdzał, czy nie występują w nich błędy składni. Wielu doświadczonych programistów denerwuje takie działanie, w związku z czym wolą wyłączyć tę opcję. Gdy opcja ta jest wyłączona, błędy składni są wyróżniane kolorem czerwonym, jednak program nie wyświetla okna komunikatu. Zaletą okien komunikatu jest to, że wyświetlają dodatkowe informacje na temat wykrytego błędu, choć komunikaty są często mało zrozumiałe. Require Variable Declaration
Ustawienie to powoduje automatyczne wstawianie dyrektywy Option Explicit we wszystkich nowych modułach VBA aplikacji Accessa. Opcja ta nie jest domyślnie włączona. Niemal powszechnie przyjmuje się, że należy stosować dyrektywę Option Explicit, dlatego warto włączyć tę opcję. Jednak system nie dodaje wtedy dyrektywy Option Explicit do wcześniej utworzonych modułów. Dobra wiadomość jest taka, że wystarczy wpisać ją w tych modułach. Kiedy przyzwyczaisz się do włączania dyrektywy Option Explicit w każdym module (z modułami globalnymi oraz modułami klas włącznie), znikną problemy związane ze szkodliwymi lub nieznanymi zmiennymi (w rzeczywistości prawie zawsze są to nazwy zmiennych, w których popełniono błędy). Dzięki ustawieniu we wszystkich modułach dyrektywy Option Explicit kod jest czytelniejszy i łatwiejszy do debugowania i utrzymania, ponieważ kompilator wykrywa wszystkie literówki.
Auto List Members Powyższa opcja wyświetla w oknie kodu listę zawierającą elementy hierarchii obiektów. Na rysunku 23.6 pokazano listę składowych obiektu DoCmd, która wyświetliła się po wpisaniu kropki za słowem DoCmd w instrukcji VBA. Aby wybrać element z listy, wystarczy kontynuować pisanie lub wskazać element na liście, a następnie wcisnąć spację. Auto Quick Info W przypadku włączenia opcji Auto Quick Info Access wyświetla pomoc dotyczącą składni (zobacz rysunek 23.7) po wprowadzeniu nazwy procedury (funkcji, podprogramu lub metody), a następnie kropki, spacji lub otwierającego nawiasu. Może to być zarówno wbudowana funkcja (podprogram), jak i procedura, którą programista napisał samodzielnie w języku VBA w Accessie. Auto Data Tips Opcja Auto Data Tips wyświetla wartości zmiennych po wskazaniu ich kursorem myszy w sytuacji, kiedy moduł znajduje się w trybie wstrzymania. Włączenie opcji Auto Data Tips jest alternatywą ustawienia obserwacji zmiennej i przełączania się do okna Debug, kiedy Access zatrzyma wykonywanie kodu na ustawionej pułapce (ang. breakpoint). Debugowanie kodu VBA w Accessie opisano w rozdziale 26.
724
Część VI Podstawy programowania w Accessie
Okno dialogowe właściwości projektu Wszystkie komponenty kodu w aplikacjach Accessa, łącznie z modułami, procedurami, zmiennymi i innymi elementami, tworzą projekt VBA. Mechanizm języka VBA korzysta z modułów i procedur jako składowych projektu. Access zarządza kodem w aplikacji poprzez śledzenie wszystkich obiektów kodu wchodzących w skład projektu. Różnią się one od kodu dodanego do aplikacji w postaci bibliotek uruchomieniowych oraz za pomocą kreatorów. Każdy projekt Accessa obejmuje pewną liczbę ważnych opcji. W oknie dialogowym właściwości projektu (zobacz rysunek 23.17) jest pewna liczba ustawień istotnych z punktu widzenia programistów. Aby otworzyć okno dialogowe właściwości projektu, należy otworzyć moduł w oknie kodu i kliknąć opcję Tools/Nazwa projektu Properties (gdzie Nazwa projektu to nazwa rozwijanego projektu bazodanowego). Rysunek 23.17. Okno dialogowe właściwości projektu zawiera szereg interesujących opcji
Project name
Niektóre zmiany w strukturze aplikacji wymagają ponownej kompilacji jej kodu przez Accessa. Na przykład modyfikacja kodu w globalnym module wpływa na wszystkie instrukcje w innych modułach wykorzystujących ten kod, w związku z czym Access musi skompilować cały kod w aplikacji. Do czasu ponownej kompilacji Access „dekompiluje” aplikację poprzez przywrócenie wersji tekstowej kodu zapisanej w pliku .accdb i ignoruje skompilowany kod zapisany w tym pliku. Oznacza to konieczność interpretowania każdego wiersza kodu w fazie wykonywania programu, co znacznie spowalnia aplikację. Czasami dekompilacja jest uruchamiana w wyniku nawet mało znaczących modyfikacji, na przykład zmiany nazwy projektu. Dzieje się tak z powodu hierarchicznej natury języka VBA Accessa. Ponieważ właścicielami wszystkich obiektów są inne obiekty, zmiana nazwy obiektu wysokiego poziomu może spowodować zmianę zależności i własności wszystkich obiektów znajdujących się niżej w hierarchii. Access utrzymuje oddzielne, niezależne nazwy projektów dla kodu oraz wykonywalnych obiektów w aplikacji. Zmiana nazwy pliku .accdb nie powoduje dekompilacji kodu w aplikacji Accessa. Domyślnie nazwa projektu jest taka sama jak nazwa pliku .accdb,
Rozdział 23. Podstawy programowania w języku VBA
725
choć nazwy te są od siebie niezależne. Projektowi można nadać niepowtarzalną nazwę za pomocą pola tekstowego Project Name w zakładce General okna dialogowego właściwości projektu. Project Description
Opcja Project Description (opis projektu) zgodnie z tym, co wskazuje nazwa, określa opis projektu. Ponieważ obszar w tym polu tekstowym jest ograniczony, nie można wprowadzić w nim istotnych informacji, które mogłyby okazać się pomocne dla innych programistów. Argumenty warunkowej kompilacji
Dyrektywy kompilatora instruują kompilator VBA Accessa, aby włączał do kompilacji bądź wyłączał z kompilacji fragmenty kodu w zależności od stałej zdefiniowanej w sekcji deklaracji modułu. Warunkowa kompilacja dotyczy wierszy rozpoczynających się od symbolu #. Jednym z ograniczeń używania dyrektyw kompilatora jest fakt, iż deklaracje stałych są lokalne dla modułu. Oznacza to konieczność używania dyrektywy kompilatora #Const w celu skonfigurowania stałej w każdym z modułów zawierających dyrektywę #If. Z powodu tego ograniczenia usunięcie wszystkich dyrektyw kompilatora #Const w celu zmodyfikowania kodu na końcu fazy projektowania jest trudne. Wyobraź sobie, że chcesz skorzystać z warunkowej kompilacji w celu włączenia określonych instrukcji i funkcji debugowania w fazie tworzenia oprogramowania. Bezpośrednio przed dostarczeniem aplikacji do użytkowników chcesz jednak usunąć z kodu dyrektywy kompilatora, tak aby użytkownicy nie widzieli okien informacyjnych, komunikatów na pasku stanu oraz innych informacji diagnostycznych. Jeśli aplikacja składa się z wielu formularzy i modułów, to aby mieć pewność pomyślnej dezaktywacji kodu diagnostycznego, trzeba znaleźć wszystkie dyrektywy #Const (dlatego właśnie warto zastosować odpowiednią konwencję nazewnictwa dla identyfikatorów używanych w dyrektywie #Const). Na szczęście w Accessie zapewniono sposób skonfigurowania „globalnych” argumentów warunkowej kompilacji. W zakładce General okna dialogowego właściwości projektu jest pole tekstowe Conditional Compilation Arguments, w którym można wpisać argumenty wykorzystywane w dyrektywach warunkowej kompilacji. Załóżmy, że we wszystkich modułach aplikacji zamieszczono instrukcje następującej postaci: #If CC_DEBUG2 Then MsgBox "Wykonuje się funkcja ProcessRecords()" #End If
Zamiast dodawać dyrektywę definiującą stałą (#Const CC_DEBUG2 = True) w każdym module w aplikacji, można w polu tekstowym Conditional Compilation Arguments wprowadzić następujący tekst: CC_DEBUG2 = -1
726
Część VI Podstawy programowania w Accessie
Powyższa dyrektywa ustawia wartość stałej CC_DEBUG2 na -1 (True) dla wszystkich modułów (zarówno globalnych, jak i modułów klas formularzy oraz raportów) w aplikacji. Wystarczy zmodyfikować tylko jeden wiersz na CC_DEBUG2=0, aby wyłączyć instrukcje diagnostyczne we wszystkich modułach w aplikacji. Warto zwrócić uwagę, że podczas ustawiania stałych kompilatora w oknie właściwości projektu nie używa się słów True i False, pomimo że w module kodu VBA wartości te są stosowane. W oknie dialogowym właściwości zamiast słowa True należy użyć wartości –1, a zamiast False — wartości 0.
Jeśli definiujesz wiele argumentów, powinieneś rozdzielić je dwukropkami, np. CC_DEBUG1=0 : CC_DEBUG2=-1.
Rozdział 24.
Typy danych i procedury w języku VBA W tym rozdziale:
Nazywanie i deklarowanie zmiennych
Typy danych w języku VBA
Zasięg i czas życia zmiennych
Stosowanie stałych
Tablice
Korzystanie z podprogramów i funkcji
Tworzenie funkcji
Wszystkie aplikacje VBA wymagają zmiennych, w których można przechowywać dane w czasie działania programu. Zmienne można porównać do tablicy, na której można tymczasowo zapisać ważne informacje, a później może z nich skorzystać program. Na przykład jeśli użytkownik wprowadzi wartość w formularzu, najczęściej wykorzystuje się zmienną do tymczasowego zapisania wartości do czasu jej trwałego zapisania w bazie danych lub wydrukowania w raporcie. Mówiąc prosto, zmienna jest nazwą, którą przypisujemy do określonych danych w aplikacji. Można też zastosować bardziej techniczne określenia — zmienna jest obszarem pamięci o określonej nazwie, przeznaczonym do przechowywania danych podczas wykonywania programu. Zmienne są chwilowe. Giną po zakończeniu działania aplikacji. Jak można przeczytać w punkcie „Zasięg i czas życia zmiennych” w dalszej części tego rozdziału, czas życia zmiennej może być bardzo krótkim odcinkiem w trakcie wykonywania się programu lub też może trwać tak długo, jak długo działa aplikacja. W większości przypadków do każdej zmiennej w aplikacji przypisuje się specyficzny typ danych. Na przykład można utworzyć zmienną łańcuchową przeznaczoną do zapisania danych tekstowych, takich jak nazwy lub opisy. Z kolei zmienne walutowe są przeznaczone do przechowywania wartości reprezentujących kwoty pieniężne. Nie należy próbować przypisywania wartości tekstowych do zmiennych walutowych, ponieważ może to spowodować błędy w pracy aplikacji.
728
Część VI Podstawy programowania w Accessie
Używane zmienne mają istotny wpływ na działanie aplikacji. Z definiowaniem i używaniem zmiennych w programach Accessa związanych jest wiele opcji. Nieodpowiednie wykorzystanie zmiennych może przyczynić się do spowolnienia działania aplikacji lub spowodować utratę danych. W tym rozdziale zawarto wszystkie informacje potrzebne do tworzenia i używania zmiennych VBA. Wiadomości zawarte w tym rozdziale umożliwiają używanie najbardziej wydajnych i skutecznych typów danych dla zmiennych, a jednocześnie zapewniają uniknięcie najczęstszych problemów związanych ze zmiennymi w języku VBA.
Zmienne Zmienna jest jednym z najważniejszych elementów języka programowania. Zmienna to tymczasowy fragment pamięci programu, który ma nazwę i wartość. Zmienną można wykorzystać w celu zachowania wyniku obliczeń, przechowywania wartości wprowadzonej przez użytkownika lub wczytanej z tabeli. Za pomocą zmiennej można też udostępnić wartość formantu innej procedurze. W celu wykorzystania wyniku wyrażenia można zachować go w zmiennej. Aby przypisać wynik wyrażenia do zmiennej, trzeba skorzystać z operatora przypisania (=). Poniżej przedstawiono kilka przykładów obliczeń oraz przypisywania wartości do zmiennych: licznik = 1 licznik = licznik + 1 dziś = Date()
Prostą procedurę wykorzystującą kilka różnych zmiennych pokazano na rysunku 24.1. Chociaż jest to bardzo prosty przykład używania zmiennych, demonstruje on niemal wszystko, co trzeba wiedzieć na temat używania zmiennych w języku VBA.
Słowo kluczowe Dim definiuje wewnątrz procedury nowe zmienne — sFormName i sCriteria.
W instrukcji Dim należy nadać zmiennej opisową nazwę. Na rysunku 24.1 zmiennym nadano nazwy sFormName oraz sCriteria, określające, do czego zmienne są używane przez procedurę.
Instrukcja Dim zawiera typ danych nowej zmiennej. Na rysunku 24.1 dla obu zmiennych zastosowano typ String.
W celu przypisania wartości do zmiennej można skorzystać z różnych technik. Na rysunku 24.1 wykorzystano operator = w celu przypisania wartości literału (frmContactLog) do zmiennej sFormName. Warto zauważyć, że tekst frmContactLog ujęto w cudzysłów, dlatego jest literałem. Wartość pobrana z pola tekstowego txtContactID z formularza jest łączona z literałem "[ContactID]=" i przypisywana do zmiennej sCriteria. Dane przypisane do zmiennych zawsze powinny być właściwe dla zastosowanego typu danych.
Do wykonywania działań na zmiennych można wykorzystać szereg operatorów. Na rysunku 24.1 wykorzystano operator złączania (&) w celu połączenia wyrażenia [ContactID]= z wartością pola tekstowego txtContactID.
Rozdział 24. Typy danych i procedury w języku VBA
729
Rysunek 24.1. Deklaracje zmiennych znajdują się na początku procedur VBA
Istnieje wiele sposobów wykonywania zadań zaprezentowanych na rysunku 24.1. Na przykład, jak opisano w punkcie „Deklarowanie zmiennych” w dalszej części tego rozdziału, instrukcja Dim nie jest jedynym sposobem definiowania zmiennej. Jak przekonasz się w wielu rozdziałach w tej książce, operator = nie jest jedynym sposobem przypisywania wartości do zmiennej. Nie trzeba też używać zmiennej takiej jak sCriteria do tymczasowego przechowania wartości wygenerowanej przez połączenie dwóch wartości. Dwie wartości równie dobrze można połączyć „w locie” w instrukcji DoCmd.OpenForm: DoCmd.OpenForm "frmContactLog", _ "[ContactID] = " & Me![txtContactID]
Jest bardzo niewiele reguł rządzących sposobami deklarowania i używania zmiennych. Zawsze należy dążyć do jak najlepszej czytelności kodu VBA. W prostym przykładzie pokazanym na rysunku 24.1 łatwo zauważyć, że w zmiennej sFormName jest zapisana nazwa formularza, zwłaszcza że użyto jej w ramach instrukcji DoCmd.OpenForm.
Nazewnictwo zmiennych Każdy język programowania ma własną konwencję nadawania nazw zmiennym. W języku VBA każda nazwa zmiennej musi spełnić następujące warunki:
Musi zaczynać się literą.
Musi być unikatowa — nazwy zmiennej nie można potem zadeklarować jeszcze raz w procedurze lub modułach korzystających z tej zmiennej.
Nie może zawierać spacji bądź znaków przestankowych (z wyjątkiem podkreślenia).
Nie może być słowem zarezerwowanym, takim jak Sub, Module lub Form.
Nie może być dłuższa niż 255 znaków.
730
Część VI Podstawy programowania w Accessie
Choć można zmiennej nadać dowolną nazwę, większość programistów przestrzega jednak standardowej konwencji nazewnictwa zmiennych. Oto kilka przykładów najczęściej stosowanych praktyk:
Stosowanie wielkich i małych liter w nazwach, np. CenaWSumie.
Stosowanie tylko małych liter, np. licznik.
Oddzielanie członów nazwy zmiennej znakiem podkreślenia, np. Cena_W_Sumie.
Poprzedzanie nazwy zmiennej znacznikiem typu danych; zmienna przechowująca liczbę może być nazwana iLicznik, natomiast zmienna przechowująca łańcuch znaków — sNazwisko.
W punkcie „Stosowanie konwencji nazewniczej” w dalszej części rozdziału znajdziesz szczegółowe omówienie zalet stosowania konwencji nazewniczej. Przyczyną wielu pomyłek popełnianych przez programistów Accessa jest to, że nazwy obiektów Accessa (tabel, kwerend, formularzy itp.) mogą zawierać spacje, natomiast nazwy zmiennych nie mogą ich zawierać. Jednym z powodów, dla których nie powinno stosować się spacji w nazwach obiektów Accessa, jest wyeliminowanie zamieszania, jakie może powstać w przypadku stosowania kilku różnych konwencji nazewniczych w jednej aplikacji. Lepiej zachować spójność nazewnictwa obiektów Accessa oraz zmiennych, procedur i innych elementów aplikacji. Podczas tworzenia zmiennej można korzystać tylko z wielkich liter, tylko z małych liter, albo z liter wielkich i małych. Wielkość liter w nazwach zmiennych VBA nie ma znaczenia. Oznacza to, że jeśli utworzysz zmienną DzisiajJest, możesz wywołać ją w dalszym fragmencie programu jako DZISIAJJEST, dzisiajjest albo dZisiAjJeST. Niezależnie od wielkości liter zawsze odwołasz się do tej samej zmiennej. Mechanizm języka VBA sam zmieni wielkość liter na taką, jaką zastosowano w deklaracji (instrukcji Dim).
Aby sprawdzić lub wykorzystać zawartość zmiennej, wystarczy posłużyć się jej nazwą. Program automatycznie odnajdzie w pamięci odpowiednie miejsce, w którym przechowywana jest wartość zmiennej o podanej nazwie, i pobierze ją. Oznacza to oczywiście, że programista musi zapamiętać i odpowiednio podać nazwę zmiennej.
Deklarowanie zmiennych Są dwa podstawowe sposoby dodawania zmiennych w aplikacji. Pierwsza metoda — nazywana deklaracją niejawną — polega na pozostawieniu zadania tworzenia zmiennych w gestii języka VBA. Podobnie jak w przypadku innych operacji, które nie są ściśle kontrolowane, pozostawienie mechanizmowi języka VBA zadania tworzenia zmiennych niekoniecznie jest dobrym pomysłem i nie prowadzi do uzyskania najlepszej wydajności bądź sprawności działania programów (porównanie niejawnego deklarowania zmiennych ze sposobami alternatywnymi można znaleźć w punkcie „Porównanie niejawnego i jawnego deklarowania zmiennych” w dalszej części tego rozdziału). Niejawne deklarowanie zmiennych oznacza, że język VBA automatycznie tworzy zmienną dla każdego identyfikatora, który został rozpoznany w aplikacji jako zmienna. Na poniższym listingu są dwie niejawnie zadeklarowane zmienne (sFirstName i sLastName). W tym fragmencie do dwóch zmiennych przechowujących łańcuchy znaków (sFirstName i sLastName) przypisywany jest tekst z dwóch pól tekstowych (txtFirstName i txtLastName).
Rozdział 24. Typy danych i procedury w języku VBA
731
Do trzeciej zmiennej (sFullName) kod przypisuje połączone wartości zmiennych sFirst Name i sLastName rozdzielone odstępem. Private Sub Combine_Implicit() sFirstName = Me.txtFirstName.Text sLastName = Me.txtLastName.Text sFullName = sFirstName & Space(1) & sLastName End Sub
Drugi sposób deklarowania zmiennych polega na ich jawnym zadeklarowaniu za pomocą jednego spośród następujących słów kluczowych: Dim, Static, Private lub Public (albo Global). Wybór słowa kluczowego ma decydujący wpływ na zasięg zmiennej w aplikacji oraz określa miejsca w programie, w których można korzystać ze zmiennej (zagadnienia związane z zasięgiem zmiennych omówiono w punkcie „Zasięg i czas życia zmiennych” w dalszej części tego rozdziału). Aby wymusić jawne deklarowanie zmiennych, dodaj dyrektywę Option Explicit na początku każdego modułu. Jeszcze lepszym rozwiązaniem jest zaznaczenie opcji Require Variable Declarations w oknie dialogowym Options edytora VBE. Wtedy dyrektywa Options Explicit będzie automatycznie umieszczana we wszystkich nowych modułach.
Składnia jawnego deklarowania zmiennych jest dość prosta: Dim NazwaZmiennej As TypDanych Static NazwaZmiennej As TypDanych Private NazwaZmiennej As TypDanych Public NazwaZmiennej As TypDanych
W każdym przypadku w deklaracji zmiennej występuje nazwa zmiennej oraz jej typ danych. W momencie wykonania instrukcji deklaracji zmiennej kompilator języka VBA rezerwuje ilość pamięci potrzebną do przechowania zmiennej. Po zadeklarowaniu zmiennej nie można zmienić jej typu danych. Dość łatwo można jednak przeprowadzić konwersję wartości zmiennej i przypisać wartość po konwersji do innej zmiennej. W przykładzie zamieszczonym poniżej przekształcono procedurę Combine_Implicit. W nowej wersji zmienne zadeklarowano jawnie. Private Sub Combine_Explicit() Dim sFistName As String Dim sLastName As String Dim sFullName As String sFirstName = Me.txtFirstName.Text sLastName = Me.txtLastName.Text sFullName = sFirstName & Space(1) & sLastName End Sub
A zatem, skoro najczęściej jest niewielka różnica pomiędzy używaniem niejawnie i jawnie zadeklarowanych zmiennych, po co w ogóle trudzić się deklarowaniem zmiennych? To, jak ważne jest jawne deklarowanie zmiennych w aplikacjach, zademonstrowano w poniższym przykładzie:
732
Część VI Podstawy programowania w Accessie Private Sub Form_Load() sDepartment = "Produkcja" sSupervisor = "Jan Jankowski" sTitle = "Starszy inżynier" 'Tutaj będzie bardzo wiele wierszy kodu Me.txtDepartment = sDepartment Me.txtSupervisor = sSuperviser Me.txtTitle = sTitle End Sub
Po wykonaniu tego kodu pole tekstowe txtSupervisor w formularzu pozostanie puste — nigdy nie zostanie do niego przypisana wartość. Pod koniec procedury do pola tekstowego txtSupervisor przypisano zmienną. Zwróćmy uwagę, że w nazwie zmiennej (sSuperviser) popełniono pomyłkę — chodziło o zmienną sSupervisor. Ponieważ kompilator języka VBA zinterpretował wyrażenie w instrukcji przypisania jako zmienną, utworzył nową zmienną typu variant o nazwie sSuperviser i przypisał jej wartość (nothing, czyli „nic”) do pola tekstowego txtSupervisor. Ponieważ do nowej zmiennej sSuperviser nigdy nie przypisano wartości, pole tekstowe pozostanie puste. Tego typu pomyłki w pisowni są bardzo częste, a w długich, złożonych procedurach bardzo łatwe do przeoczenia. Co więcej, kod pokazany w powyższym przykładzie uruchamia się bez problemów. Ponieważ w tej procedurze użyto niejawnych deklaracji zmiennych, Access nie zgłosi błędu z powodu pomyłki w pisowni i problem nie zostanie wykryty do czasu, kiedy ktoś nie zauważy, że pole tekstowe jest przez cały czas puste. Wyobraź sobie, jakie problemy mogą wystąpić w aplikacjach płacowych bądź bilingowych z powodu nieustawienia zmiennych w wyniku prostych pomyłek w pisowni nazw. Podczas deklarowania zmiennej Access rezerwuje odpowiednią ilość pamięci komputera. Pamięć jest rezerwowana w momencie deklaracji czyli przed przypisaniem zmiennej odpowiedniej wartości. Ilość tej pamięci zależy od typu danej, którą zmienna będzie przechowywać. Warto wiedzieć, że więcej pamięci potrzeba do przechowania wartości walutowej (np. 1 000 000 zł) niż do przechowania liczby całkowitej mniejszej od 255. Jest tak, ponieważ zmienna zadeklarowana z typem danych Currency wymaga więcej pamięci niż inna zmienna zadeklarowana jako Byte. Typy danych omówiono w dalszej części tego rozdziału, w podrozdziale „Typy danych”. Wprawdzie w języku VBA deklarowanie zmiennych przed ich użyciem nie jest obowiązkowe, to istnieje taka możliwość. Warto przyjąć zasadę, że wszystkie zmienne wykorzystane w tworzonym kodzie źródłowym będą zadeklarowane wcześniej. Jawna deklaracja zmiennej daje pewność, że będzie można jej przypisać tylko wartość typu wyznaczonego w momencie deklaracji (na przykład w danej zmiennej można przechowywać wartości liczbowe albo tylko wartości znakowe). Ponadto deklarując zmienne, można zwiększyć wydajność tworzonej aplikacji. Dobrą praktyką jest deklarowanie wszystkich zmiennych przed kodem procedury. Dzięki temu kod jest bardziej czytelny, co ma znaczenie dla programistów pracujących nad nim później.
Rozdział 24. Typy danych i procedury w języku VBA
733
Słowo kluczowe Dim Aby jawnie zadeklarować wartość, należy skorzystać z instrukcji Dim (Dim to skrót od archaicznego terminu związanego z programowaniem Dimension — wymiar — ponieważ deklarujemy wymiary zmiennej). W instrukcji tej należy podać nazwę deklarowanej zmiennej. Składnia instrukcji Dim wygląda następująco: Dim [NazwaZmiennej] [As TypDanych]
Poniżej znajduje się deklaracja przykładowej zmiennej typu Integer — iBeeps: Dim iBeeps As Integer
Nazwa deklarowanej zmiennej znajduje się tuż po słowie kluczowym Dim. Oprócz nazwy należy podać konstrukcję As TypDanych, aby określić typ danych zmiennej. Typ wyznacza, jakie wartości będą przechowywane w zmiennej: String (ciągi znaków), integer (liczby całkowite), currency (wartości walutowe) i tak dalej. Domyślnym typem danych jest Variant. Ten typ pozwala na przechowywanie w zadeklarowanej zmiennej wartości dowolnego typu. Listę wszystkich dostępnych typów danych znajdziesz w tabeli 24.1 w następnym podrozdziale. W przypadku zadeklarowania zmiennej za pomocą instrukcji Dim wewnątrz określonej procedury ze zmiennej można z niej korzystać tylko w tej procedurze. Inne procedury, nawet umieszczone w tym samym module, nie mają dostępu do tej zmiennej („nie wiedzą” o jej istnieniu). Takie zmienne często określa się jako zmienne lokalne — ponieważ są zadeklarowana lokalnie w obrębie procedury i są znane tylko przez procedurę, która jest ich „właścicielem” (więcej informacji na temat zasięgu zmiennych można znaleźć w punkcie „Zasięg i czas życia zmiennych” w dalszej części tego rozdziału). Zmienne można także zadeklarować w sekcji deklaracyjnej modułu. Takie zmienne można wykorzystać we wszystkich procedurach znajdujących się w module (wszystkie procedury będą „znać” te zmienne). Zmienne zadeklarowane w module nie mogą być wykorzystane w procedurach, które znajdują się poza tym modułem. W jednej instrukcji Dim można zadeklarować wiele zmiennych, jednak trzeba określić typ danych każdej z nich. Jeśli nie podasz typu danych, powstanie zmienna typu Variant. Instrukcja Dim sString1, sString2 As String spowoduje powstanie zmiennych sString1 (typu Variant) i sString2 (typu String). Poprawna postać tej instrukcji to Dim sString1 As String, sString2 As String. Powoduje ona powstanie dwóch zmiennych typu String.
Instrukcja Public Aby zmienna była dostępna we wszystkich modułach aplikacji, trzeba w trakcie jej deklarowania skorzystać ze słowa kluczowego Public. Deklarację zmiennej publicznej pokazano na rysunku 24.2. Nie można zadeklarować zmiennej publicznej wewnątrz procedury. Zmienna publiczna musi być zadeklarowana w sekcji deklaracyjnej modułu. W przypadku próby zadeklarowania zmiennej publicznej wewnątrz procedury wystąpi błąd.
734
Część VI Podstawy programowania w Accessie
Rysunek 24.2. Deklaracja zmiennej o dostępie publicznym
Zmienną publiczną można zadeklarować w dowolnym module znajdującym się w aplikacji, ale najczęściej deklaracje wszystkich zmiennych publicznych umieszcza się w jednym module standardowym, który służy tylko do przechowywania takich zmiennych. Choć czasem zmienne publiczne są potrzebne, nie należy ich nadużywać. Ponieważ wartość takiej zmiennej może zmienić dowolna procedura z projektu, czasem trudno jest wykryć, która procedura wprowadza niepożądane zmiany. Gdy wszystkie zmienne publiczne znajdują się w jednym miejscu, łatwo jest je znaleźć i stwierdzić, że jest ich zbyt wiele. Warto wtedy ponownie się zastanowić nad strukturą kodu. Zmienne publiczne można zadeklarować w module kodu dołączonym do formularza bądź raportu. Odwoływanie się do takich zmiennych publicznych z innego modułu nieco różni się od odwoływania się do zmiennych publicznych zadeklarowanych w modułach standardowych. Aby odwołać się do wartości zmiennej publicznej zadeklarowanej w formularzu lub raporcie z innego modułu, trzeba zastosować odwołanie poprzez nazwę obiektu formularza lub raportu. Na przykład frmFormularz Główny.MojaZmienna to odwołanie się do zmiennej o nazwie MojaZmienna zadeklarowanej w module z kodem formularza frmFormularzGłówny. Do zmiennych publicznych zadeklarowanych w modułach formularza lub raportu dostęp można uzyskać tylko po otwarciu danego formularza albo raportu.
Instrukcja Private W sekcji deklaracyjnej przedstawionej na rysunku 24.2 pokazano, jak wykorzystać słowo kluczowe Private w celu zadeklarowania zmiennych. Instrukcje Private i Dim działają prawie tak samo, jednak za pomocą instrukcji Private można zadeklarować na poziomie modułu zmienne, które mogą być wykorzystywane jedynie w procedurach danego modułu. Słowo kluczowe Private gwarantuje, że wszystkie procedury z danego modułu mogą korzystać z danej zmiennej, natomiast jest ona niedostępna dla procedur z pozostałych modułów. Deklarowanie zmiennych prywatnych różni się od innych metod deklarowania:
odróżnia się od deklaracji za pomocą instrukcji Dim (która musi się znajdować na poziomie procedury), dzięki czemu można łatwo stwierdzić, gdzie zadeklarowano zmienną i jaki jest jej zasięg (moduł lub procedura);
odróżnia się od deklaracji za pomocą instrukcji Public (również wykorzystywanej do deklaracji zmiennej wykorzystywanej w module), co poprawia czytelność kodu i ułatwia jego zrozumienie.
Rozdział 24. Typy danych i procedury w języku VBA
735
Sekcję deklaracyjną modułu można wyświetlić w trakcie tworzenia kodu źródłowego modułu formularza, wybierając opcję (General) z listy rozwijanej Object w edytorze kodu. Wartość na liście rozwijanej Procedure zmieni się wtedy na (Declarations). Wspomniane listy pokazano w oknie modułu widocznym na rysunku 24.2. Gdy na liście rozwijanej Object zaznaczony jest formant lub formularz, opcja Declarations nie jest dostępna.
W trakcie deklarowania zmiennej można skorzystać ze słowa kluczowego AS w celu jawnego określenia typu danych przechowywanych przez zmienną. Ponieważ Access jest systemem projektowania baz danych, nie powinno dziwić, że typy danych zmiennych są podobne do typów danych pól w tabelach baz danych Accessa.
Typy danych W trakcie deklaracji zmiennej od razu określa się jej typ danych. Każda zmienna ma typ danych, który określa rodzaj informacji przechowywanych w zmiennej. Zmienna typu String (ciąg znaków) pozwala przechowywać łańcuchy tekstowe złożone z dowolnych znaków (symboli z klawiatury i znaków dodatkowych). Po utworzeniu zmienne typu String można wykorzystywać na różne sposoby. Można porównywać ich zawartość z zawartością innych zmiennych, można pobrać fragment przechowywanej informacji i tak dalej. Zmiennej tekstowej (typu String) nie można zastosować do wykonania obliczeń matematycznych. 12 podstawowych typów dostępnych w języku VBA przedstawiono w tabeli 24.1. Najczęściej stosowane są wartości typu String, Date, Long, Currency i Double. Jeśli w określonej zmiennej będą zawsze przechowywane wartości całkowitoliczbowe z zakresu –32 768 do 32 767, to deklarując ją jako Integer, można zaoszczędzić kilka bajtów pamięci i przyspieszyć wykonywania operacji arytmetycznych. Jak duże są zmienne typu String? W tabeli 24.1 opisano, że mogą one obejmować dużo danych. Ile tekstu można umieścić w jednej zmiennej typu String w języku VBA? Słownik Oxford English Dictionary (OED) powszechnie uważa się za podstawowe źródło informacji o języku angielskim. Choć nie jest to największy słownik świata (holenderski Woordenboek de Nederlandsche Taal jest znacząco obszerniejszy), jego objętość jest naprawdę duża. Obejmuje ponad 301 000 głównych haseł, ma 22 000 stron i 59 000 000 słów. Drukowane wydanie słownika OED składa się z 20 tomów. Choć słownik ten jest bardzo duży, zajmuje tylko 540 megabajtów danych. Tak więc jedna zmienna typu String w języku VBA może pomieścić cztery kompletne egzemplarze słownika OED!
Aby przypisać wartość z pola bazy danych Accessa do zmiennej, najpierw należy sprawdzić, czy typ danych zmiennej pozwala na zapisanie typu danych pola. W tabeli 24.2 zamieszczono porównanie typów danych języka VBA z typami pól bazy danych Accessa. Po zapoznaniu się ze zmiennymi i typami danych można przejść do ich stosowania w tworzonych procedurach.
+/–79 228 162 514 264 337 593 543 950 335 (liczby całkowite), +/–7,9228162514264337593543950335 (wartości ułamkowe z 28 cyframi znaczącymi po przecinku) — najmniejsza wartość niezerowa to +/–0,0000000000000000000000000001
Liczba zapisana w 14 bajtach
Date
Od godziny 00:00:00 1 stycznia 100 roku do godziny 23:59:59 31 grudnia 9999 roku
8-bajtowa wartość data/czas
Double
Od –1,79769313486231E+308 do –4,94065645841247E–324 dla wartości ujemnych i od 4,94065645841247E–324 do 1,79769313486232E+308 dla wartości dodatnich
8-bajtowa liczba zmiennoprzecinkowa
Integer
Od –32 768 do 32 767
2-bajtowa liczba całkowita
Long
Od –2 147 483 648 do 2 147 483 647
4-bajtowa liczba całkowita
Object
Referencja do obiektu
4 bajty
Single
Od –3,402823E38 do –1,401298E–45 dla wartości ujemnych i od 1,401298E–45 do 3,402823E38 dla wartości dodatnich
4-bajtowa liczba zmiennoprzecinkowa
String (stała dł.)
Od 1 do około 65 400
Liczba znaków
String (zmienna dł.)
Od 0 do około 2 000 000 000 znaków
10 bajtów plus długość ciągu
Variant (dla znaków) Od 0 do około 2 000 000 000 znaków Variant (dla liczb)
Dowolna wartość liczbowa mieszcząca się w zakresie typu Double (opisanego wcześniej w tabeli)
22 bajty plus długość ciągu 16 bajtów
Rozdział 24. Typy danych i procedury w języku VBA
737
Tabela 24.2. Porównanie typów danych Accessa i zmiennych języka VBA Typ danych Accessa
Typ danych języka VBA
Załącznik
—
Autonumerowanie (liczba całkowita długa)
Long
Autonumerowanie (identyfikator replikacji)
—
Waluta
Currency
Obliczeniowy
—
Data/Godzina
Date
Długi tekst
String
Liczba (bajt)
Byte
Liczba (liczba całkowita)
Integer
Liczba (liczba całkowita długa)
Long
Liczba (pojedyncza precyzja)
Single
Liczba (podwójna precyzja)
Double
Liczba (identyfikator replikacji) Obiekt OLE
String
Krótki
String
Hiperłącze
String
Tak/Nie
Boolean
Porównanie niejawnego i jawnego deklarowania zmiennych Domyślny typ danych zmiennych języka VBA to Variant. Oznacza to, że jeśli jawnie nie zdefiniujesz typu, wszystkie zmienne w aplikacji będą typu Variant. Jak wspomniano wcześniej w tym rozdziale, typ danych Variant nie jest zbyt wydajny. Jego wymagania w zakresie miejsca na dysku są większe w porównaniu z odpowiadającymi mu typami danych (np. String), a poza tym komputer zużywa więcej czasu na śledzenie danych zapisanych jako typ Variant w porównaniu z innymi typami danych. Poniżej zaprezentowano przykład testowania różnicy w szybkości działania aplikacji dla przypadków używania zmiennych typu Variant deklarowanych niejawnie oraz zmiennych deklarowanych jawnie. Poniższy kod można znaleźć w module formularza frm ImplicitTest w bazie danych Rozdział24.accdb. 'Aby uzyskać dokładny pomiar czasu, można skorzystać z wywołań Windows API: Private Declare Function GetTickCount _ Lib "kernel32" () As Long Private Sub cmdGo_Click() Dim i As Integer
738
Część VI Podstawy programowania w Accessie Dim j As Integer Dim snExplicit As Single Me.txtImplicitStart.Value = GetTickCount() For o = 1 To 10000 For p = 1 To 10000 q = i / 0.33333 Next p Next o Me.txtImplicitEnd.Value = GetTickCount() Me.txtImplicitElapsed.Value = _ Me.txtImplicitEnd.Value – Me.txtImplicitStart.Value DoEvents 'Wymuszanie ukończenia przez Access oczekujących operacji Me.txtExplicitStart.Value = GetTickCount() For i = 1 To 10000 For j = 1 To 10000 snExplicit = i / 0.33333 Next j Next i Me.txtExplicitEnd.Value = GetTickCount() Me.txtExplicitElapsed.Value = _ Me.txtExplicitEnd.Value – Me.txtExplicitStart.Value DoEvents End Sub
W tym prostym teście wykonanie pętli, w której użyto zmiennych zadeklarowanych niejawnie, zajęło około 2,7 sekundy, podczas gdy pętla wykorzystująca zmienne zadeklarowane jawnie potrzebowała zaledwie 2,5 sekundy. A zatem samo użycie jawnie zadeklarowanych zmiennych poprawiło wydajność aplikacji o około 10%. Dokładny czas wykonania tej i innych procedur języka VBA w dużym stopniu zależy od szybkości komputera, a także zadań przetwarzanych przez maszynę w trakcie działania danej procedury. Komputery znacznie różnią się między sobą ze względu na szybkość procesora, ilość pamięci i inne zasoby. Dlatego nie da się przewidzieć, jak długo potrwa wykonywanie określonego fragmentu kodu.
Wymuszanie jawnego deklarowania zmiennych W Accessie jest dostępna prosta dyrektywa kompilatora, która wymusza jawne deklarowanie zmiennych w aplikacjach. Wstawienie instrukcji Option Explicit na początku modułu instruuje mechanizm obsługi języka VBA o obowiązku jawnego deklarowania wszystkich zmiennych w module. Jeśli na przykład pracujesz z aplikacją zawierającą szereg zadeklarowanych niejawnie zmiennych, to wstawienie instrukcji Option Explicit na początku każdego modułu spowoduje sprawdzenie wszystkich deklaracji zmiennych przy następnej kompilacji aplikacji.
Rozdział 24. Typy danych i procedury w języku VBA
739
Ponieważ jawne deklaracje są tak korzystne, nie ma się co dziwić, że w Accessie istnieje sposób automatycznego wymuszania jawnych deklaracji we wszystkich modułach w aplikacji. W zakładce Editor okna dialogowego Options pokazanego na rysunku 24.3 występuje pole wyboru Require Variable Declaration. Opcja ta automatycznie wstawia dyrektywę Option Explicit na początku każdego modułu utworzonego po ustawieniu tej opcji. Rysunek 24.3. Obowiązkowe deklarowanie zmiennych w większości aplikacji Accessa jest dobrym pomysłem
Opcja Require Variable Declaration nie ma wpływu na moduły napisane wcześniej. Opcja ta dotyczy wyłącznie modułów utworzonych po zaznaczeniu tej opcji, zatem we wszystkich istniejących wcześniej modułach trzeba jawnie wstawić dyrektywę Option Explicit. W obecnych wersjach Accessa opcja Require Variable Declaration domyślnie nie jest włączona. Musisz ją ustawić samodzielnie, jeśli chcesz, aby Access dodawał do wszystkich modułów dyrektywę Option Explicit.
Stosowanie konwencji nazewniczej Aplikacje napisane w języku VBA, podobnie jak i w innych językach programowania, zwykle są dosyć długie i złożone. Często jest to nawet kilka tysięcy wierszy kodu. Nawet proste programy w języku VBA mogą wymagać kilkuset różnych zmiennych. W formularzach VBA często występują dziesiątki różnych formantów, łącznie z polami tekstowymi, przyciskami poleceń, grupami opcji i innymi formantami. Śledzenie zmiennych, procedur, formularzy i formantów nawet w średnio skomplikowanej aplikacji VBA jest karkołomnym zadaniem. Jednym ze sposobów ułatwienia zarządzania kodem i obiektami w aplikacji jest zastosowanie konwencji nazewniczej. Jest to usystematyzowana metoda nadawania nazw obiektom i zmiennym w aplikacji. Najbardziej popularna konwencja nazewnicza stosowana w aplikacjach Accessa polega na wykorzystaniu przedrostka o długości od jednego do czterech znaków (znacznika) dołączonego do podstawowej nazwy obiektów i zmiennych w aplikacji VBA. Znacznik tworzony jest zwykle na podstawie typu formantu lub typu danych albo zasięgu zmiennej. Na przykład polu tekstowemu zawierającemu nazwisko osoby można nadać nazwę txtText Name, natomiast przyciskowi polecenia zamykającemu formularz można nadać nazwę cmdClose lub cmdCloseForm.
740
Część VI Podstawy programowania w Accessie
Dla nazw zmiennych stosuje się podobny wzorzec. Zmiennej tekstowej, w której zapisano nazwę klienta, można nadać nazwę sCustomer, natomiast zmienna logiczna, która informuje o tym, czy klient jest aktywny, może mieć nazwę bActive. Stosowanie konwencji nazewniczej nie jest trudne. W kodzie zamieszczonym w tej książce zastosowano prefiksy złożone z jednego (dla zmiennych) lub trzech znaków (dla formantów). Sama konwencja, którą wybierzesz, nie jest ważna. Istotne jest to, aby stosować ją spójnie. Gdy zaczniesz pisać większe ilości kodu VBA, zobaczysz, która najbardziej Ci odpowiada. Przykładową konwencję nazewniczą przedstawia tabela 24.3. Tabela 24.3. Przykładowa konwencja nazewnicza Formant lub typ danych
Przedrostek
Przykład
Formant: pole tekstowe
txt
txtFirstName
Formant: etykieta
lbl
lblFirstName
Formant: przycisk polecenia
cmd
cmdClose
Formant: ramka
frm
fmrOptions
Formant: Pole kombi
cbx
cbxCustomers
Formant: pole listy
lbx
lbxProducts
Formant: pole wyboru
chk
chkActive
Formant: przycisk opcji
opt
optFemale
Typ danych: Byte
bt
btCounter
Typ danych: Boolean
b
bActive
Typ danych: Integer
i
iCounter
Typ danych: Long
l
lCustomerID
Typ danych: Single
sn
snTaxRate
Typ danych: Double
d
dGrossPay
Typ danych: Currency
c
cNetSales
Typ danych: Date
dt
dtHired
Typ danych: Object
o
oControl
Typ danych: String
s
sLastName
Typ danych: Variant
v
vCompany
Zasięg: lokalny
Brak
sState
Zasięg: prywatny
m
msState
Zasięg: publiczny
g
gsState
Zaletą stosowania krótszych przedrostków dla zmiennych i dłuższych dla formantów jest to, że można łatwo odróżnić jedne od drugich w kodzie. Warto też zauważyć, że dla częściej stosowanych typów danych używane są przedrostki jednoznakowe. Zwykle
Rozdział 24. Typy danych i procedury w języku VBA
741
częściej używa się typu Boolean niż Byte, dlatego krótszy przedrostek dla zmiennych typu Boolean pozwala zmniejszyć liczbę wprowadzanych znaków. Niektórzy programiści w ogóle nie używają przedrostków dla zmiennych. Nie ma w tym nic złego. Jednak stosowanie przedrostków ma pewne zalety. Pierwsza z nich związana jest z możliwością określenia typu danych w miejscu używania zmiennej. Łatwo jest zauważyć, że instrukcja sCustomer = chkActive może prowadzić do problemów. Wiadomo, że zmienna sCustomer jest typu String, a chkActive to pole wyboru, które zwraca wartość logiczną. Inną zaletą stosowania przedrostków jest możliwość tworzenia niepowtarzalnych nazw. Warto przypomnieć, że zgodnie z regułami nazywania zmiennych wszystkie zmienne muszą mieć unikatowe nazwy. Ponadto nie można stosować zarezerwowanych słów kluczowych jako nazw. Oznacza to, że nie można utworzyć zmiennej typu Boolean o nazwie Print (taka zmienna mogłaby określać, czy należy wydrukować raport). Dzięki zastosowaniu przedrostka można utworzyć nazwę bPrint, która nie narusza żadnych reguł. Zastosowanie dodatkowego przedrostka dla zasięgu ma podobne zalety. Znajomość zasięgu zmiennej w danym fragmencie kodu pomaga w jego debugowaniu, gdy pojawią się problemy. Ponadto można stosować podobne zmienne o różnym zasięgu. Możliwe, że w kodzie na poziomie modułu używana jest zmienna prywatna mbIsEnabled, dostępna w całym module, natomiast w konkretnej procedurze stosowana jest dostępna tylko w niej zmienna bIsEnabled. Ostatnią zaletą posługiwania się konwencją nazewniczą jest to, że wykorzystanie wielkich i małych liter pozwala bardzo szybko wykryć błędy w pisowni nazw zmiennych. VBA zmienia wielkość liter w nazwach zmiennych, aby dostosować pisownię do tej z miejsca deklaracji. Jeśli zadeklarowałeś zmienną za pomocą instrukcji Dim sFirstName As String, a dalej wpisałeś wyrażenie sfirstname = "Janek" (z nazwą zapisaną samymi małymi literami), to gdy przejdziesz do następnego wiersza, wyrażenie przyjmie postać sFirst Name = "Janek". Tego typu natychmiastowe informacje pomagają wykryć błędy w pisowni, zanim doprowadzą do problemów.
Zasięg i czas życia zmiennych Zmienna to coś więcej niż proste repozytorium danych. Każda zmienna stanowi dynamiczną część aplikacji i można ją wykorzystać w różnych momentach wykonywania programu. Deklaracja zmiennej nie ogranicza się tylko do zdefiniowania jej nazwy i typu danych. W zależności od słowa kluczowego użytego do zadeklarowania zmiennej oraz lokalizacji deklaracji zmiennej w kodzie programu zmienna może być widoczna w dużych fragmentach kodu aplikacji. Natomiast inna lokalizacja może poważnie ograniczyć możliwości odwoływania się do zmiennej w procedurach wewnątrz aplikacji. Badanie zasięgu Widoczność zmiennej lub procedury określa się jako jej zasięg. O zmiennych, które są widoczne i mogą być używane w każdej procedurze w aplikacji, mówi się, że mają zasięg publiczny. Zmienne, których można używać we wszystkich procedurach modułu, mają zasięg prywatny, ograniczony do danego modułu. Zmienna dostępna tylko w jednej procedurze ma zasięg lokalny.
742
Część VI Podstawy programowania w Accessie
Jest wiele analogii do zasięgu publicznego i prywatnego. Na przykład firma posiada numer telefonu, który jest dostępny publicznie (główny numer centrali), zatem jest wymieniony w książce telefonicznej i w firmowej witrynie. Oprócz głównego numeru centrali każde biuro lub pokój w firmie może mieć własny numer wewnętrzny — prywatny wewnątrz firmy. Duży budynek biurowy będzie posiadał adres publiczny, znany wszystkim osobom przechodzącym obok budynku. Każde biuro lub ośrodek wewnątrz budynku może mieć numer, który jest prywatny wewnątrz tego budynku. Zmienne zadeklarowane wewnątrz procedury są lokalne w tej procedurze i nie można ich używać ani odwoływać się do nich poza tą procedurą. Na większości listingów w tym rozdziale użyto zmiennych zadeklarowanych wewnątrz procedur zdefiniowanych na tych listingach. W każdym przypadku do zdefiniowania zmiennej użyto słowa kluczowego Dim. Dim to instrukcja języka VBA, która powoduje przydzielenie ilości pamięci wystarczającej do zapisania zmiennej wymienionej za słowem kluczowym Dim. W związku z tym instrukcja Dim intMyInt As Integer przydziela mniej pamięci (2 bajty) niż instrukcja Dim dblMyDouble As Double (8 bajtów). Aby zmienna była widoczna w całej aplikacji, w jej deklaracji należy zastosować słowo kluczowe Public (lub Global). Można go używać wyłącznie na poziomie modułu — użycie go wewnątrz procedury jest niedozwolone. Najczęściej słowa kluczowego Public używa się w standardowych (samodzielnych) modułach, które nie są częścią formularza. Na rysunku 24.4 zaprezentowano zmienne zadeklarowane z wykorzystaniem trzech różnych zasięgów. Rysunek 24.4. Zasięg zmiennej określa się w jej deklaracji
Każda zmienna zadeklarowana w sekcji deklaracji standardowego modułu jest zmienną prywatną modułu, o ile w jej deklaracji nie użyto słowa kluczowego Public. Słowo kluczowe Private ogranicza widoczność zmiennej do modułu, w którym zmienną zadekla-
Rozdział 24. Typy danych i procedury w języku VBA
743
rowano. Na rysunku 24.4 zmienna gsAppName zadeklarowana z zasięgiem publicznym na początku modułu będzie widoczna w każdym miejscu aplikacji, natomiast zmienna mbIs Complete zadeklarowana w następnej instrukcji będzie dostępna tylko wewnątrz modułu. Zmienna sMessage jest zadeklarowana wewnątrz procedury, dlatego jest dostępna tylko w niej. Błędne zrozumienie zasięgu zmiennych jest częstą przyczyną poważnych błędów w wielu aplikacjach Accessa. Może się zdarzyć, że w projekcie VBA w Accessie znajdą się dwie zmienne o tej samej nazwie, ale o różnym zasięgu. Gdy sytuacja jest niejednoznaczna, Access wybiera najbliżej zadeklarowaną zmienną. Rozważmy dwie zmienne o nazwie MojaZmienna. Jedna z nich ma zasięg globalny (słowo kluczowe Public), natomiast druga jest zmienną z poziomu modułu zadeklarowaną za pomocą słowa kluczowego Private. W procedurach Access używa pierwszej lub drugiej z tych zmiennych. W module, w którym zmienna MojaZmienna nie jest zadeklarowana, Access korzysta ze zmiennej z modyfikatorem Public. Zmienna z modyfikatorem Private jest używana tylko w module obejmującym jej deklarację. Problem pojawia się, gdy zmienna o tej samej nazwie (np. zadeklarowana w kilku miejscach zmienna MojaZmienna) występuje w wielu procedurach. Jeśli programista nie sprawdził, która zmienna zostanie wykorzystana, może wystąpić poważny błąd. Procedura może zmienić wartość zmiennej publicznej używanej w aplikacji w dziesiątkach miejsc. Jeśli nawet jedna z procedur zmieni wartość zmiennej publicznej zamiast zmiennej lokalnej, wystąpi bardzo trudny do naprawienia błąd. Określanie czasu życia zmiennej Zmienne nie muszą być „obywatelami” zameldowanymi w aplikacji na stałe. Tak jak ich widoczność jest określona przez miejsce deklaracji, tak miejsce deklaracji określa również ich czas życia. Czas życia zmiennej decyduje o tym, kiedy jest ona dostępna w aplikacji. Domyślnie zmienne zadeklarowane na poziomie procedury istnieją tylko podczas jej wykonywania. Kiedy procedura kończy działanie, zmienna jest usuwana z pamięci i nie jest już dłużej dostępna. Jak powiedziano już wcześniej, zasięg zmiennych zdefiniowanych na poziomie procedury jest ograniczony do tej procedury i nie można go rozszerzyć poza jej granice. Zmienna zadeklarowana w sekcji deklaracji modułu formularza istnieje tak długo, jak długo formularz jest otwarty. Nie ma przy tym znaczenia, jak zadeklarowano tę zmienną (jako publiczną, prywatną, za pomocą słowa kluczowego Dim itd.). Wszystkie procedury wewnątrz modułu formularza mogą korzystać ze zmiennych poziomu modułu. Wszystkie one współdzielą wartość przypisaną do zmiennej. W momencie zamknięcia formularza i usunięcia go z pamięci usunięte będą także wszystkie zmienne zdefiniowane w jego module. Najdłuższym czasem życia charakteryzują się zmienne zadeklarowane jako publiczne w modułach standardowych. Są one dostępne natychmiast po uruchomieniu aplikacji VBA, aż do momentu zamknięcia programu i usunięcia go z pamięci. Z tego względu zmienne publiczne zachowują swoje wartości we wszystkich miejscach w aplikacji i są
744
Część VI Podstawy programowania w Accessie
dostępne dla wszystkich procedur wewnątrz programu. Zmienne prywatne (zadeklarowane ze słowem kluczowym Private) zdefiniowane na początku modułów standardowych są dostępne przez cały czas działania aplikacji, ale zgodnie z regułami zasięgu zmiennych są dostępne tylko w obrębie modułu. Jest jeden istotny wyjątek od ogólnej zasady, która mówi, że zmienne zdefiniowane na poziomie procedury trwają tylko tak długo, jak długo działa procedura. Zastosowanie słowa kluczowego Static powoduje, że zmienna zostaje zachowana pomiędzy wywołaniami procedur. Po przypisaniu wartości do zmiennej statycznej zmienna ta utrzymuje wartość do czasu jej modyfikacji w innym wywołaniu procedury. Alternatywą do używania zmiennych statycznych jest zadeklarowanie globalnej zmiennej na poziomie modułu i używanie jej przy każdym wywołaniu określonej procedury. Problem przy takim podejściu polega na tym, że zmienna globalna zdefiniowana na poziomie modułu jest dostępna także w innych procedurach, które również mogą ją modyfikować. Nieumyślne zmodyfikowanie wartości zmiennej globalnej w nieodpowiedni sposób może spowodować niepożądane efekty uboczne. Dzięki temu, że zasięg zmiennych statycznych jest ograniczony do procedur, są one jednym ze sposobów uniknięcia efektów ubocznych. Zdefiniowanie procedury jako statycznej powoduje, że wszystkie zdefiniowane w niej zmienne również stają się statyczne. Na poniższym listingu obie zmienne (lStatic oraz lLocal) zdefiniowane w procedurze StaticTest są statyczne, pomimo że zadeklarowano je lokalnie wewnątrz procedury. Zastosowanie słowa kluczowego Static w nagłówku procedury powoduje, że obie zmienne są statyczne. Private Static Sub StaticTest() ' Obie zmienne są statyczne, ponieważ w deklaracji ' procedury zastosowano słowo kluczowe "Static" Static lStatic As Long Dim lLocal As Long lStatic = lStatic + 1 lLocal = lLocal + 1 Me.txtLocal.Value = lLocal Me.txtStatic.Value = lStatic End Sub
Ustalanie zasięgu zmiennych Wiesz już, w jaki sposób deklaracja wpływa na zasięg i czas życia zmiennej. Być może się zastanawiasz, jak określić zasięg konkretnej zmiennej. Odpowiedź jest prosta: zawsze maksymalnie ograniczaj zasięg zmiennych. Oznacza to, że większość zmiennych powinna być dostępna tylko na poziomie procedury i należy je deklarować za pomocą słowa kluczowego Dim. Jeśli stwierdzisz, że chcesz zachować wartość zmiennej i wykorzystać ją przy następnym wywołaniu procedury, zmień instrukcję Dim na Static. Dzięki temu zwiększysz czas życia zmiennej, ale już nie jej zasięg. Ograniczenie zasięgu pomaga zmniejszyć liczbę miejsc, w których zmienna może zostać zmodyfikowana. Dzięki temu można łatwiej wykryć źródło problemów, gdy się pojawią.
Rozdział 24. Typy danych i procedury w języku VBA
745
Jeśli zmienna jest potrzebna także w innej procedurze z tego samego modułu, możesz przekazać zmienną do tej procedury jako parametr (parametry omawiamy w dalszej części rozdziału). Zmienna przekazywana jako parametr jest lokalna w procedurze, w której ją zadeklarowano, oraz w procedurze, do której jest przekazywana. W pozostałych procedurach jest niedostępna. Jeśli wartość zmiennej nieoczekiwanie się zmieni, będziesz musiał sprawdzić tylko dwie procedury, aby odkryć przyczynę problemu. Czasem zmienne są przekazywane między procedurami z tego samego modułu. Jeśli ta sama zmienna jest używana w większej liczbie procedur z modułu, można pomyśleć o przekształceniu jej na zmienną prywatną tego modułu. Następny poziom zwiększania zasięgu zmiennej związany jest sytuacją, gdy zmienna potrzebna jest w procedurze spoza macierzystego modułu. Wtedy kusząca jest myśl o utworzeniu zmiennej globalnej (za pomocą słowa kluczowego Public). Jeśli jednak trzymać się zasady maksymalnego ograniczania zasięgu zmiennej, można zastosować kilka innych rozwiązań. Przede wszystkim zastanów się, czy nie umieścić owej innej procedury w module, w którym zadeklarowano zmienną. Moduły powinny zawierać powiązane procedury, dlatego możliwe, że zewnętrzną procedurę warto przenieść. W przeciwnym razie pomyśl o przekazywaniu zmiennej do innej procedury jako parametru. Jeśli zmienna z poziomu modułu jest przekazywana do procedury spoza niego, można z niej korzystać w macierzystym module i tylko jednej zewnętrznej procedurze (tej, do której zmienna jest przekazywana). Zasięg takiej zmiennej jest większy niż we wcześniej opisanych sytuacjach, ale nadal maksymalnie ograniczony. Zmienne globalne, deklarowane w standardowym module za pomocą słowa kluczowego Public, należy stosować jak najrzadziej. Jednak w niemal każdym projekcie występuje przynajmniej jedna zmienna globalna. Nazwa aplikacji, wersja aplikacji i wartość logiczna określająca, czy bieżący użytkownik ma specjalne uprawnienia, to przykładowe dane, które sensownie jest przechowywać w zmiennych globalnych.
Stosowanie stałych Stałe różnią się od zmiennych w jednej ważnej kwestii: nigdy nie zmieniają wartości. Wartość jest przypisywana do zmiennej w miejscu deklaracji, a późniejsze próby zmiany wartości w kodzie prowadzą do wystąpienia błędu. Deklarowanie stałych Stałe deklaruje się za pomocą słowa kluczowego Const. Składnia deklaracji stałych wygląda następująco: [Public | Private] Const NazwaStałej [As TypDanych] = WartośćStałej
Stosowanie stałych pozwala poprawić czytelność kodu. Stałe pomagają też unikać błędów, jeśli potrzebujesz tej samej wartości w więcej niż jednym miejscu. Rysunek 24.5 przedstawia procedurę używającą stałej. Gdyby w procedurze z rysunku 24.5 nie zastosowano stałej określającej poziom rabatu, potrzebny byłby wiersz podobny do poniższego: dFinalPrice = dFullPrice * (1 – 0.15)
746
Część VI Podstawy programowania w Accessie
Rysunek 24.5. Do deklarowania stałych służy słowo kluczowe Const
Z uwagi na nazwy zmiennych mógłbyś się domyślić, że 0.15 to poziom rabatu. Jednak dzięki zastosowaniu stałej dDISCOUNT przeznaczenie danej wartości staje się oczywiste dla każdej osoby czytającej ten kod. Zasięg i czas życia stałych jest bardzo podobny jak w przypadku zmiennych. Stałe zadeklarowane w procedurze są dostępne tylko w niej. Stałe zadeklarowane za pomocą słowa kluczowego Private w module są dostępne we wszystkich procedurach z tego modułu, natomiast nie można ich używać w procedurach z innych modułów. Stałe globalne, deklarowane przy użyciu słowa kluczowego Public, są dostępne w całym projekcie. Wartości stałych nigdy się nie zmieniają, dlatego w deklaracjach stałych słowo Static jest niedostępne (i niepotrzebne). Konwencje nazewnicze dla stałych Dobrą praktyką jest stosowanie dla stałych tych samych konwencji nazewniczych co dla zmiennych. Poprzedzanie nazwy stałej przedrostkiem g (dla stałych publicznych) lub m (dla stałych prywatnych) pozwala szybko ustalić zasięg stałej. Ponadto przedrostek określający typ danych stałej pomaga zachować niepowtarzalność nazw i zapobiec błędom (np. użyciu stałej typu String w obliczeniach matematycznych). Na rysunku 24.5 nazwa stałej składa się z samych wielkich liter (oprócz przedrostka), nie jest to jednak wymóg. Nazwy stałych mogą zawierać dowolną kombinację wielkich i małych liter. Reguły dotyczące nazw zmiennych i procedur obowiązują także przy tworzeniu nazw stałych. Wielu programistów używa w nazwach stałych samych wielkich liter: dFinalPrice = dFullPrice * (1 – dDISCOUNT)
W powyższym wierszu kodu łatwo jest stwierdzić, co jest zmienną, a co stałą. Wynika to z zastosowania połączenia wielkich i małych liter w nazwach zmiennych oraz samych wielkich liter w nazwie stałej.
Rozdział 24. Typy danych i procedury w języku VBA
747
Stosowanie stałych globalnych (w odróżnieniu od używania zmiennych globalnych) nie utrudnia zarządzania kodem. Wartości stałych nigdy się nie zmieniają, dlatego nie trzeba sprawdzać, w których procedurach są używane. Podobnie jak przy stosowaniu zmiennych warto umieścić stałe globalne w jednym module, przeznaczonym tylko na zmienne i stałe globalne. Jeśli znajdziesz w projekcie moduł modGlobals, możesz przyjąć, że utworzył go programista stosujący to podejście. Usuwanie wartości zapisanych na stałe Wartości stosowane w procedurach czasem nazywa się magicznymi liczbami. Pojęcie to nie oznacza, że wartości te mają wyjątkowe zastosowania, lecz to, że inny programista czytający kod może mieć problemy ze zrozumieniem ich przeznaczenia. Inny programista (a nawet autor kodu po kilku miesiącach lub latach od jego napisania) może uznać, że liczby pojawiają się w magiczny, niewyjaśniony sposób. Wielu programistów stara się usuwać z kodu magiczne liczby (z wyjątkiem wartości 0 i 1 oraz liczb przypisywanych do zmiennych). Dzięki temu kod jest uporządkowany i łatwy w konserwacji. Sub DiscountedAmount2() Dim dFullPrice As Double Dim dFinalPrice As Double Const dDISCOUNT As Double = 0.15 Const dDISCTHRESHOLD As Double = 5000 Const sPROMPT As String = "Cena wynosi " dFullPrice = 8000 If dFullPrice > dDISCTHRESHOLD Then dFinalPrice = dFullPrice * (1 - dDISCOUNT) Else dFinalPrice = dFullPrice End If MsgBox sPROMPT & dFinalPrice End Sub
W tej wersji procedury z rysunku 24.5 usunięto magiczne liczby. Jeśli chcesz zmienić wyświetlany komunikat, procent rabatu lub minimalną cenę, nie musisz szukać w kodzie wystąpień tych wartości. Wszystkie ważne wartości używane w procedurze znajdują się w instrukcjach Const sekcji deklaracji. Zmiana wartości w instrukcji Const powoduje zmodyfikowanie jej we wszystkich miejscach procedury. Wiersz If dFullPrice > dDISCTHRESHOLD jest łatwiejszy do zrozumienia niż wiersz z porównaniem pełnej ceny do ceny minimalnej. Może się jednak zdarzyć, że programista przesadzi z eliminowaniem magicznych liczb. Najlepiej jest zastosować stałe dla każdej wartości używanej więcej niż raz, a następnie ponownie przeczytać kod i ustalić, czy opisowe nazwy będą lepsze od magicznych liczb.
Stosowanie tablic Tablice to zmienne specjalnego rodzaju. Jedna zmienna tablicowa może zawierać wiele danych. Dla tablic rezerwowanych jest kilka bloków pamięci (inaczej niż dla zwykłych zmiennych, dla których rezerwowany jest tylko jeden blok). Tablice mogą mieć rozmiar
748
Część VI Podstawy programowania w Accessie
stały lub dynamiczny. Rozmiar tablic dynamicznych można zwiększać lub zmniejszać w procedurze. Tablice o stałej wielkości W deklaracji tablicy o stałej wielkości trzeba określić wielkość w instrukcji Dim. Później wielkości tej nie można zmienić. Najprostszy sposób deklarowania tablic o stałej wielkości polega na podaniu maksymalnego indeksu w nawiasach po nazwie zmiennej. Dim aCustomers(10) as Long
Tu aCustomers to tablica, która może przechowywać 11 liczb typu Long (np. z pola CustomerID). Dlaczego 11? Domyślnie najmniejszy indeks tablic deklarowanych w ten sposób to 0. Oznacza to, że wartości można zapisywać w elementach aCustomers(0), aCustomers(1) itd. — aż do aCustomers(10). Inny sposób deklarowania tablic o stałej wielkości polega na określeniu dolnego i górnego indeksu. Podawanie obu indeksów w deklaracjach — nawet jeśli się stosuje ustawienia domyślne — to dobry zwyczaj. Aby określić dolny i górny indeks tablicy, należy zastosować słowo kluczowe To. Dim aCustomers(1 to 10) as Long
Ta tablica, w odróżnieniu od poprzedniej, może zawierać tylko 10 liczb typu Long. Liczby tego typu zajmują po 8 bajtów pamięci, tak więc dla tablicy zadeklarowanej w ten sposób rezerwowanych jest 80 bajtów, w których można zapisać wszystkie 10 wartości. Pamięć jest zajmowana w momencie deklaracji, dlatego nawet jeśli program nie przypisze do tablicy żadnych wartości, pamięć zostanie zużyta. Jeśli aplikacja jest niewydajna lub zajmuje dużo pamięci, można sprawdzić, czy używane tablice nie są niepotrzebnie długie. Jednak w nowoczesnych komputerach 80 bajtów zwykle nie ma większego znaczenia. Wartości do tablic przypisuje się podobnie jak do innych zmiennych, przy czym trzeba podać indeks elementu, w którym zapisywana jest wartość. Poniższa procedura przypisuje w pętli liczby typu Long do tablicy. Sub ArrayAssignment() Dim aCustomers(1 To 5) As Double aCustomers(1) aCustomers(2) aCustomers(3) aCustomers(4) aCustomers(5)
= = = = =
0.2 24.6 7.1 99.9 14.7
End Sub
Nazwa tablicy (podobnie jak innych zmiennych) znajduje się po lewej stronie znaku równości, a wartość należy podać po prawej. Jednak — inaczej niż w przypadku zmiennych — w każdej operacji przypisania należy określić indeks elementu tablicy, w którym wartość jest zapisywana.
Rozdział 24. Typy danych i procedury w języku VBA
749
W języku VBA dostępna jest dyrektywa Option Base służąca do ustawiania domyślnego indeksu dolnego. Jeśli umieścisz dyrektywę Option Base 1 na początku modułu, domyślnie dolnym indeksem będzie 1. W tablicach deklarowanych z dolnym i górnym indeksem dyrektywa Option Base jest ignorowana. Dyrektywa ta dotyczy tylko modułu, w którym ją zadeklarowano.
Odczyt wartości z tablic odbywa się w podobny sposób jak odczyt wartości ze zmiennych — wystarczy podać nazwę zmiennej. W przypadku tablic zawsze trzeba określić też indeks wczytywanego elementu. Poniższa procedura zapisuje w tablicy pięć losowych liczb, mnoży je przez 10, a następnie wyświetla w oknie Immediate. Sub ArrayRandom() Dim aRandom(1 To 5) As Double Dim i As Long For i = 1 To 5 aRandom(i) = Rnd Next i For i = 1 To 5 aRandom(i) = aRandom(i) * 10 Next i For i = 1 To 5 Debug.Print aRandom(i) Next i End Sub
Ponieważ kolejne indeksy tablic są większe o jeden, do przechodzenia po wszystkich elementach tablic często służą pętle For…Next. Tablice omawiane do tego miejsca to tablice jednowymiarowe. Przypominają one listy — mają wiele wierszy, ale tylko jedną kolumnę. Można też tworzyć tablice dwuwymiarowe, które przypominają tabele — mają wiele wierszy i wiele kolumn. Aby zadeklarować tablicę dwuwymiarową, należy rozdzielić indeksy graniczne wymiaru pierwszego od indeksów granicznych drugiego. Dim aContact(1 to 10, 1 to 3) As String
W tablicy aContact znajduje się 30 miejsc na dane. W tej tablicy można zapisać po trzy informacje na temat 10 kontaktów. Odczyt i zapis dla tablic dwuwymiarowych wymaga podania indeksów obu wymiarów. Sub TwoDArray() Dim aPotus(1 To 2, 1 To 3) Dim i As Long aPotus(1, aPotus(1, aPotus(1, aPotus(2, aPotus(2, aPotus(2,
Część VI Podstawy programowania w Accessie For i = 1 To 2 Debug.Print aPotus(i, 1) & Space(1) & aPotus(i, 2) & Space(1) & _ "był prezydentem w latach" & Space(1) & aPotus(i, 3) Next i End Sub
Można też tworzyć tablice o więcej niż dwóch wymiarach, jednak zarządzanie nimi jest bardzo trudne. Jeśli chcesz przechowywać duże ilości danych, pomyśl o zastosowaniu własnego typu lub niestandardowego modułu klasy.
Tablice dynamiczne Tablice dynamiczne deklarowane są bez indeksów. Rozmiar takich tablic można zmieniać w procedurze. Oprócz braku indeksów deklaracja tablicy dynamicznej wygląda tak samo jak tablicy o stałej wielkości. Dim aProductIDs() as Long
Przy deklarowaniu tablicy dynamicznej nie trzeba zajmować pamięci do momentu zainicjowania tablicy i podania jej wymiarów. Aby móc przypisywać wartości do takiej tablicy, trzeba ją najpierw zainicjować. Do inicjowania tablic dynamicznych służy słowo kluczowe ReDim: ReDim aProductIDs(1 to 100)
Warto zauważyć, że w instrukcji ReDim nie określono typu danych. Jest on ustawiany w deklaracji i nie można go zmienić. Tablice dynamiczne należy stosować, gdy wielkość tablicy jest ustalana dopiero w czasie wykonywania programu. Tu w tablicy umieszczane są nazwy wszystkich otwartych formularzy bazy danych. Ponieważ nie wiadomo z góry, ile formularzy będzie otwartych, należy zadeklarować tablicę dynamiczną i zmienić jej wielkość w trakcie wykonywania procedury. Sub FormArray() Dim Dim Dim Dim
aForms() As String frm As Form lFrmCnt As Long i As Long
ReDim aForms(1 To Application.Forms.Count) For Each frm In Application.Forms lFrmCnt = lFrmCnt + 1 aForms(lFrmCnt) = frm.Name Next frm For i = LBound(aForms) To UBound(aForms) Debug.Print aForms(i) & “ is open.” Next i End Sub
Rozdział 24. Typy danych i procedury w języku VBA
751
Do określania wielkości tablic dynamicznych używana jest tu właściwość Forms.Count. Następnie w pętli For…Each procedura umieszcza nazwę każdego otwartego formularza w innym elemencie tablicy. W ostatnim kroku procedura przechodzi w pętli po elementach tablicy i wyświetla nazwę każdego formularza w oknie Immediate. Jeśli znasz rozmiar tablicy w czasie projektowania aplikacji, najlepiej jest utworzyć tablicę o stałej wielkości. Jeżeli musisz zastosować tablicę dynamiczną, najwyższą wydajność uzyskasz, gdy określisz potrzebną wielkość tablicy i wywołasz polecenie ReDim, aby zmienić rozmiar tablicy. Jednak czasem liczba elementów jest ustalana dopiero w momencie zapełniania nimi tablicy. W języku VBA dostępne jest słowo kluczowe Preserve, które pozwala zmienić wielkość tablicy bez utraty zapisanych w niej danych. Gdy wywołasz instrukcję ReDim bez słowa kluczowego Preserve, rozmiar tablicy się zmieni, jednak zostanie ona ponownie zainicjowana, co spowoduje utratę wszelkich zapisanych w niej danych. ReDim Preserve aCustomerIDs(1 to x) As Long
Słowo kluczowe Preserve powoduje utworzenie nowej tablicy o nowym rozmiarze i skopiowanie wszystkich danych ze starej tablicy do nowej. Jest to bardzo niewydajna operacja nawet dla tablic o umiarkowanej wielkości, dlatego słowo kluczowe Preserve należy stosować tylko wtedy, gdy nie ma innej możliwości. Funkcje dla tablic W języku VBA dostępnych jest kilka przydatnych funkcji do manipulowania tablicami. Nie ma tu miejsca na omówienie każdej z nich, jednak proponujemy Ci przegląd najprzydatniejszych i najciekawszych funkcji tego rodzaju. Funkcje do sprawdzania rozmiarów tablic
VBA udostępnia dwie funkcje (LBound i UBound) do określania wielkości tablic. Funkcja LBound zwraca dolny indeks, natomiast UBound — górny. Funkcje te są najprzydatniejsze przy przechodzeniu w pętli po wszystkich elementach tablicy. For i = LBound(aContacts) To UBound(aContacts) Debug.Print aContacts(i) Next i
Jeśli tablicę aContacts zadeklarowano za pomocą instrukcji Dim aContacts(1 to 5) As String, wywołanie LBound zwróci 1, a UBound — 5. Przydatność tych funkcji stanie się widoczna, gdy zmienisz deklarację na Dim aContacts(1 to 6) As String. Gdyby dolny i górny indeks zapisano na stałe w instrukcji For…Next, konieczna byłaby zmiana indeksu górnego w dwóch miejscach. Dzięki zastosowaniu wywołań LBound i UBound wystarczy zmodyfikować instrukcję Dim. Przy stosowaniu tablic dwuwymiarowych funkcje LBound i UBound wymagają podania drugiego argumentu (określa on wymiar). Poniżej pokazano typowy sposób przechodzenia w pętli po wszystkich elementach tablicy dwuwymiarowej: For i = LBound(aBounds, 1) To UBound(aBounds, 1) For j = LBound(aBounds, 2) To UBound(aBounds, 2) Debug.Print aBounds(i, j) Next j Next i
752
Część VI Podstawy programowania w Accessie Funkcja Array
Funkcja Array umożliwia utworzenie tablicy przez podanie wszystkich jej wartości w jednej instrukcji. Tablica zwracana przez tę funkcję to tablica typu Variant (obiekt Variant przechowujący tablicę). Aby zapisać wynik zwrócony przez funkcję Array do zmiennej, trzeba użyć zmiennej typu Variant. Argumenty funkcji Array należy rozdzielić przecinkami. Każdy argument staje się elementem tablicy. Sub ArrayFunction() Dim vaRates As Variant Dim i As Long vaRates = Array(0.05, 0.055, 0.06, 0.065, 0.07) For i = LBound(vaRates) To UBound(vaRates) Debug.Print vaRates(i) Next i End Sub
W tym przykładzie zmienna vaRates jest typu Variant i zawiera pięcioelementową tablicę z pięcioma liczbami zwróconymi przez funkcję Array. Ponieważ zmienna jest typu Variant, nie trzeba wcześniej podawać wielkości tablicy. Liczba argumentów w funkcji Array wyznacza rozmiar tablicy. Dlatego dolny i górny indeks są określane przez VBA. Domyślny indeks dolny to zero, a domyślny indeks górny jest o 1 mniejszy od liczby argumentów funkcji Array. W tablicy vaRates z przykładowego kodu te indeksy to 0 i 4. Dolny indeks tablicy zwracanej przez funkcję Array zależy od dyrektywy Option Base podanej na początku modułu (jeśli programista ją zastosował). Funkcja Array zwraca tablicę typu Variant — obiekt Variant zawierający tablicę. Można też zadeklarować tablicę elementów typu Variant. Może to być stała lub dynamiczna tablica, której elementy są typu Variant. Tablica typu Variant i tablica elementów typu Variant to dwa różne rodzaje tablic. Funkcja Split
Funkcja Split przekształca tekst na tablicę typu Variant. VBA nie potrafi z góry określić wielkości tablicy zwracanej przez funkcję Split, dlatego zmienną przechowującą taką tablicę musi być typu Variant. Składnia funkcji Split wygląda tak: Split(łańcuch_znaków, [ogranicznik],[limit],[porównania])
Pierwszy argument to łańcuch znaków rozdzielany do tablicy. Argument ogranicznik informuje funkcję Split, które znaki wyznaczają miejsca podziału łańcucha. Argument limit wyznacza maksymalną wielkość tablicy. Po dojściu do limitu funkcja Split kończy dzielenie łańcucha znaków, nawet jeśli pozostały w nim dalsze ograniczniki. Sub TheSplitFunction() Dim vaWords As Variant Dim i As Long vaWords = Split("To już ta godzina.", Space(1))
Rozdział 24. Typy danych i procedury w języku VBA
753
For i = LBound(vaWords) To UBound(vaWords) Debug.Print vaWords(i) Next i End Sub
Zmienna vaWords to tablica typu Variant zawierająca cztery elementy — To, już, ta i godzina.. Ogranicznik (tu jest nim spacja) nie jest jednym z elementów. Kropka po słowie „godzina” jest uwzględniana, dlatego ostatni element to godzina. (z kropką), a nie godzina (bez kropki). Funkcja Join
Funkcja Join działa odwrotnie do funkcji Split — przyjmuje tablicę i zwraca łańcuch znaków. Oto składnia funkcji Join: Join(źródłowa_tablica, [ogranicznik])
Pierwszym argumentem jest jednowymiarowa tablica przekształcana na łańcuch znaków. Źródłową tablicą może być element dowolnego typu (nawet liczba lub data), który VBA potrafi przekształcić na typ String. Argument ogranicznik to znak (lub znaki) wstawiany między elementy tablicy. Sub TheJoinFunction() Dim sResult As String Dim aWords(1 To 5) As String aWords(1) aWords(2) aWords(3) aWords(4) aWords(5)
= = = = =
"Król" "Karol" "kupił" "królowej" "Karolinie"
sResult = Join(aWords, Space(1)) Debug.Print sResult End Sub
W zmiennej sResult znajdzie się łańcuch znaków Król Karol kupił królowej Karolinie. Elementy tablicy są złączane ze sobą, a pomiędzy nimi umieszczany jest ogranicznik.
Procedury Sub i funkcje Kod w aplikacjach VBA jest zapisany w kontenerach zwanych modułami. Jak opisano w rozdziale 23., moduły w aplikacjach Accessa można zdefiniować na poziomie formularzy i raportów albo jako samodzielne jednostki. Moduły zawierają procedury, zmienne i deklaracje stałych, a także inne dyrektywy dla mechanizmu obsługi języka VBA. Kod wewnątrz modułów składa się z procedur. W języku VBA są dwa główne typy procedur: podprogramy, czyli inaczej procedury Sub oraz funkcje.
754
Część VI Podstawy programowania w Accessie
Oto kilka ogólnych reguł dotyczących procedur:
Procedura musi mieć unikatową nazwę w swoim zasięgu (zobacz punkt „Zasięg i czas życia zmiennych” wcześniej w tym rozdziale). Chociaż nie jest to dobry pomysł ze względu na możliwość wprowadzenia w błąd kompilatora VBA oraz osób pracujących nad kodem, istnieje możliwość zdefiniowania więcej niż jednej procedury o tej samej nazwie, o ile nazwa ta jest niepowtarzalna w zasięgu każdej z procedur.
Nazwa przypisana do procedury nie może być taka sama jak słowo kluczowe VBA.
Nazwa procedury musi być różna od nazwy modułu. Jest to jedna z sytuacji, gdy konwencje nazewnicze są bardzo przydatne. Jeśli zawsze poprzedzasz nazwę modułu przedrostkiem bas lub mod, unikasz błędu związanego z utworzeniem procedury i modułu o identycznej nazwie.
W procedurze nie można zdefiniować innych procedur. W procedurze można jednak w dowolnym momencie wywołać inną procedurę i w ten sposób wykonać jej kod.
W związku z regułami dotyczącymi zasięgu procedur niedozwolone jest występowanie dwóch procedur o dostępie publicznym i nazwie MojaProcedura. Mogą jednak występować dwie prywatne procedury MojaProcedura lub jedna publiczna procedura o tej nazwie i jedna prywatna (choć nie mogą one znajdować się w jednym module). Przyczyny, dla których złym pomysłem jest nadanie dwóm procedurom tej samej nazwy, nawet jeśli mają różny zasięg, są oczywiste. W poniższych punktach opisano niektóre specyficzne zagadnienia dotyczące procedur VBA. Planowanie i komponowanie procedur w modułach to najbardziej czasochłonna część pracy z kodem VBA. Z tego względu należy zdać sobie sprawę z miejsca, jakie zajmują procedury w ogólnym schemacie projektowania aplikacji. W dalszych punktach opisaliśmy pewne kwestie dotyczące procedur języka VBA. Planowanie i tworzenie procedur umieszczanych w modułach jest jednym z najbardziej czasochłonnych aspektów korzystania z języka VBA, dlatego ważne jest, aby zrozumieć funkcję procedur w ogólnym modelu tworzenia aplikacji. Zarówno w procedurach Sub, jak i w funkcjach znajduje się kod, który można uruchomić. Uruchomienie procedury lub funkcji można nazwać również wywołaniem. Wywołanie lub uruchomienie to pojęcia oznaczające wykonanie instrukcji (lub wierszy kodu) w procedurze Sub lub funkcji. Wszystkie wspomniane terminy są stosowane zamiennie przez programistów. Niezależnie od sposobu wywołania procedury VBA — za pomocą słowa kluczowego Call, poprzez odwołanie się do procedury za pomocą nazwy czy też uruchomienie jej z okna Immediate — za każdym razem wykonywana jest ta sama operacja: przetworzenie, uruchomienie lub wywołanie pewnej grupy instrukcji kodu źródłowego. Jedyną różnicą pomiędzy procedurą Sub a funkcją jest to, że funkcje w wyniku wykonania zwracają wartość. Oznacza to, że funkcja w czasie wykonywania generuje wartość i udostępnia ją w kodzie, który ją wywołał. Na przykład, można użyć funkcji logicznej zwracającej True lub False, która informuje o tym, czy wykonana operacja zakończyła się
Rozdział 24. Typy danych i procedury w języku VBA
755
pomyślnie. Można sprawdzić, czy istnieje plik, czy określona wartość jest większa niż inna wartość lub wykonać inny dowolny test. Funkcje mogą zwracać daty, liczby lub ciągi znaków. Funkcje mogą nawet zwracać złożone typy danych, na przykład zestawy rekordów. Procedura Sub nie zwraca żadnych wartości. Funkcja zwraca wartość bezpośrednio poprzez odpowiednią zmienną utworzoną w trakcie wykonywania funkcji. W funkcjach i procedurach Sub w języku VBA można jednak korzystać z innych sposobów przekazywania wartości formantom znajdującym się na formularzu lub określonym zmiennym zadeklarowanym w pamięci.
Gdzie można utworzyć procedurę? Procedurę możesz utworzyć w jednym z dwóch miejsc:
W standardowym module VBA — podprogram lub funkcję należy utworzyć w standardowym module, jeśli dana procedura ma być współużytkowana przez kod z więcej niż jednego formularza lub raportu albo dostępna dla obiektów innych niż formularz lub raport. Na przykład w kwerendach można wykorzystać funkcje do obsługi bardzo skomplikowanych kryteriów.
W raporcie bądź formularzu — jeśli rozwijany kod ma być wywoływany tylko w jednej procedurze lub jednym formularzu, procedurę Sub lub funkcję należy utworzyć w module formularza lub raportu. Moduł jest kontenerem przechowującym funkcje i procedury.
Wywoływanie procedur w języku VBA W języku VBA procedury można wywołać na kilka sposobów oraz z różnych miejsc. Procedury mogą być wywoływane w wyniku wystąpienia określonych zdarzeń w formularzach lub raportach; można także je wywoływać, korzystając z nazw, a także za pomocą polecenia Call. Oto kilka przykładów: nazwa_procedury Call nazwa_procedury Wartość = nazwa_funkcji
Tylko funkcje zwracają wartości, które można przypisać do zmiennych. Wywołanie procedury Sub powoduje wykonanie jej kodu źródłowego, co prowadzi do realizacji określonego zadania. Po wykonaniu tego zadania procedura jest zamykana. Wprawdzie tylko funkcje zwracają wartości, ale dane mogą być zapisywane w tabelach, formantach, a także w zmiennych o dostępie publicznym zarówno przez funkcje, jak i przez procedury Sub. W niniejszym rozdziale poznasz kilka sposobów odczytywania danych w procedurach Sub i funkcjach. Istnieje kilka sposobów wywoływania procedur Sub z parametrami. Na przykład przy stosowaniu słowa kluczowego Call do wywoływania procedury Sub argumenty należy umieścić w nawiasach:
756
Część VI Podstawy programowania w Accessie Call NazwaProcedury(arg1, arg2)
Jednak to samo wywołanie bez słowa kluczowego Call nie wymaga podawania nawiasów: NazwaProcedury arg1, arg2
Ponadto zastosowanie słowa kluczowego Call do wywołania funkcji jest dla Accessa informacją, że kod nie pobiera wartości zwracanej przez daną funkcję: Call NazwaFunkcji
Gdy potrzebne są argumenty, wywołanie wygląda tak: Call NazwaFunkcji(arg1, arg2)
W tym kontekście funkcja działa jak procedura Sub. Słowo kluczowe Call występowało w języku BASIC od czasu jego powstania. Stosowanie tego słowa nie przynosi żadnych korzyści, a większość programistów w ogóle go nie używa.
Tworzenie procedur Sub Zrozumienie procedur Sub nie jest trudne. Procedura (zazwyczaj nazywana procedurą Sub, a czasami podprogramem) jest zbiorem instrukcji programu, które kompilator języka VBA wykonuje jako osobną jednostkę. Procedury w języku VBA mogą być złożone, zatem szybko przekonasz się, że rzeczywiste procedury tworzone w aplikacjach Accessa są bardziej skomplikowane, niż wynikałoby to z tej podstawowej definicji. Typową procedurę pokazano na rysunku 24.6. Zwróć uwagę na rozpoczynające procedurę słowo kluczowe Sub, za którym występuje nazwa. Deklaracja tej konkretnej procedury zawiera słowo kluczowe Private, ograniczające dostępność procedury do modułu, w którym ją zdefiniowano. Rysunek 24.6. Typowa procedura w aplikacji Accessa
Rozdział 24. Typy danych i procedury w języku VBA
757
Procedura pokazana na rysunku 24.6 zawiera większość komponentów, które można spotkać niemal w każdej procedurze lub funkcji języka VBA.
Deklaracja — wszystkie procedury trzeba zadeklarować tak, by kompilator języka VBA łatwo mógł je znaleźć. Nazwa przypisana do procedury musi być niepowtarzalna w obrębie projektu VBA. Słowo kluczowe Sub identyfikuje pokazaną procedurę jako procedurę Sub.
Symbol zakończenia — wszystkie procedury muszą być zakończone za pomocą słowa kluczowego End oraz typu procedury. Na rysunku 24.6 symbolem zakończenia jest End Sub. Funkcje kończą się określeniem End Function.
Obszar deklaracji — chociaż zmienne i stałe można deklarować w treści procedury (przy czym deklaracja musi znajdować się przed miejsce użycia danego elementu), zgodnie z dobrą praktyką programowania należy deklarować je na początku procedury, tak by można je było łatwo znaleźć.
Instrukcje — procedura VBA może zawierać wiele instrukcji. Zazwyczaj jednak dąży się do tego, aby procedury VBA zawierały jak najmniej instrukcji — po to, by debugowanie było jak najmniej kłopotliwe. Z rozbudowanymi procedurami ciężko się pracuje. Dzięki zachowaniu ich niewielkiej objętości unikniesz wielu problemów. Zamiast wprowadzać wiele mechanizmów i operacji w jednej procedurze, lepiej umieścić je w osobnych procedurach i wywoływać wtedy, gdy będą potrzebne.
Na końcu procedury sterowanie powraca do kodu lub operacji, która wywołała procedurę. Procedura pokazana na rysunku 24.6 jest uruchamiana w odpowiedzi na zdarzenie Load formularza, dlatego sterowanie zwracane jest do tego zdarzenia. W kilku następnych akapitach opisaliśmy przykładową przydatną procedurę VBA. Pokazujemy w nich, jak utworzyć procedurę obsługi zdarzenia formantu z formularza Accessa. Procedura ta pobiera wartość z jednej z kolumn pola kombi cboCustomerID i wykorzystuje ją do znalezienia rekordu. Właściwość Źródło wiersza tego pola kombi to instrukcja SQL-a zwracająca pola CustomerID i Company. Oto ta instrukcja: SELECT DISTINCT tblCustomers.CustomerID, tblCustomers.Company FROM tblCustomers INNER JOIN tblSales ON tblCustomers.CustomerID = tblSales.CustomerID ORDER BY tblCustomers.Company;
Tabela tblCustomers jest złączana z tabelą tblSales, dlatego w polu kombi wyświetlani są tylko klienci, dla których istnieją faktury. W instrukcji zastosowano słowo kluczowe DISTINCT, dlatego każdy klient pojawia się tylko raz. Szczegółowe omówienie składni języka SQL znajdziesz w rozdziale 14.
Celem tego ćwiczenia jest poznanie procedur. W trakcie tworzenia przykładowych procedur poznasz jednak kilka nowych poleceń języka VBA. Pierwsza przykładowa procedura będzie obsługiwać zdarzenie Po aktualizacji pola kombi cboCustomerID. Aby utworzyć procedurę zdarzenia na formularzu, wykonaj poniższe czynności:
758
Część VI Podstawy programowania w Accessie
1. Zaznacz pole kombi cboCustomerID na formularzu frmSales otwartym w widoku projektu. 2. Wciśnij F4, aby otworzyć okno właściwości wybranego formantu. 3. Kliknij zdarzenie Po aktualizacji na zakładce Zdarzenie arkusza właściwości i z rozwijanej listy zdarzenia Po aktualizacji wybierz wartość [Procedura zdarzenia]. 4. Kliknij przycisk konstruktora (oznaczony wielokropkiem), aby otworzyć edytor kodu VBA. 5. Wprowadź poniższy kod w sposób pokazany na rysunku 24.7. Wpisz kod w procedurze zdarzenia cboCustomerID_AfterUpdate. Powinien się on znaleźć w edytorze kodu VBA między wierszami Private Sub cboCustomerID_AfterUpdate() a End Sub. Me.txtCustomerID.SetFocus If Not IsNull(Me.cboCustomerID.Value) Then DoCmd.FindRecord Me.cboCustomerID.Value End If Me.txtInvoiceDate.SetFocus
Rysunek 24.7. Procedura obsługi zdarzenia cboCustomerID_AfterUpdate formularza frmSales otwarta w edytorze kodu VBA
6. Z menu Debug edytora kodu wybierz polecenie Compile Rozdział24, aby sprawdzić poprawność wprowadzonego kodu. 7. Zamknij okno VBA i powróć do formularza frmSales. Kod najpierw przechodzi do pola tekstowego txtCustomerID i ustawia je jako aktywne. Człon Me. oznacza bieżący formularz i w tym przykładzie zastępuje fragment Forms! frmSales!. Pierwsza instrukcja If sprawdza, czy wybrano identyfikator klienta. W tym celu ustala, czy bieżąca wartość powiązanej kolumny pola kombi (CustomerID) jest różna od Null.
Rozdział 24. Typy danych i procedury w języku VBA
759
Najważniejszym elementem procedury jest metoda FindRecord obiektu DoCmd. Metoda ta przeszukuje zbiór rekordów i zwraca rekord pasujący do argumentów. Metoda Find Record może przyjmować kilka argumentów, jednak tu podano tylko pierwszy — FindWhat. Określa on, czego metoda ma szukać w rekordach. Tu metoda szuka wartości Me.cboCustomerID.Value. Inne argumenty metody FindRecord są opcjonalne i tu wykorzystano wartości domyślne. Dzięki przejściu do pola Me.txtCustomerID jest ono ustawiane jako pole aktywne. Metoda FindRecord domyślnie przeszukuje tylko zawartość aktywnego pola, dlatego przed jej wywołaniem należy ustawić odpowiednie pole. W ostatnim wierszu kod przechodzi do pola tekstowego txtInvoideDate. Dobrym zwyczajem jest, aby po znalezieniu rekordu przejść do wygodnego punktu wyjścia do zapoznania się z rekordem. Choć nie jest to wymagane, ułatwia pracę użytkownikom. Na rysunku 24.7 przedstawiono omawianą procedurę zawierającą wspomniane polecenia utworzoną w edytorze kodu VBA. Po wprowadzeniu wszystkich instrukcji, a przed zamknięciem okna edytora, należy kliknąć przycisk Save znajdujący się na pasku narzędzi i zapisać kod. Procedura zdefiniowana dla tego formularza będzie wywoływana za każdym razem, gdy zmieni się wartość w polu kombi cboCustomerID. Kod wyświetli wtedy pierwszą fakturę danego klienta.
Tworzenie funkcji Funkcje różnią się od procedur Sub tym, że po wykonaniu zwracają wartości. W pokazanych przykładach utworzysz funkcją do obliczania wartości zamówionych produktów (liczba produktów × cena), a także funkcję wyznaczającą wartość wszystkich pozycji opodatkowanych, która uwzględni wysokość odpowiedniej stawki podatkowej. Funkcje można tworzyć w formularzach lub raportach, ale zwykle umieszcza się je w modułach standardowych. Pierwszą przykładową funkcję utworzysz w nowym module o nazwie modSalesFunctions. Umieszczenie tej funkcji w module standardowym powoduje, że można z niej korzystać w dowolnym miejscu aplikacji. Aby utworzyć nową funkcję, wykonaj następujące czynności: 1. Wybierz zakładkę Moduły w okienku nawigacji. 2. Kliknij prawym przyciskiem myszy moduł modSalesFunctions i z menu podręcznego wybierz widok projektu. Wyświetli się okno VBA z tytułem modSalesFunctions(Code) w pasku tytułu. 3. Przejdź na koniec modułu i wpisz następujący kod: Public Function CalcExtendedPrice( _ lQuantity As Integer, _ cPrice As Currency, _ dDiscount As Double _ ) As Currency Dim cExtendedPrice As Currency
760
Część VI Podstawy programowania w Accessie cExtendedPrice = lQuantity * cPrice CalcExtendedPrice = cExtendedPrice * (1 - dDiscount) End Function
Pierwsza instrukcja jest deklaracją zmiennej cExtendedPrice typu Currency. Jest to zmienna pomocnicza. W następnym wierszu kodu wykonano obliczenia — przypisano iloczyn dwóch zmiennych lQuantity i cPrice do wcześniej zadeklarowanej zmiennej cExtendedPrice. Jak łatwo zauważyć, zmienne lQuantity i cPrice nie zostały zadeklarowane. Zmienne te opisano w następnym punkcie, „Obsługa przekazywanych parametrów”. W ostatnim wierszu wykonywane są następne obliczenia — od wartości cExtendedPrice odliczany jest rabat. Nazwą funkcji posłużono się tak, jakby była zmienną, i przypisano do niej wartość obliczeń. Właśnie w taki sposób nadaje się funkcji wartość, która jest następnie zwracana do programu wywołującego.
Obsługa przekazywanych parametrów Spróbujmy odpowiedzieć na następujące pytanie: skąd pochodzą zmienne lQuantity, cPrice i dDiscount? Odpowiedź jest bardzo prosta: zmienne te zostały przekazane funkcji jako parametry wywołania z innej procedury. Przekazane do procedury parametry (często nazywane argumentami) traktuje się w niej jak dowolne inne zmienne. Parametry mają nazwę i typ danych, a służą do przekazywania informacji do procedury. Parametrów często się używa także do pobierania informacji z procedur. W poniższej tabeli przedstawiono nazwy i typy danych argumentów używanych w funkcji CalcExtendedPrice: Nazwa parametru
Typ
lQuantity
Integer
cPrice
Currency
dDiscount
Double
Parametry można nazywać dowolnie. Parametry przekazuje się w zmiennych, które niczym nie różnią się od tych deklarowanych za pomocą instrukcji Dim. Nazwy tych zmiennych nie muszą pokrywać się z nazwami wykorzystywanymi w wywołaniu funkcji. Zwykle wykorzystuje się tu nazwy pól tabel lub formantów z formularza albo nazwy zmiennych pochodzące z procedury wywołującej daną funkcję. Kompletną funkcję CalcExtendedPrice przedstawiono na rysunku 24.8. Zwróć uwagę na to, jak parametry funkcji zostały zdefiniowane w deklaracji funkcji. Są tu rozdzielone symbolem kontynuacji (odstępem i podkreśleniem), dzięki czemu kod jest czytelniejszy.
Rozdział 24. Typy danych i procedury w języku VBA
761
Rysunek 24.8. Kompletna funkcja CalcExtendedPrice
Wywoływanie funkcji i przekazywanie parametrów Gdy masz już gotową funkcję, możesz sprawdzić jej działanie. Zwykle funkcja jest wywoływana z poziomu procedury zdarzenia formularza lub raportu (lub z poziomu innej procedury), która przekazuje dane w parametrach wywołania. Przekazywanymi parametrami często są zmienne i dane z formantów formularza. W celu przetestowania działania tej funkcji wartości parametrów można wpisać bezpośrednio w oknie Immediate. Aby sprawdzić działanie tej funkcji, wykonaj następujące czynności: 1. Wciśnij kombinację klawiszy Ctrl+G, aby wyświetlić okno Immediate. 2. Wpisz ? CalcExtendedPrice (5,3.50,.05). Instrukcja ta przekazuje wartości 5, 3,50 i 0,05 (5%) odpowiednio do parametrów lQuantity, dPrice i dDiscount. Wykorzystując te parametry, funkcja CalcExtendedPrice zwraca wynik 16,625, co pokazano na rysunku 24.9. Rysunek 24.9. Sprawdzanie działania funkcji CalcExtendedPrice w oknie Immediate
3. Zamknij okno Immediate i edytor VBA i powróć do okienka bazy danych. Kolejnym zadaniem jest wykorzystanie funkcji do wyznaczenia sumy częściowej (cena razy liczba produktów) dla każdej pozycji z faktury. Wywołanie funkcji można dodać za pomocą pola z kwotą z formularza fsubSalesLineItems (jest on osadzony w formularzu frmSales). Wykonaj następujące czynności:
762
Część VI Podstawy programowania w Accessie
1. Otwórz formularz frmSales w widoku projektu. 2. Kliknij podformularz fsubSalesLineItems. 3. Kliknij formant txtAmount podformularza. 4. Wyświetl okno właściwości i do właściwości Źródło formantu przypisz następujący kod (zobacz rysunek 24.10): =CalcExtendedPrice(Nz([txtQuantity];0);Nz ([txtPrice];0);Nz([txtDiscountPercent];0)). Powyższe wyrażenie przekazuje wartości z trzech formantów (txtQuantity, txtPrice i txtDiscountPercent) podformularza do funkcji CalcExtendedPrice z modułu i zwraca wartość jako źródło formantu txtAmount za każdym razem, gdy zmieni się któryś z parametrów lub nastąpi ponowne obliczenie pozycji. Odwołania do pól txtQuantity, txtPrice i txtDiscountPercent znajdują się w funkcji Nz, która przekształca wartości null na zera. Jest to jeden ze sposobów na uniknięcie błędów Invalid use of null. Rysunek 24.10. Wprowadzanie wywołania funkcji za pomocą właściwości Źródło formantu
W formularzu do obsługi sprzedaży (frmSales) zastosowano regułę biznesową, która wymusza ponowne obliczanie ceny do zapłaty po każdej zmianie liczby produktów, ceny lub rabatu przez użytkownika. Na rysunku 24.10 warto zwrócić uwagę na to, że funkcja CalcExtendedPrice wywoływana jest we właściwości źródła formantu txtAmount. W wywołaniu tym nie określono modułu obejmującego tę funkcję. Ponieważ funkcja ta jest zadeklarowana ze słowem kluczowym Public, Access łatwo ją znajduje i przekazuje do niej odpowiednie parametry. Funkcja CalcExtendedPrice pozwala zademonstrować ważny aspekt programowania w Accessie — funkcję publiczną można umieścić w dowolnym miejscu aplikacji, a następnie korzystać z niej tam, gdzie jest potrzebna. Możliwość wykorzystania procedury w wielu miejscach ułatwia konserwację kodu. Funkcję wystarczy wtedy zmodyfikować w jednym miejscu, a poprawki zostaną odzwierciedlone wszędzie tam, gdzie funkcja jest używana.
Tworzenie funkcji wyznaczającej kwotę podatku W aplikacji MiniAuta dla Kolekcjonerów w trakcie dodawania pozycji do faktury użytkownik musi zdecydować, czy produkty podlegają opodatkowaniu czy nie. Można wyznaczyć sumę kwot wszystkich pozycji znajdujących się na fakturze, następnie dodać je do siebie i wyznaczyć kwotę podatku.
Rozdział 24. Typy danych i procedury w języku VBA
763
Formularz do wprowadzania transakcji w aplikacji MiniAuta dla Kolekcjonerów (frmSales) zawiera pole tekstowe przeznaczone na kwotę podatku. Wyrażenie do obliczania wartości formantu można utworzyć w następujący sposób: =fsubSalesLineItems.Form!txtTaxableTotal * txtTaxRate
W powyższym wyrażeniu program pobiera wartość kwoty opodatkowanej (txtTaxable Total) z formantu znajdującego się w podformularzu fsubSalesLineItems i mnoży ją przez wartość odczytaną z formantu txtTaxRate znajdującego się na formularzu frmSales. Wprawdzie kwota podatku zostanie wyznaczona poprawnie, ale zastosowanie wyrażenia do jej wyliczenia spowoduje, że pole txtTaxAmount będzie tylko do odczytu (bo zawiera wyrażenie). Nie można zmienić wartości pola, która została wyznaczona z wykorzystaniem wyrażenia. Użytkownik w polu zawierającym kwotę podatku powinien mieć możliwość wprowadzania zmian z przyczyn biznesowych. Zamiast korzystać z wyrażenia, można utworzyć funkcję, której zadaniem będzie wyliczenie wartości, a następnie tę wartość wprowadzić do formantu. W ten sposób pole będzie zawierać wartość wstępnie wyliczoną przez funkcję, ale wartość tę będzie można zmodyfikować samodzielnie. W procedurze zdarzenia Po aktualizacji formantów txtQuantity, txtPrice, txtDiscount Percent i chkTaxable można wpisać przedstawioną poniżej instrukcję. W ten sposób w momencie wyświetlania danych kolejnego klienta zostanie odczytana stawka podatkowa z formularza frmSales i ponownie wyznaczona kwota podatku. txtTaxAmount = _ fsubSalesLineItems.Form!txtTaxableTotal * txtTaxRate
Najlepiej ten wiersz kodu umieścić jednak w procedurze zdarzenia Po aktualizacji podformularza fsubSalesLinteItems. W ten sposób kwota podatku będzie wyznaczana za każdym razem, gdy którakolwiek z wartości podformularza zostanie zmieniona. Ponieważ podformularz fsubSalesLineItems wyświetla się w widoku arkusza danych, zdarzenia Po aktualizacji występuje po przejściu do kolejnego wiersza w formularzu. Chociaż można użyć prostych wyrażeń, które odwołują się do formularzy i podformularzy, sposób ten działa tylko dla formularzy ze zdefiniowanym kodem. Załóżmy, że trzeba wyznaczyć kwoty podatku znajdujące się na innych formularzach i raportach. Istnieje lepszy sposób ich obliczenia od korzystania z wartości na formularzach. Jak mawiają programiści zajmujący się tworzeniem aplikacji dla Accessa, „formularze i raporty kłamią — tabele nigdy nie kłamią”. Oznacza to, że formanty znajdujące się na formularzu lub raporcie mogą zawierać wartości nieprawdziwe, wyznaczone na przykład w wyniku zastosowania błędnie skonstruowanego wyrażenia, kodu VBA lub formatu. Prawdziwe wartości są przechowywane w tabelach i stamtąd powinny być bezpośrednio pobierane do obliczeń oraz raportów. Za pomocą kodu VBA można łatwo pobrać dane z tabeli, zastosować je w skomplikowanych obliczeniach, a następnie przekazać wynik do formantu w formularzu lub raporcie albo do innej części kodu. Na rysunku 24.11 pokazano funkcję CalcTax.
764
Część VI Podstawy programowania w Accessie
Rysunek 24.11. Funkcja CalcTax
Funkcja CalcTax będzie wywoływana w procedurach zdarzenia Po aktualizacji podformularza fsubSalesLineItems. Funkcja CalcTax jest wykorzystywana do wyznaczenia wartości produktów, które podlegają opodatkowaniu. Poszczególne dane są pobierane z tabeli tblSalesItems. Do pobrania odpowiednich danych wykorzystano instrukcję SQL-a razem z kodem ADO. Wyznaczoną wartość przeznaczoną do opodatkowania pomnożono przez stawkę podatkową przekazaną za pomocą parametru dTaxPercent. Wartość podatku przypisano do zmiennej cReturn, która na końcu funkcji jest przypisywana do CalcTax (nazwa wyrażenia). Ważnym aspektem przykładowego kodu jest to, że połączono tu dane pobrane z tabeli bazy danych (Quantity, RetailPrice, DiscountPercent) z danymi przekazanymi jako parametry (dTaxPercent, lInvoiceNum). Pobieranie danych i obliczenia są automatycznie wykonywane przez kod, a użytkownik nie wie, w jaki sposób obliczana jest kwota podatku. Funkcje i procedury są ważnymi elementami aplikacji umożliwiającymi wielokrotne zastosowanie raz utworzonego kodu. Z funkcji i procedur wraz z parametrami należy korzystać wszędzie, gdzie to możliwe. Warto stosować zasadę, według której sygnałem do utworzenia funkcji jest konieczność skopiowania fragmentu kodu w inne miejsce.
Rozdział 24. Typy danych i procedury w języku VBA
765
Upraszczanie kodu za pomocą argumentów identyfikowanych przez nazwę Kolejną istotną cechą języka VBA Accessa jest wykorzystanie w procedurach argumentów o nadanych nazwach. W przypadku braku nazw argumenty przekazywane do procedur muszą występować we właściwym porządku od lewej do prawej. Dzięki omawianej cesze można przypisać nazwy każdemu z parametrów przekazanych do procedury lub funkcji. W procedurze (funkcji) z argumentu korzysta się na podstawie nazwy, a nie na podstawie pozycji na liście argumentów. Ponadto ponieważ każdy parametr przekazywany do procedury ma określoną nazwę, można pominąć niepotrzebne parametry bez powodowania błędów. Argumenty z nazwami są doskonałym sposobem na uporządkowanie kodu, a także zwiększenie jego czytelności i zrozumiałości. Załóżmy, że w aplikacji znajduje się następująca funkcja: Function PrepareOutput(sStr1 As String, sStr2 As String, _ sStr3 As String) As String PrepareOutput = sStr1 & Space(1) & sStr2 & Space(2) & sStr3 End Function
Działanie tej funkcji sprowadza się do połączenia ciągów sStr1, sStr2 i sStr3, a następnie zwrócenia ich do procedury wywołującej. W kolejnym przykładzie pokazano sposób wywołania tej funkcji z innej procedury. Private Sub cmdForward_Click() Me.txtOutput.Value = PrepareOutput( _ Me.txtFirstName.Value, _ Me.txtLastName.Value, _ Me.txtHireDate.Value) End Sub
Argumenty wymagane przez procedurę PrepareOutput() muszą być przekazane w porządku od lewej do prawej. Wynik działania funkcji pokazano na rysunku 24.12. Tekst w polu tekstowym Wynik funkcji formularza pokazuje argumenty w kolejności, w jakiej występują w polach tekstowych po lewej stronie formularza. Rysunek 24.12. W formularzu frmNamedArguments pokazano zalety używania argumentów z nazwami w procedurach VBA
766
Część VI Podstawy programowania w Accessie
Argumenty przekazywane do funkcji można identyfikować przez nazwę. Dzięki zastosowaniu nazw pozycja argumentów na liście staje się nieistotna. Aby zobaczyć, jak działają argumenty z nazwami, przeanalizuj kod na poniższym listingu: Private Sub cmdBackward_Click() Me.txtOutput.Value = PrepareOutput( _ sStr2:=Me.txtLastName.Value, _ sStr3:=Me.txtFirstName.Value, _ sStr1:=Me.txtHireDate.Value) End Sub
Należy zwrócić uwagę, że w procedurze cmBackward_Click nie przekazano argumentów do procedury PrepareOutput() w ustalonym porządku. Jeśli nazwy przypisane do argumentów odpowiadają argumentom funkcji PrepareOutput(), kompilator języka VBA Accessa poprawnie użyje argumentów w tej funkcji. Przykładowa baza danych Rozdział24.accdb zawiera formularz frmNamedArguments pokazany na rysunkach 24.12 i 24.13. Dwa przyciski poniżej pola tekstowego Wynik funkcji powodują przekazanie ciągów z pól tekstowych Imię, Nazwisko i Zatrudniony do funkcji PrepareOutput(). Używane sortowania przy tym argumenty przekazywane na podstawie pozycji oraz nazwy. Rysunek 24.13. Do funkcji PrepareOutput() można przekazać argumenty w dowolnym porządku, pod warunkiem użycia prawidłowych nazw
Rozdział 25.
Model zdarzeń W tym rozdziale:
Programowanie zdarzeń
Przegląd często używanych zdarzeń
Omówienie kolejności zdarzeń
Podczas tworzenia systemów baz danych często okazuje się, że pewne operacje są wielokrotnie powtarzane. Zamiast ręcznie wykonywać te zadania, można je zautomatyzować, korzystając z języka VBA lub makr. W trakcie korzystania z systemów zarządzania bazami danych użytkownicy dodają nowe rekordy w formularzach i kwerendy, a także tworzą nowe raporty. Wiele z tworzonych obiektów jest wykorzystywana wielokrotnie — np. raport tygodniowy, odpowiednia kwerenda wykonywana w celu aktualizacji bazy raz w miesiącu itd. Wiele zadań w systemie zarządzania bazami danych jest wykonywanych w ten sposób. Na przykład w czasie uzupełniania bazy danych z kontaktami o nowy rekord za każdym razem trzeba otworzyć ten sam formularz. W podobny sposób drukowane są też raporty dla klientów, którzy zakupili pojazd w ciągu ostatniego miesiąca. W celu wykonania tych zadań, można utworzyć w aplikacji odpowiedni kod VBA. Język VBA oferuje wiele poleceń przydatnych w pracy z rekordami w tabeli, obsłudze formantów znajdujących się na formularzu i tak dalej. W niniejszym rozdziale znajdziesz dalszy ciąg omówienia stosowania procedur w formularzach, raportach i modułach standardowych. W tym rozdziale używana jest baza danych Rozdzial25.accdb. Jeśli ktoś chce śledzić przykłady zamieszczone w tym rozdziale, powinien skopiować plik z tą bazą danych z przykładów dołączonych do książki.
Głównym tematem tego rozdziału jest model zdarzeń Accessa. Jest to bardzo ważny aspekt programowania baz Accessa. W rozdziale tym przekonasz się, że Access udostępnia różnorodne zdarzenia, które umożliwiają uruchamianie kodu w odpowiedzi na działania użytkowników.
768
Część VI Podstawy programowania w Accessie
Programowanie zdarzeń Zdarzenie w Accessie jest efektem działania użytkownika lub reakcją aplikacji na działanie użytkownika. Zdarzenie zachodzi wtedy, gdy użytkownik, na przykład, przeniesie rekord do innego formularza, zamknie raport albo kliknie przycisk polecenia znajdujący się na formularzu. Nawet poruszenie myszą generuje szereg zdarzeń. Aplikacje w Accessie działają w oparciu o zdarzenia. Obiekty Accessa reagują na wiele typów zdarzeń. Zdarzenia w Accessie są powiązane z określonymi właściwościami obiektów. Na przykład zaznaczenie bądź anulowanie zaznaczenia pola wyboru generuje odpowiednio zdarzenia Przy naciśnięciu przycisku myszy, Przy zwolnieniu przycisku myszy i Przy kliknięciu. Zdarzenia te są powiązane z polem wyboru za pomocą właściwości OnMouseDown, OnMouseUp i OnClick. Do tworzenia procedur, które uruchamiają się za każdym razem, kiedy użytkownik kliknie pole wyboru, służy język VBA. Zdarzenia w Accessie można podzielić na siedem grup:
Zdarzenia związane z oknami (formularzami i raportami) — otwieranie, zamykanie, zmiany rozmiarów.
Zdarzenia związane z klawiaturą — wciśnięcie bądź zwolnienie klawisza.
Zdarzenia związane z myszą — wciśnięcie przycisku myszy.
Zdarzenia związane z fokusem — aktywacja, wejście, wyjście.
Zdarzenia związane z danymi — zmiana aktywnego wiersza, usuwanie, wstawianie lub aktualizowanie danych.
Zdarzenia związane z wydrukiem — formatowanie i drukowanie.
Zdarzenia związane z obsługą błędu i z czasem — odpowiednia reakcja na wystąpienie błędu lub po upływie określonego czasu.
Ogółem Access udostępnia ponad 50 różnych zdarzeń, które można obsłużyć za pomocą procedur VBA. Wśród tych zdarzeń zdecydowanie najpopularniejsze są zdarzenia związane z klawiaturą i myszą. Jak dowiesz się z kolejnych podrozdziałów, formularze i większość formantów rozpoznają zdarzenia dotyczące klawiatury i myszy. Formularze i formanty rozpoznają dokładnie te same zdarzenia dotyczące myszy i klawiatury. Kod dla zdarzenia kliknięcia myszą przycisku polecenia jest dokładnie taki sam jak ten, który można napisać dla zdarzenia kliknięcia myszą na formularzu. Dodatkowo większość typów obiektów w Accessie posiada własne, niepowtarzalne zdarzenia. W kolejnych podrozdziałach opisano często używane zdarzenia tego rodzaju. Firma Microsoft zwykle jednak wprowadza nowe zdarzenia wraz z nowymi wersjami Accessa. Ponadto z większością formantów ActiveX, które można wykorzystać w aplikacjach Accessa, związane są specyficzne i specjalne zdarzenia. W przypadku korzystania z nieznanego formantu lub nowego typu obiektu w aplikacjach Accessa należy zapoznać się ze zdarzeniami i właściwościami obsługiwanymi przez ten formant bądź obiekt.
Rozdział 25. Model zdarzeń
769
W jaki sposób zdarzenia uruchamiają kod VBA? W Accessie można utworzyć procedurę obsługi zdarzenia, która uruchomi się w przypadku wystąpienia jednego z wielu zdarzeń dostępnych w Accessie. Access odpowiada na zdarzenia za pośrednictwem specjalnych właściwości formularzy i formantów. Raporty charakteryzują się podobnym zbiorem zdarzeń, dostosowanym do specjalnych wymagań raportów. Na rysunku 25.1 pokazano arkusz właściwości formularza frmProducts. Formularz ten ma wiele właściwości, które można wykorzystać do obsługi zdarzeń. Poszczególne sekcje (nagłówek strony, nagłówek formularza, szczegóły, stopka strony, stopka formularza) oraz każdy formant znajdujący się na formularzu (np. etykieta, pole tekstowe, pole wyboru, przycisk opcji) również mają zdarzenia.
Rysunek 25.1. Arkusz właściwości formularza frmProducts z otwartą zakładką Zdarzenia
Zwróć uwagę, że na rysunku 25.1 arkusz właściwości otwarto na zakładce Zdarzenie. Formularze Accessa obsługują ponad 50 zdarzeń. Z każdą sekcją formularza, a także z każdym formantem jest związana pewna liczba zdarzeń. Po wybraniu sekcji formularza lub formantu zakładka Zdarzenie arkusza właściwości zmienia się, pokazując zdarzenia dla wybranego obiektu. Na rysunku 25.1 wszystkie zdarzenia, dla których zdefiniowano procedurę obsługi, mają opis [Procedura zdarzenia]. Oznacza to, że z właściwością jest związany kod VBA, który uruchomi się w przypadku wystąpienia zdarzenia. Przy zdarzeniach może znajdować się też opis [Makro osadzone], nazwa makra lub nazwa funkcji.
770
Część VI Podstawy programowania w Accessie
Tworzenie procedur zdarzeń W Accessie można uruchamiać procedury zdarzeń za pomocą właściwości obiektów. W Accessie do łączenia kodu VBA ze zdarzeniami obiektów służą właściwości. Na przykład właściwość Przy otwarciu jest związana ze zdarzeniem polegającym na otwarciu formularza lub raportu na ekranie. Procedury obsługi zdarzeń w Accessie widoczne w arkuszu właściwości często obejmują odstępy. Na przykład zdarzeniu otwarcia odpowiada procedura Przy otwarciu. Same zdarzenie to oczywiście otwarcie. Wiele właściwości zdarzeń (choć nie wszystkie) rozpoczyna się od członu Przy.
Aby dodać procedurę obsługi zdarzenia do formularza lub raportu, należy wybrać właściwość zdarzenia (np. Przed aktualizacją) w arkuszu właściwości obiektu. Jeśli w określonym momencie dla właściwości nie istnieje procedura obsługi zdarzenia, w polu właściwości wyświetla się strzałka w dół oraz przycisk konstruktora, tak jak pokazano dla właściwości zdarzenia Przed aktualizacją na rysunku 25.1. Kliknięcie przycisku powoduje wyświetlenie krótkiej listy zawierającej jeden element [Procedura zdarzenia]. Wybranie tej opcji i późniejsze kliknięcie przycisku konstruktora powoduje otwarcie edytora kodu VBA i wyświetlenie szablonu procedury zdarzenia (zobacz rysunek 25.2). Rysunek 25.2. Pusty szablon procedury zdarzenia dla zdarzenia formularza Przed aktualizacją
Zwróć uwagę na format deklaracji procedury zdarzenia: Private Sub Obiekt_Zdarzenie()
Część Obiekt nazwy procedury to oczywiście obiekt wyzwalający zdarzenie, natomiast część Zdarzenie to określone zdarzenie występujące dla obiektu. Na rysunku 25.2 obiektem jest Form, a zdarzeniem — BeforeUpdate. Niektóre zdarzenia wymagają podania argumentów. Wprowadza się je w nawiasach na końcu deklaracji. Nie można zmienić nazwy ani argumentów procedury obsługi zdarzenia, ponieważ przestanie ona działać. Język VBA w Accessie wymaga stosowania konwencji Obiekt_Zdarzenie przy łączeniu procedur ze zdarzeniami obiektów.
Rozdział 25. Model zdarzeń
771
Często używane zdarzenia Niektóre zdarzenia są zgłaszane przez wiele różnych obiektów Accessa. Firma Microsoft dołożyła starań, aby zdarzenia te działały dokładnie w ten sam sposób niezależnie od tego, jaki obiekt je zgłasza. Kilka najczęściej wykorzystywanych przez osoby programujące w Accessie zdarzeń zamieszczono w tabeli 25.1. Większość z tych zdarzeń dotyczy formularzy, a także różnych formantów, które można umieszczać w formularzach Accessa. Tabela 25.1. Zdarzenia dotyczące różnych typów obiektów Zdarzenie
Typ zdarzenia
Wyzwolenie zdarzenia
Przy kliknięciu
Zdarzenie związane z myszą
Po naciśnięciu i zwolnieniu (czyli kliknięciu) lewego przycisku myszy na obiekcie
Przy dwukrotnym kliknięciu
Zdarzenie związane z myszą
Po dwukrotnym naciśnięciu i zwolnieniu (czyli kliknięciu) lewego przycisku myszy na obiekcie
Przy naciśnięciu przycisku myszy
Zdarzenie związane z myszą
Po naciśnięciu przycisku, gdy wskaźnik myszy znajduje się na obiekcie
Przy ruchu myszy
Zdarzenie związane z myszą
W trakcie przesuwania wskaźnika myszy nad obiektem
Przy zwolnieniu przycisku myszy
Zdarzenie związane z myszą
Po zwolnieniu wcześniej wciśniętego przycisku myszy (wskaźnik na obiekcie)
On Mouse Wheel
Zdarzenie związane z myszą
Przy przesuwaniu rolki myszy
Przy naciśniętym klawiszu
Zdarzenie związane z klawiaturą
Po naciśnięciu klawisza, gdy obiekt uzyskał fokus; w trakcie korzystania z wbudowanego makra SendKeys
Przy zwolnieniu klawisza
Zdarzenie związane z klawiaturą
Po zwolnieniu klawisza albo tuż po zakończeniu działania makra SendKeys
Przy naciśnięciu klawisza
Zdarzenie związane z klawiaturą
Po wciśnięciu i zwolnieniu klawisza, gdy obiekt uzyskał fokus; w trakcie korzystania z makra SendKeys
Jak należało się spodziewać, wszystkie te zdarzenia są związane z myszą i klawiaturą, ponieważ są to najczęściej wykorzystywane sposoby wprowadzania informacji oraz przekazywania instrukcji dla aplikacji. Nie każdy obiekt odpowiada na każde z tych zdarzeń, ale jeśli jakiś obiekt odpowiada na dowolne z nich, zdarzenie działa dokładnie w taki sam sposób. Wielu programistów kopiuje kod VBA z jednej procedury obsługi zdarzenia do takiej samej procedury powiązanej z innym obiektem. Załóżmy, że chcesz w wymyślny sposób formatować pole tekstowe w reakcji na kliknięcie go przez użytkownika. W tym celu wystarczy skopiować kod formatujący do procedury obsługi zdarzenia Przy kliknięciu innego formantu. Pozwala to uzyskać identyczne formatowanie bez konieczności ponownego wpisywania kodu. Choć we wklejonym kodzie trzeba zmienić nazwę pola tekstowego, wymaga to mniej pracy niż ponowne pisanie całej procedury.
Access obsługuje bardzo dużą liczbę zdarzeń. Jedną z jego najważniejszych zalet jest udostępnianie programistom różnorodnych zdarzeń. Umożliwiają one kontrolowanie niemal dowolnego aspektu działania aplikacji Accessa i zarządzanie danymi za pomocą
772
Część VI Podstawy programowania w Accessie
procedur obsługi zdarzeń. Choć Microsoft nie wprowadza formalnego rozróżnienia między typami zdarzeń, w dalszych punktach zdarzenia i procedury ich obsługi podzielono na grupy na podstawie rodzajów obiektów (formularze, raporty itd.) zgłaszających poszczególne zdarzenia. Model zdarzeń w Accessie jest niezwykle bogaty. Niewielu programistów zna wszystkie zdarzenia Accessa (nie jest to zresztą niezbędne). Prawie każdy poznaje i stosuje zdarzenia, które są mu potrzebne w tworzonych akurat aplikacjach, a potem w miarę potrzeb uczy się kolejnych. Nie musisz uczyć się wszystkich zdarzeń na pamięć. Zapamiętaj tylko, że Access udostępnia rozmaite typy zdarzeń i że możesz je wykorzystać, gdy będziesz ich potrzebować.
Procedury zdarzeń formularza W trakcie pracy nad formularzem można utworzyć procedury obsługujące zdarzenia z poziomu formularza, z poziomu sekcji lub z poziomu formantu. Jeśli procedura zdarzenia zostanie dołączona do zdarzenia poziomu formularza, to po wystąpieniu zdarzenia zadania realizowane przez tę procedurę zadziałają na całym formularzu (taka sytuacja wystąpi na przykład przy przejściu do innego rekordu albo przy opuszczaniu formularza). Aby formularz właściwie zareagował na dane zdarzenie, trzeba skonstruować odpowiednią procedurę zdarzenia i podłączyć ją do właściwości zdarzenia danego formularza. Do wyzwalania procedur zdarzeń poziomu formularza można wykorzystać wiele właściwości. Zdarzenia formularza to w tym kontekście te zdarzenia, które odnoszą się do formularza jako całości, a nie zdarzenia wyzwalane przez dowolny formant znajdujący się na formularzu. Zdarzenia formularza są zgłaszane przy przenoszeniu danych pomiędzy rekordami albo podczas otwierania lub zamykania formularza. Zdarzenia formantów omówiono w dalszej części rozdziału w punkcie „Procedury obsługi zdarzeń formantów”.
Podstawowe zdarzenia formularzy Formularze Accessa reagują na bardzo wiele zdarzeń. Dla większości z tych zdarzeń ze względu na ich specjalistyczny charakter nie trzeba pisać kodu. Są jednak pewne zdarzenia, które bardzo często programuje się w aplikacjach Accessa. Kilka najbardziej podstawowych i najważniejszych zdarzeń formularzy Accessa przedstawiono w tabeli 25.2. Nieprzypadkowo są to również najczęściej programowane zdarzenia związane z formularzami Accessa. Zwróć uwagę na to, jak wiele zdarzeń z tabeli 25.2 związanych jest z danymi (Przy bieżącym, Przed wstawieniem itd.). Ponieważ formularze Accessa zwykle służą do pracy z danymi (np. do dodawania nowych danych lub modyfikowania informacji), udostępniają te zdarzenia, aby umożliwić większą kontrolę w zakresie zarządzania danymi. Zdarzenia formularzy dotyczące myszy i klawiatury Formularze Accessa reagują również na zdarzenia związane z myszą i klawiaturą. Zestawiono je w tabeli 25.3.
Przy otwarciu formularza, ale przed wyświetleniem pierwszego rekordu
Po załadowaniu
Po załadowaniu formularza do pamięci, ale przed otwarciem
Po zmianie rozmiaru
Po zmianie rozmiaru formularza
Przy zwolnieniu
Po zamknięciu formularza, zwolnieniu rekordów, ale przed usunięciem formularza z ekranu
Przy zamknięciu
Po zamknięciu i usunięciu formularza z ekranu
Przy aktywowaniu
Po aktywowaniu otwartego formularza
Przy dezaktywowaniu
Po aktywacji innego okna, ale przed utratą fokusu
Przy uzyskaniu fokusu
Po uzyskaniu fokusu przez okno nieposiadające aktywnych formantów
Przy utracie fokusu
Po utracie fokusu
Przy cyklu czasomierza
Po upływie czasu równego wartości interwału czasomierza (interwał jest określony w milisekundach we właściwości Interwał czasomierza)
Before Screen Tip
Przy aktywacji etykietki ekranowej
Tabela 25.3. Zdarzenia formularzy związane z myszą i klawiaturą Zdarzenie
Wyzwolenie zdarzenia
Przy kliknięciu
Po naciśnięciu i zwolnieniu (czyli kliknięciu) lewego przycisku myszy
Przy dwukrotnym kliknięciu
Po dwukrotnym naciśnięciu i zwolnieniu (czyli kliknięciu) lewego przycisku myszy na formularzu
Przy naciśnięciu przycisku myszy
Po naciśnięciu przycisku, gdy wskaźnik myszy znajduje się na formularzu
Przy ruchu myszy
W trakcie przesuwania wskaźnika myszy na obszarze formularza
Przy zwolnieniu przycisku myszy
Po zwolnieniu wcześniej wciśniętego przycisku myszy (wskaźnik na formularzu)
On Mouse Wheel
Przy przesuwaniu rolki myszy
Przy naciśniętym klawiszu
Po naciśnięciu klawisza klawiatury, gdy formularz uzyskał fokus; w trakcie korzystania z wbudowanego makra SendKeys
Przy zwolnieniu klawisza
Po zwolnieniu klawisza albo tuż po zakończeniu działania makra SendKeys
Przy naciśnięciu klawisza
Po wciśnięciu i zwolnieniu klawisza, gdy formularz uzyskał fokus; w trakcie korzystania z makra SendKeys
Ze zdarzeniami formularza dotyczącymi klawiatury ściśle związana jest właściwość Podgląd klawisza. Ta właściwość, dostępna wyłącznie w formularzach, instruuje Accessa, aby zdarzenia związane z klawiaturą miały pierwszeństwo przed zdarzeniami związanymi z formantami na formularzu. Domyślnie zdarzenia związane z formantami na formularzach Accessa mają pierwszeństwo przed zdarzeniami samego formularza. Na przykład po kliknięciu przycisku na formularzu to przycisk (a nie formularz) odbiera zdarzenie, choć także
774
Część VI Podstawy programowania w Accessie
formularz obsługuje zdarzenie kliknięcia. Oznacza to, że formanty formularza maskują zdarzenia samego formularza, dlatego ten nie może na nie odpowiedzieć. Aby formularz mógł odpowiadać na zdarzenia związane z klawiaturą (Przy naciśnięciu klawisza, Przy zwolnieniu klawisza itp.), trzeba ustawić właściwość Podgląd klawisza na Tak (True). Zdarzenia formularzy dotyczące danych Głównym przeznaczeniem formularzy Accessa jest wyświetlanie danych. Nic więc dziwnego, że formularze Accessa obsługują pewną liczbę zdarzeń bezpośrednio powiązanych z zarządzaniem danymi. W tej książce wielokrotnie spotkasz się z procedurami obsługi dla zdarzeń tego rodzaju. Pisze się je niemal zawsze podczas pracy z aplikacjami Accessa. Zdarzenia tego typu przedstawiono w tabeli 25.4. Tabela 25.4. Zdarzenia formularza związane z danymi Zdarzenie
Wyzwolenie zdarzenia
Przy bieżącym
Przy przejściu do innego rekordu, który staje się rekordem bieżącym
Przed wstawieniem
Po wprowadzeniu danych do nowego rekordu, ale przed właściwym utworzeniem rekordu
Po wstawieniu
Po dodaniu nowego rekordu do tabeli
Przed aktualizacją
Przed aktualizacją zmienionych danych w rekordzie
Po aktualizacji
Po aktualizacji zmienionych danych w rekordzie
Przy buforowaniu
W trakcie modyfikacji rekordu
Przy cofaniu
Gdy użytkownik przywraca wcześniejszy stan formularza (rekord wraca do stanu sprzed modyfikacji); przeciwieństwo właściwości Przy buforowaniu
Przy usunięciu
Po usunięciu rekordu, ale przed zakończeniem operacji usuwania
Potwierdzenie przed usunięciem
Na chwilę przed wyświetleniem okna dialogowego potwierdzającego usunięcie
Potwierdzenie po usunięciu
Po zamknięciu okna dialogowego potwierdzającego usunięcie
Przy błędzie
Po wystąpieniu błędu
Przy filtrowaniu
Po zdefiniowaniu, ale przed zastosowaniem filtra
Przy zastosowaniu filtra
Po zastosowaniu filtra
Zdarzenie Przy bieżącym jest zgłaszane bezpośrednio po odświeżeniu danych w formularzu. Zachodzi najczęściej wtedy, gdy użytkownik przenosi fokus do innego rekordu ze zbioru używanego w formularzu. Często wykorzystuje się je do wykonywania obliczeń na podstawie danych z formularza lub do zmiany wyglądu formantów. Na przykład jeśli określona liczba lub data wykracza poza oczekiwany zakres, za pomocą zdarzenia Przy bieżącym można zmienić właściwość BackColor pola tekstowego, aby użytkownik zauważył problem. Zdarzenia Przed wstawieniem i Po wstawieniu związane są z przenoszeniem nowego rekordu z formularza do powiązanego źródła danych. Zdarzenie Przed wstawieniem zgłaszane jest przed przeniesieniem danych przez Access, a Po wstawieniu — po umiesz-
Rozdział 25. Model zdarzeń
775
czeniu rekordu w źródle danych. Zdarzenia te można wykorzystać na przykład do rejestrowania operacji dołączania danych do tabeli. Zdarzenia Przed aktualizacją i Po aktualizacji często wykorzystuje się do sprawdzania poprawności danych przed ich przesłaniem do powiązanego źródła danych. W dalszej części rozdziału zobaczysz, że zdarzenia te są obsługiwane przez liczne formanty formularzy. Aktualizacja formantu ma miejsce bezpośrednio po zmodyfikowaniu zapisanych w nim danych. Zdarzenie Po aktualizacji formularza jest zgłaszane znacznie później niż Przed wstawieniem i Po wstawieniu. Zdarzenie Po aktualizacji ma miejsce, gdy formularz przygotowuje się do przejścia do następnego rekordu. Wielu programistów wykorzystuje zdarzenie Przed aktualizacją do sprawdzenia wszystkich formantów formularza w celu ustalenia, czy zapisane w nich dane są prawidłowe. Zdarzenie Przed aktualizacją formularza ma parametr Cancel. Ustawienie go na True powoduje anulowanie zdarzenia Przed aktualizacją. Jest to skuteczny sposób ochrony integralności danych aplikacji Accessa. Użytkownicy często chcą otrzymywać powiadomienia o oczekujących aktualizacjach przed przejściem do następnego rekordu. Gdy użytkownik przechodzi do następnego rekordu lub zamyka formularz, Access domyślnie automatycznie aktualizuje źródło danych powiązane z formularzem. Zdarzenie Przy buforowaniu jest zgłaszane zawsze wtedy, gdy użytkownik zmodyfikuje dane w formularzu. Zdarzenie to można wykorzystać do ustawienia zmiennej logicznej z poziomu modułu (np. bDirty), aby inne formanty formularza (takie jak przycisk zamykania) mogły wykryć, że w formularzu znajdują się niezatwierdzone zmiany. Jeśli wartość zmiennej bDirty to True, po kliknięciu przycisku zamykania lub zgłoszeniu zdarzenia Przed aktualizacją można wyświetlić okno z komunikatem Czy chcesz zatwierdzić zmiany?. Użytkownik może wtedy zatwierdzić wprowadzenie zmian w bazie.
Procedury obsługi zdarzeń formantów Formanty również wyzwalają zdarzenia. Zdarzenia formantów często służą do modyfikowania wyglądu kontrolek lub sprawdzania poprawności danych, gdy użytkownik zmienia zawartość danego formantu. Zdarzenia formantów określają też działanie myszy i klawiatury w czasie, gdy użytkownik korzysta z formantu. Zdarzenie Przed aktualizacją formantu wyzwala się w chwili, kiedy fokus opuszcza formant (dokładniej, zdarzenie Przed aktualizacją wyzwala się bezpośrednio przed przeniesieniem informacji z formantu do zbioru danych, dzięki czemu można anulować zdarzenie, jeśli nie powiedzie się test poprawności danych), natomiast zdarzenie Przed aktualizacją formularza zachodzi dopiero przy przejściu do następnego rekordu (zdarzenie Przed aktualizacją formularza powoduje zatwierdzenie całego rekordu w źródle danych formularza). Oznacza to, że zdarzenie Przed aktualizacją formantu nadaje się do sprawdzania poprawności pojedynczego formantu, natomiast zdarzenie Przed aktualizacją formularza można wykorzystać do sprawdzania poprawności wielu formantów na formularzu. Zdarzenie formularza Przed aktualizacją to dobre miejsce do sprawdzenia, czy wartości w dwóch różnych formantach są ze sobą zgodne (np. kod pocztowy w jednym polu i miasto w drugim). Można je wykorzystać zamiast zdarzenia Przed aktualizacją każdego z formantów.
776
Część VI Podstawy programowania w Accessie
Procedury zdarzeń wykorzystywane do obsługi zdarzeń wywoływanych przez formanty tworzy się tak samo jak procedury zdarzeń dla formularzy. Wystarczy przy odpowiedniej właściwości zdarzenia wybrać z listy rozwijanej [Procedura zdarzenia], a następnie w edytorze VBA wprowadzić odpowiedni kod źródłowy procedury. Wszystkie właściwości zdarzeń wraz z opisami ich działania zaprezentowano w tabeli 25.5. Podczas przeglądania informacji w tabeli 25.5 należy pamiętać, że nie każdy formant obsługuje każde zdarzenie. Tabela 25.5. Zdarzenia formantów Zdarzenie
Wyzwolenie zdarzenia
Przed aktualizacją
Przed aktualizacją danych z formantu w powiązanym rekordzie
Po aktualizacji
Po aktualizacji zmodyfikowanych danych formantu w rekordzie
Przy buforowaniu
W trakcie modyfikacji zawartości formantu
Przy cofaniu
W przypadku powrotu do stanu sprzed modyfikacji
Przy zmianie
Przy zmianie zawartości pola tekstowego albo pola kombi
Przy aktualizacji
Po modyfikacji danych w formancie ActiveX
Przy wartości spoza listy
Gdy wprowadzona wartość nie znajduje się w liście pola kombi
Przy wejściu
Tuż przed uzyskaniem fokusu od innego formantu
Przy zakończeniu
Tuż przed utratą fokusu na rzecz innego formantu
Przy uzyskaniu fokusu
Po uzyskaniu fokusu przez nieaktywny formant
Przy utracie fokusu
Po utracie fokusu przez formant
Przy kliknięciu
Po naciśnięciu i zwolnieniu (czyli kliknięciu) lewego przycisku myszy na formancie
Przy dwukrotnym kliknięciu
Po dwukrotnym naciśnięciu i zwolnieniu (czyli kliknięciu) lewego przycisku myszy na formancie
Przy naciśnięciu przycisku myszy
Po naciśnięciu przycisku, gdy wskaźnik myszy znajduje się na formancie
Przy ruchu myszy
W trakcie przesuwania wskaźnika myszy na obszarze formantu
Przy zwolnieniu przycisku myszy
Po zwolnieniu wcześniej wciśniętego przycisku myszy (wskaźnik na formancie)
Przy naciśniętym klawiszu
Po naciśnięciu klawisza, gdy formant uzyskał fokus; w trakcie korzystania makra SendKeys
Przy naciśnięciu klawisza
Po wciśnięciu i zwolnieniu przycisku, gdy formularz uzyskał fokus; w trakcie korzystania z makra SendKeys
Przy zwolnieniu klawisza
Po zwolnieniu klawisza albo tuż po zakończeniu działania makra SendKeys
Rozdział 25. Model zdarzeń
777
Procedury zdarzeń związane z raportami W raportach, podobnie jak w formularzach, można używać procedur zdarzeń do reagowania na konkretne zdarzenia. Raporty w Accessie obsługują zdarzenia z poziomu samego raportu, a także z poziomu poszczególnych sekcji. Formanty z raportów Accessa nie zgłaszają zdarzeń. Procedury zdarzeń powiązane z raportem są uruchamiane przy otwieraniu, zamykaniu lub drukowaniu raportów. Również dla każdej sekcji (nagłówka, stopki itd.) istnieją zdarzenia uruchamiane w trakcie formatowania lub drukowania raportu. Istnieje kilka ogólnych właściwości zdarzeń raportów. Zdarzenia raportów Accessa opisano w tabeli 25.6. Jak widać, ich lista jest znacznie krótsza od listy zdarzeń formularza. Tabela 25.6. Zdarzenia raportów Właściwość zdarzenia
Wyzwolenie zdarzenia
Przy otwarciu
Po otwarciu raportu, ale przed jego wydrukowaniem
Przy zamknięciu
Po zamknięciu raportu i usunięciu go z ekranu
Przy aktywowaniu
Gdy raport otrzymał fokus i stał się aktywnym oknem
Przy dezaktywowaniu
Gdy inne okno stało się aktywne
Przy braku danych
Gdy do otwieranego raportu nie przekazano danych
Przy stronie
Po zmianie stron w raporcie
Przy błędzie
Po wystąpieniu błędu czasu wykonania w Accessie
Choć interakcje użytkowników z raportami są znacznie bardziej ograniczone niż z formularzami, zdarzenia są ważne także w trakcie projektowania raportów. Otwarcie raportu bez danych zwykle prowadzi do niepożądanych efektów. Raport może wtedy wyświetlać tytuł, ale bez szczegółowych informacji. Może też wyświetlać tekst #error zamiast brakujących danych. Może to przestraszyć użytkownika. Wykorzystaj zdarzenie Przy braku danych, aby poinformować użytkownika o tym, że raport nie zawiera danych. Zdarzenie to jest zgłaszane, gdy w źródle danych otwieranego raportu informacje są niedostępne. Za pomocą procedury obsługi zdarzenia Przy braku danych możesz wyświetlić okno komunikatu z opisem sytuacji, a następnie anulować otwieranie raportu. Na rysunku 25.3 przedstawiono typową procedurę obsługi zdarzenia Przy braku danych. Rysunek 25.3. Uruchamianie procedury obsługi zdarzenia Przy braku danych, gdy w raporcie nie ma danych
778
Część VI Podstawy programowania w Accessie
Przedstawiona na rysunku 25.3 procedura Report_NoData najpierw wyświetla okno komunikatu, aby poinformować użytkownika, że raport nie zawiera danych. Następnie procedura anuluje otwieranie raportu. W tym celu ustawia parametr Cancel na True. Powoduje to, ze raport nie pojawia się na ekranie i nie jest wysyłany do drukarki. Wiele zdarzeń Accessa ma parametry takie jak Cancel na rysunku 25.3. Tu ustawienie parametru Cancel na True jest dla Accessa informacją, że ma zignorować proces, który zgłosił zdarzenie. Ponieważ w trakcie otwierania raportu wystąpiło zdarzenie NoData, ustawienie tego parametru zapobiega przesłaniu raportu do drukarki i wyświetleniu go na ekranie. W dalszej części książki wielokrotnie zetkniesz się z parametrami procedur obsługi zdarzeń.
Procedury zdarzeń dotyczących sekcji raportów Oprócz właściwości zdarzeń samego formularza Access udostępnia też trzy specjalne właściwości zdarzeń dotyczące sekcji raportów. W tabeli 25.7 opisano te zdarzenia, ich działanie, a także sytuacje, w których są zgłaszane. Tabela 25.7. Zdarzenia sekcji raportów Zdarzenie
Wyzwolenie zdarzenia
Przy formatowaniu
Zgłaszane, gdy sekcja jest wstępnie formatowana w pamięci przed przesłaniem do drukarki. Na tym etapie można w specjalny sposób zmienić wygląd formantów z danej sekcji.
Przy wydruku
Zgłaszane, gdy sekcja jest wysyłana do drukarki. Po zgłoszeniu zdarzenia Przy wydruku jest już za późno na zmianę wyglądu formantów.
Przy powrocie
Zgłaszane po zdarzeniu Przy formatowaniu, ale przed zdarzeniem Przy wydruku. Zachodzi, gdy Access musi zapisać wszystkie pozostałe sekcje strony, aby w kilku przebiegach sformatować dane. Zdarzenie Przy powrocie dotyczy wszystkich sekcji oprócz nagłówków i stopek.
Zdarzenie Przy formatowaniu pozwala dodać specjalne formatowanie do formantów z sekcji przed jej wyświetleniem. Zdarzenie to przydaje się na przykład do ukrywania formantów, których z powodu wystąpienia pewnego warunku w danych nie należy drukować. Procedura obsługi zdarzenia jest uruchamiana, gdy Access zapisuje sekcję w pamięci, ale przed przesłaniem raportu do drukarki. Właściwości zdarzeń Przy formatowaniu i Przy wydruku można ustawić dla dowolnej sekcji raportu. Właściwości Przy powrocie nie można jednak stosować dla nagłówków i stopek strony. Na rysunku 25.4 pokazano arkusz właściwości z właściwością zdarzenia Przy braku danych. Zauważ, że na liście rozwijanej w górnej części arkusza właściwości wybrany jest raport. Dlatego zdarzenia w zakładce Zdarzenie dotyczą całego raportu, a nie konkretnego formantu. Oprócz zdarzenia Przy braku danych często stosuje się też inne zdarzenia raportów. Na rysunku 25.5 pokazano, jak dodać do zdarzenia Przy formatowaniu raportu kod, który pozwala kontrolować widoczność formantów w raporcie.
Rozdział 25. Model zdarzeń
779
Rysunek 25.4. Określanie procedury obsługi zdarzenia dla raportu Rysunek 25.5. Procedura zdarzenia wyświetlająca lub ukrywająca formant w raporcie
Procedura Detail0_Format z rysunku 25.5 najpierw sprawdza wartość formantu txtQtyIn Stock. Jeśli ta wartość jest mniejsza niż 10, należy wyświetlić etykietę lblLowStock. W przeciwnym razie formant z ostrzeżeniem jest ukrywany. Access tworzy nazwy sekcji, dołączając cyfrę do typu sekcji (np. Detail0). Za pomocą właściwości Nazwa można zmienić te nazwy.
W książce tej znajdziesz wiele przykładów wykorzystania zdarzeń i procedur ich obsługi do manipulowania formularzami, raportami i formantami.
780
Część VI Podstawy programowania w Accessie
Kolejność zdarzeń Czasami nawet stosunkowo proste działanie użytkownika wyzwala wiele szybko następujących po sobie zdarzeń. Na przykład za każdym razem, kiedy użytkownik wciska klawisz, zachodzą następujące zdarzenia: Przy naciśnięciu klawisza, Przy naciśniętym klawiszu oraz Przy zwolnieniu klawisza. Podobnie wciśnięcie lewego przycisku myszy wyzwala zdarzenia Przy naciśnięciu przycisku myszy, Przy zwolnieniu przycisku myszy oraz Przy kliknięciu. Decyzja o tym, które zdarzenie w aplikacji Accessa będzie zaprogramowane, zależy od programisty języka VBA. Zdarzenia nie zachodzą losowo. Są wyzwalane w sposób, który można przewidzieć, w zależności od tego, który formant je wyzwala. Czasami najtrudniejszym elementem pracy ze zdarzeniami jest śledzenie kolejności, w jakiej one zachodzą. Czasami jest ona mało intuicyjna, na przykład zdarzenie Przy wejściu zachodzi przed zdarzeniem Przy uzyskaniu fokusu (zobacz tabela 25.2) lub zdarzenie Przy naciśniętym klawiszu zachodzi przed zdarzeniem Przy naciśnięciu klawisza (zobacz tabela 25.3).
Często występujące sekwencje zdarzeń W poniższych punktach została przedstawiona kolejność zdarzeń dla najczęściej występujących scenariuszy zachodzących w formularzach:
Otwieranie i zamykanie formularzy
Kiedy formularz się otwiera: Przy otwarciu (formularz) Przy załadowaniu (formularz) Przy zmianie rozmiaru (formularz) Przy aktywowaniu (formularz) Przy bieżącym (formularz) Przy wejściu (formant) Przy uzyskaniu fokusu (formant).
Kiedy formularz się zamyka: Przy zakończeniu (formant) Przy utracie fokusu (formant) Przy zwolnieniu (formularz) Przy dezaktywowaniu (formularz) Przy zamknięciu (formularz).
Zmiana fokusu
Przy przejściu fokusu z jednego formularza do innego: Przy dezaktywowaniu (formularz1) Przy aktywowaniu (formularz2).
Kiedy fokus przechodzi do formantu na formularzu: Przy wejściu Przy uzyskaniu fokusu.
Kiedy fokus opuszcza formant na formularzu: Przy zakończeniu Przy utracie fokusu.
Przy przejściu fokusu z jednego formantu do innego: Przy zakończeniu (formant1) Przy utracie fokusu (formant1) Przy wejściu (formant2) Przy uzyskaniu fokusu (formant2).
Kiedy fokus opuści rekord, w którym zmodyfikowano dane, ale przed przejściem do następnego rekordu: Przed aktualizacją (formularz) Po aktualizacji (formularz) Przy zakończeniu (formant) Przy utracie fokusu (formant) Przy bieżącym (formularz).
Rozdział 25. Model zdarzeń
781
Kiedy fokus przechodzi do istniejącego rekordu w widoku formularza: Przed aktualizacją (formularz) Po aktualizacji (formularz) Przy bieżącym (formularz).
Modyfikacje danych
Przy wprowadzeniu lub modyfikacji danych w formancie formularza, gdy fokus przechodzi do innego formantu: Przed aktualizacją Po aktualizacji Przy zakończeniu Przy utracie fokusu.
Kiedy użytkownik naciśnie i zwolni klawisz w sytuacji, kiedy formant formularza posiada fokus: Przy naciśniętym klawiszu Przy naciśnięciu klawisza Przy zwolnieniu klawisza.
Kiedy zmieni się tekst w polu tekstowym lub w tekstowej części pola kombi: Przy naciśniętym klawiszu Przy naciśnięciu klawisza Przy zmianie Przy zwolnieniu klawisza.
Po wprowadzeniu w polu kombi wartości, której nie ma na liście pola kombi: Przy naciśniętym klawiszu Przy naciśnięciu klawisza Przy zmianie Przy zwolnieniu klawisza Przy wartości spoza listy Przy błędzie.
Kiedy zmienią się dane w formancie, a użytkownik wciśnie klawisz Tab w celu przejścia do następnego formantu:
Formant 1: Przy naciśniętym klawiszu Przed aktualizacją Po aktualizacji Przy zakończeniu Przy utracie fokusu.
Formant 2: Przy wejściu Przy uzyskaniu fokusu Przy naciśnięciu klawisza Przy zwolnieniu klawisza.
Kiedy otworzy się formularz i zmienią się dane w formancie: Przy bieżącym (formularz) Przy wejściu (formant) Przy uzyskaniu fokusu (formant) Przed aktualizacją (formant) Po aktualizacji (formant).
W przypadku usunięcia rekordu: Przy usunięciu Potwierdzenie przed usunięciem Potwierdzenie po usunięciu.
Kiedy fokus przejdzie do nowego, pustego rekordu w formularzu i utworzy się nowy rekord w momencie wpisania danych w formancie: Przy bieżącym (formularz) Przy wejściu (formant) Przy uzyskaniu fokusu (formant) Przed wstawieniem (formant) Po wstawieniu (formant).
Zdarzenia związane z myszą
Kiedy użytkownik wciśnie i zwolni (kliknie) przycisk myszy w momencie, kiedy wskaźnik myszy znajduje się na formancie formularza: Przy naciśnięciu przycisku myszy Przy zwolnieniu przycisku myszy Przy kliknięciu.
Kiedy użytkownik przeniesie fokus z jednego formantu do innego poprzez kliknięcie drugiego formantu:
Formant 1: Przy zakończeniu Przy utracie fokusu.
Formant 2: Przy wejściu Przy uzyskaniu fokusu Przy naciśnięciu przycisku myszy Przy zwolnieniu przycisku myszy Przy kliknięciu.
782
Część VI Podstawy programowania w Accessie
Kiedy użytkownik dwukrotnie kliknie formant inny niż przycisk polecenia: Przy naciśnięciu przycisku myszy Przy zwolnieniu przycisku myszy Przy kliknięciu Przy dwukrotnym kliknięciu Przy zwolnieniu przycisku myszy.
Pisanie prostych procedur obsługi zdarzeń formularzy i formantów Pisanie prostych procedur, które sprawdzają kolejność występowania zdarzeń formularz lub formantu, jest dosyć łatwe. Informacje zamieszczone wcześniej można wykorzystać do sprawdzenia zdarzeń, które należy wykorzystać w aplikacji. Bardzo często przyczyną nieoczekiwanego działania aplikacji są procedury obsługi zdarzeń dowiązane do zdarzeń, które zachodzą zbyt późno (lub zbyt wcześnie), aby było możliwe pobranie informacji wymaganych przez aplikację. W przykładowej bazie danych Rozdział25.accdb znajduje się formularz frmEventLogger, który w oknie Immediate wyświetla zdarzenia zachodzące dla przycisku polecenia, pola tekstowego i przełącznika. Formularz ten zamieszczono po to, aby zademonstrować, jak wiele zdarzeń Accessa zachodzi przy wykonywaniu prostych działań. Na przykład jednokrotne kliknięcie przycisku polecenia, a następnie przełączenie się klawiszem Tab do pola tekstowego i wciśnięcie jednego klawisza na klawiaturze powoduje wygenerowanie następujących zdarzeń: cmdButton_MouseDown cmdButton_MouseUp cmdButton_Click cmdButton_KeyDown cmdButton_Exit cmdButton_LostFocus txtText1_Enter txtText1_GotFocus txtText1_KeyPress txtText1_KeyPress txtText1_KeyUp txtText1_KeyDown txtText1_KeyPress txtText1_Change txtText1_KeyUp
Aby zobaczyć te zdarzenia, należy otworzyć edytor kodu i wyświetlić okno Immediate. W tym celu wystarczy wcisnąć klawisze Ctrl+G z dowolnego miejsca w środowisku Accessa. Natychmiast otworzy się edytor kodu i wyświetli okno Immediate. Następnie za pomocą klawiszy Alt+Tab wróć do głównego ekranu Accessa, otwórz formularz i kliknij różne formanty oraz wpisz tekst w polu tekstowym. Po wciśnięciu klawiszy Ctrl+G w celu powrotu do okna Immediate zobaczysz długą listę zdarzeń.
Rozdział 25. Model zdarzeń
783
Zdarzeń jest oczywiście znacznie więcej niż się ich kiedykolwiek wykorzysta. Warto zwrócić uwagę, że w przypadku przycisku polecenia zarówno zdarzenie Przy naciśnięciu klawisza, jak i Przy zwolnieniu przycisku myszy zachodzą przed zdarzeniem Przy kliknięciu. Poza tym zdarzenie Przy naciśnięciu klawisza występuje po naciśnięciu klawisza Tab, a zdarzenie Przy zakończeniu przycisku polecenia zachodzi przed jego zdarzeniem Przy utracie fokusu (oczywiście po wciśnięciu klawisza Tab fokus przechodzi z przycisku polecenia do pola tekstowego). Warto również zwrócić uwagę, że pole tekstowe wyzwala więcej niż jedno zdarzenie Przy naciśniętym klawiszu. Pierwsze z nich pochodzi od klawisza Tab, natomiast drugie jest generowane w momencie wciśnięcia klawisza na klawiaturze. Chociaż może się wydawać dziwne, że zdarzenie Przy naciśniętym klawiszu klawisza Tab zostało przechwycone przez pole tekstowe (a nie przez przycisk polecenia), ma to sens, jeśli wziąć pod uwagę, co się dzieje na zapleczu. Wciśnięcie klawisza Tab to polecenie przeniesienia fokusu do następnego w kolejności formantu. W rzeczywistości Access przenosi fokus przed przekazaniem zdarzenia Przy naciśniętym klawiszu do formantów na formularzu. Oznacza to, że fokus przechodzi do pola tekstowego, a pole tekstowe otrzymuje zdarzenie Przy naciśniętym klawiszu wyzwolone przez klawisz Tab. Warto pamiętać, że programiści piszą kod tylko dla zdarzeń potrzebnych w rozwijanej aplikacji. Zdarzenie, z którym nie powiązano kodu, jest przez Accessa ignorowane i nie ma wpływu na działanie aplikacji. Możliwe jest też, że w celu wykonania określonego zadania zaprogramujesz nieodpowiednie zdarzenie. Możesz na przykład chcieć zmienić wygląd formantu za pomocą kodu zdarzenia Przy wejściu (wielu programistów modyfikuje właściwości BackColor i Fore Color formantu, aby użytkownicy mogli łatwiej zauważyć, który formant jest aktywny). Szybko odkryjesz, że zdarzenie to nie jest wiarygodnym dowodem na to, że kontrolka uzyskała fokus. Do kontrolowania interfejsu użytkownika przeznaczone są specjalne zdarzenia Przy uzyskaniu fokusu i Przy utracie fokusu, natomiast zdarzenia Przy wejściu i Przy wyjściu są bardziej „teoretyczne” i często nie programuje się ich w aplikacjach Accessa. Ten prosty przykład pomaga wyjaśnić, dlaczego w Accessie dostępnych jest tak wiele zdarzeń. Microsoft starannie zaprojektował Accessa, aby obsługiwał różne kategorie zdarzeń, dotyczące na przykład zadań związanych z danymi i interfejsem użytkownika. Zdarzenia zapewniają bogate środowisko programowania. Prawie zawsze znajdziesz w nim formant, zdarzenie lub technikę programowania, które pozwolą zmusić Accessa do wykonania odpowiedniej operacji. Otwieranie formularza za pomocą procedurą zdarzenia W wielu aplikacjach trzeba skorzystać z kilku formularzy i raportów, aby wykonać wszystkie zadania biznesowe. Zamiast wymuszać na użytkownikach przeglądanie wszystkich formularzy i raportów znajdujących się w oknie aplikacji w celu odnalezienia tego, który jest potrzebny do wykonania określonego zadania, tworzy się specjalny formularz — panel przełączania. Na panelu przełączania umieszcza się przyciski, których etykiety informują użytkownika o funkcjach możliwych do wykonania za pomocą danej aplikacji. Przyciski służą do otwierania odpowiednich formularzy i raportów. Na rysunku 25.6 przedstawiono panel przełączania aplikacji MiniAuta dla Kolekcjonerów.
784
Część VI Podstawy programowania w Accessie
Rysunek 25.6. Panel przełączania aplikacji pomaga użytkownikowi w odnalezieniu odpowiednich raportów i formularzy
Panel przełączania aplikacji MiniAuta dla Kolekcjonerów zawiera pięć przycisków poleceń. Naciśnięty przycisk wywołuje odpowiednią procedurę zdarzenia. Na przykład przycisk obok etykiety Produkty (cmdProducts) uruchamia procedurę zdarzenia, której zadaniem jest otwarcie formularza z produktami o nazwie frmProducts. Rysunek 25.7 przedstawia okno właściwości przycisku o nazwie cmdProducts. Rysunek 25.8 przedstawia natomiast kod VBA procedury dla zdarzenia Przy kliknięciu1 przycisku cmdProducts. Procedura zdarzenia zamykająca formularz Czasem się zdarza, że przed opuszczeniem lub zamknięciem formularza powinno być wykonane jakieś dodatkowe zadanie. Przykładem takiego dodatkowego zadania jest automatyczne wylogowanie wszystkich użytkowników formularza albo automatyczne zamknięcie formularza drukowania, gdy użytkownik zamknie formularz główny. Aby formularz frmDialogProductPrint był zamykany automatycznie w przypadku zamknięcia formularza frmProducts, trzeba utworzyć dla tego ostatniego odpowiednią procedurę zdarzenia Przy zamknięciu. Rysunek 25.9 przedstawia taką procedurę. Procedura zdarzenia Form_Close, której kod przedstawiono na rysunku 25.9, najpierw sprawdza, czy formularz frmDialogProductPrint jest otwarty. Jeśli tak, uruchamiana jest instrukcja jego zamknięcia. Chociaż próba zamknięcia formularza, który nie jest otwarty, nie powoduje błędu, przed próbą wykonania operacji z obiektem zawsze warto sprawdzić, czy jest on dostępny. 1
W polskiej wersji Accessa przetłumaczono tylko właściwości zdarzeń (np. Przy kliknięciu), ale identyfikatory wykorzystywane w Visual Basicu pozostały w języku angielskim (np. OnClick). Dlatego też procedura obsługi zdarzenia Przy kliknięciu ma nazwę _Click. Wszystkie procedury obsługi zdarzenia otrzymują nazwy _. Zmieniając człon na polski, zmienimy charakter procedury (nie będzie to już procedura obsługi zdarzenia) — przyp. tłum.
Rozdział 25. Model zdarzeń
Rysunek 25.7. Przypisywanie procedury zdarzenia do odpowiedniego zdarzenia formantu Rysunek 25.8. Wykorzystanie procedury zdarzenia do otwarcia formularza
Rysunek 25.9. Uruchamianie procedury zdarzenia w momencie zamykania formularza
785
786
Część VI Podstawy programowania w Accessie
Procedura zdarzenia zatwierdzająca usunięcie rekordu Chociaż rekord w formularzu można usunąć korzystając z polecenia Usuń z grupy Rekordy zakładki NARZĘDZIA GŁÓWNE wstążki Accessa, lepszą praktyką jest umieszczenie przycisku polecenia Usuń bezpośrednio na formularzu. W ten sposób użytkownik będzie od razu wiedział, w jaki sposób usunąć rekord — po prostu kliknie odpowiedni przycisk. Dodatkowo w procedurze zdarzenia przycisku Usuń można umieścić odpowiedni kod, który zostanie wykonany tuż przed usunięciem rekordu, co daje możliwość większej kontroli nad procesem usuwania. Można też sprawdzić więzy integralności, aby uzyskać pewność, że usunięcie rekordu nie spowoduje utraty powiązania z rekordem z innej tabeli w bazie danych. Do potwierdzenie zamiaru usunięcia rekordu można skorzystać z funkcji MsgBox(). W procedurze zdarzenia dla przycisku cmdDelete wykorzystano wspomnianą funkcję do zatwierdzania usunięcia (zobacz rysunek 25.10). Rysunek 25.10. Zastosowanie funkcji MsgBox() do zatwierdzenia usunięcia
W trakcie wykonywania procedury zdarzenia CmdDelete_Click() Access wyświetla na ekranie okno z komunikatem przedstawione na rysunku 25.11. Zwróć uwagę, że okno zawiera dwa przyciski: Tak i Nie. Po wyświetleniu okna Access oczekuje na ostateczną decyzję użytkownika, czy usunąć dany rekord czy nie. Rekord jest usuwany tylko wtedy, gdy użytkownik potwierdzi zamiar usunięcia poprzez kliknięcie przycisku Tak. Rysunek 25.11. Okno z prośbą o potwierdzenie usunięcia rekordu
Rozdział 25. Model zdarzeń
787
Przed wykonaniem instrukcji RunCommand acCmdDeleteRecord program automatycznie sprawdza, czy usunięcie rekordu nie spowoduje naruszenia więzów integralności ustawionych w oknie Relacje. Jeśli usunięcie rekordu narusza integralność danych, w Accessie wystąpi błąd i operacja usunięcia zostanie anulowana. Więcej informacji na temat definiowania więzów integralności między tabelami w bazie danych, można znaleźć w rozdziale 4.
788
Część VI Podstawy programowania w Accessie
Rozdział 26.
Debugowanie aplikacji Accessa W tym rozdziale:
Porządkowanie kodu VBA
Testowanie aplikacji
Tradycyjny model debugowania (z wykorzystaniem instrukcji MsgBox i Debug.Print)
Korzystanie z narzędzi diagnostycznych dostępnych w Accessie
Przechwytywanie nieoczekiwanych błędów
W wielu aplikacjach Accessa występują duże ilości kodu VBA — w formularzach, raportach i samodzielnych modułach. Z uwagi na duże i różnorodne możliwości język VBA jest wykorzystywany we wszystkich aspektach programowania aplikacji — od komunikowania się z użytkownikami przez wyświetlanie komunikatów i przekształcanie danych pobieranych z tabel i kwerend po obsługę formularzy i raportów. Ponieważ kod VBA jest często skomplikowany (a przynajmniej na taki wygląda!), debugowanie błędów i problemów w aplikacjach bywa trudne i czasochłonne. W zależności od tego, jak dobrze uporządkowany jest kod i czy programista zastosował proste konwencje (np. nadał opisowe nazwy zmiennym i procedurom), szukanie nawet drobnego błędu w kodzie może być frustrujące. Na szczęście Access udostępnia pełny zestaw narzędzi diagnostycznych, które ułatwiają pracę programistom. Narzędzia te nie tylko pozwalają zaoszczędzić czas, ponieważ wskazują źródło błędu, ale też pomagają lepiej zrozumieć strukturę kodu i przekazywanie sterowania między procedurami. W rozdziale tym w dużym stopniu zignorowano błędy spowodowane nieprawidłowym projektem: nieprawidłową reprezentację danych spowodowaną błędnie zaprojektowanymi kwerendami, anomalie związane z aktualizacją i dodawaniem rekordów, których przyczyną są nieprawidłowe reguły więzów integralności używane w aplikacji, itp. W większości przypadków przyczyną tych problemów jest nieprzestrzeganie reguł projektowania,
790
Część VI Podstawy programowania w Accessie niewłaściwe rozumienie projektu kwerend w Accessie itd. Rozdział ten pomaga jednak poradzić sobie z błędami, które wkradają się do kodu VBA — zwłaszcza tymi, które powodują zauważalne problemy z danymi bądź interfejsem użytkownika w aplikacjach. W tym rozdziale założono, że Czytelnicy potrafią projektować i implementować struktury danych w aplikacji oraz że tabele, kwerendy oraz inne komponenty strukturalne baz danych nie sprawiają im problemów. W tym rozdziale użyto przykładów, które różnią się od tych z wcześniejszych części tej książki. Przykładowy kod prezentowany w tym rozdziale można znaleźć w pliku Rozdział26.accdb. Kod zawarty w tym pliku nie zawsze wykonuje przydatne działania. Kod ten służy bardziej jako środowisko testowe, pozwalające wykonać ćwiczenia z zakresu posługiwania się narzędziami diagnostycznymi Accessa, niż jako dobry przykład praktycznego kodu VBA. Wiele instrukcji w przykładach oznaczono jako komentarz ze względu na to, że zawierają błędy składniowe i inne problemy. Aby obejrzeć błąd generowany przez określony wiersz kodu lub zapoznać się z pomocą wbudowaną w programie Microsoft Access, należy usunąć apostrof z początku wybranego wiersza.
Porządkowanie kodu VBA Pierwszy krok w procesie debugowania kodu polega na unikaniu popełniania błędów. Nie powinno nikogo zaskakiwać, że nawyki programistyczne mają duży wpływ na typ i liczbę popełnianych pomyłek. Zastosowanie prostych konwencji programowania bardzo często pomaga wyeliminować wszystkie oprócz najbardziej skomplikowanych błędów składniowych i logicznych w kodzie VBA. Omówienie niektórych konwencji znajdziesz w innych miejscach tej książki. Tutaj przedstawiamy pomocny przegląd technik z tego obszaru.
Stosowanie konwencji nazewniczej. Konwencje nazewnictwa procedur, zmiennych i stałych nie muszą być skomplikowane. Konsekwentnie stosowane konwencje pomagają wykrywać błędy, które mogłyby pozostać niezauważone. Próba przypisania wartości do stałej, zastosowania zmiennej typu String w obliczeniach matematycznych lub przekazania do funkcji argumentów o niewłaściwym typie to przykładowe problemy, których dzięki konwencji nazewniczej można uniknąć.
Ograniczanie zasięgu zmiennych. Zmienne powinny mieć jak najmniejszy zasięg, przy którym program będzie działał wydajnie i poprawnie. Zmienne domyślnie należy tworzyć na poziomie procedury i zwiększać zasięg tylko wtedy, gdy działanie kodu tego wymaga. Zmienne globalne warto przechowywać w odrębnym module. Gdy lista zmiennych globalnych staje się zbyt długa, należy pomyśleć o refaktoryzacji kodu.
Stosowanie stałych. Stałe to doskonałe narzędzie do poprawy czytelności kodu i zapobiegania błędom. Stała dMINIMALNY_RABAT jest dużo bardziej zrozumiała niż magiczna liczba, np. 5000. Postaraj się usunąć z kodu wszystkie magiczne liczby i zapisać je jako stałe o opisowych nazwach. Nawet jeśli nie zdołasz pozbyć się wszystkich takich liczb, kod stanie się solidniejszy i bardziej odporny na błędy w porównaniu z wersją, w której znajduje się wiele magicznych liczb.
Rozdział 26. Debugowanie aplikacji Accessa
791
Tworzenie krótkich procedur. Procedura zwykle powinna wykonywać tylko jedno zadanie. Jeśli jest na tyle długa, że nie mieści się na ekranie, warto pomyśleć o rozdzieleniu jej na kilka procedur i wywoływaniu każdej z nich w głównej procedurze. Oczywiście zdarzają się sytuacje, gdy procedura wykonuje więcej niż jedno zadanie. Zarządzanie kodem jest jednak znacznie łatwiejsze przy stosowaniu wielu prostych procedur zamiast jednej długiej.
Tworzenie uporządkowanych modułów. Nie istnieje ograniczenie liczby modułów w projekcie. Wszystkie procedury w module powinny być ze sobą powiązane. Moduły z kodem formularzy i raportów powinny zawierać procedury zdarzeń nadrzędnego obiektu oraz powiązane z nimi procedury pomocnicze. Przechowywanie w module tylko powiązanych ze sobą procedur daje większą pewność, że zmienne prywatne z modułu nie będą używane w nieprawidłowy sposób.
Stosowanie komentarzy tam, gdzie to konieczne. Komentarze mogą być ważną częścią kodu projektu. Jeśli jednak jest ich zbyt dużo, nikt nie będzie ich czytał i po wprowadzeniu zmian w kodzie szybko staną się nieaktualne. Stosuj odpowiednie nazwy dla procedur, zmiennych i stałych, aby kod sam był dla siebie dokumentacją. Komentarze dodawaj do niestandardowego kodu lub w celu wyjaśnienia, dlaczego wybrałeś określone rozwiązanie danego problemu. Komentarze nie powinny opisywać, jak działa kod, ale wyjaśniać, dlaczego kod funkcjonuje w określony sposób.
Unikanie powtórzeń. Duża część tworzonego kodu wygląda powtarzalnie, zwłaszcza gdy piszesz kod obsługi zdarzeń formularza z dużą liczbą formantów. Jeśli masz wrażenie, że cały czas piszesz ten sam kod, pomyśl o przeniesieniu go do odrębnej procedury i przekazywaniu do niego argumentów z procedury obsługi zdarzenia. Dzięki temu, gdy trzeba będzie wprowadzić zmiany w kodzie, wystarczy zrobić to w jednym miejscu. Pozwala to przyspieszyć pracę i uniknąć błędów.
Częste kompilowanie kodu. Kompiluj projekt za każdym razem, gdy napiszesz lub zmodyfikujesz kilka wierszy kodu. Nie czekaj z kompilacją do momentu napisania całego modułu lub projektu. Wykrywanie błędów składni w trakcie pisania kodu umożliwia łatwe ich naprawienie. W czasie pisania procedury dobrze wiesz, jak działa i gdzie jest używana. To najlepszy moment na wykrycie usterek.
Testowanie aplikacji Testowanie aplikacji Accessa jest procesem ciągłym. Za każdym razem, gdy przełączasz się w formularzu lub raporcie z widoku projektu do widoku normalnego lub opuszczasz edytor VBA w celu uruchomienia fragmentu kodu, testujesz aplikację. Za każdym razem, gdy napiszesz linijkę kodu i przechodzisz do kolejnej, parser składniowy języka VBA sprawdza napisany kod. Za każdym razem, gdy zmodyfikujesz właściwość formularza lub raportu i przeniesiesz kursor do innej właściwości lub innego formantu, testujesz zmienioną właściwość. Testowanie pozwala na przekonanie się, że aplikacja działa zgodnie z oczekiwaniami, lub sprawdzenie, czy w ogóle działa. Odkrycie w wyniku próby uruchomienia aplikacji, że aplikacja nie działa, oznacza znalezienie błędu (ang. bug). Poprawianie błędów najczęściej określa się jako debugowanie.
792
Część VI Podstawy programowania w Accessie Termin ten pamięta jeszcze pierwsze komputery bazujące na lampach elektronowych. Legenda głosi, że ćma spowodowała zamknięcie obwodu elektrycznego. Termin debugowanie, oznaczający pierwotnie usunięcie ćmy, zawdzięczamy pionierce komputeryzacji, nieżyjącej admirał Grace Hopper.
Kiedy po uruchomieniu raportu nie widać żadnych danych, trzeba sprawdzić właściwość Źródło rekordów raportu, aby się upewnić, czy trafiają do niego właściwe dane. Aby sprawdzić, czy przyczyną problemu jest źródło danych, należy przejrzeć kwerendę lub tabelę. Jeśli po uruchomieniu formularza w poszczególnych formantach wyświetli się tekst #Nazwa lub #Błąd, to trzeba sprawdzić właściwość Źródło formantu. Być może występuje nieprawidłowe odwołanie do pola tabeli lub literówka w nazwie i Access nie potrafi prawidłowo zinterpretować odwołania. Być może w wyrażeniu występuje zbyt dużo nawiasów lub użyto nazwy formantu we wzorze, która koliduje ze słowem kluczowym Accessa. Za każdym razem, kiedy wystąpi problem, warto zapytać kogoś z większym doświadczeniem, czego problem dotyczy, poszukać informacji w internecie lub książce, albo sprawdzić składnię wzoru. Większość problemów dotyczących projektu kwerend, formularzy i raportów objawia się w dość oczywisty sposób. Jeśli kwerenda zwraca nieprawidłowe dane albo formularz lub raport nie chce się otworzyć (bądź przy otwieraniu zwraca komunikat o błędzie), wiadomo, że wystąpił błąd. Access wykonuje na zapleczu doskonałą pracę, która ułatwia wykrycie i poprawienie problemów z projektem aplikacji. Podczas uruchamiania formularzy i raportów Access często zgłasza błędy w przypadku znalezienia czegoś, co w oczywisty sposób jest nieprawidłowe. Znacznie trudniejsze dla Accessa jest znalezienie problemów w nieprawidłowo napisanym kodzie. Bardzo często problem w kodzie VBA występuje przez kilka miesięcy, a nawet lat, zanim użytkownik go dostrzeże. Nawet bardzo źle napisany kod często uruchamia się bez zgłaszania błędów i nie wykazuje oczywistych problemów. Jednak sprecyzowanie miejsca występowania błędu w kodzie VBA i znalezienie sposobu na jego poprawienie może być bardzo trudne. Podczas tworzenia kodu VBA trzeba samodzielnie znaleźć sposób wykrywania i poprawiania błędów. Na szczęście jest wiele wbudowanych narzędzi edytora, które pomagają w wykonywaniu tych zadań. Nie jest tajemnicą, że testowanie i debugowanie zajmuje sporo czasu. Dobrzy programiści poświęcają około jednej trzeciej czasu na projektowanie aplikacji, kolejną jedną trzecią na pisanie kodu oraz jedną trzecią na testowanie i debugowanie. Czasami warto przekazać aplikację do testowania innym osobom. Osoba, która nie zna aplikacji, bardzo często wykonuje działania, których programista się nie spodziewa, co prowadzi do wykrycia nowych, zaskakujących błędów.
Testowanie funkcji Funkcje zwracają wartości, dzięki czemu testowanie funkcji jest łatwiejsze niż sprawdzanie procedur innego rodzaju. Dobrzy programiści piszą odrębne procedury do testowania wszystkich funkcji, aby sprawdzić, czy dane wyjściowe są zgodne z oczekiwanymi. Testowanie funkcji w trakcie jej pisania pozwala wykryć problemy w momencie, gdy najłatwiej jest je naprawić. Jeśli funkcja zawiera błąd odzwierciedlany później w formancie na formularzu, wykrycie źródła problemów może okazać się trudniejsze. Pisanie testów zmusza też do przyjrzenia się działaniu funkcji z różnych perspektyw.
Rozdział 26. Debugowanie aplikacji Accessa
793
W języku VBA w pisaniu testów pomocna jest metoda Assert obiektu Debug. Poniższa przykładowa procedura oblicza rabat na podstawie faktury. Jest kilka czynników, od których zależy, czy firma udziela rabatu. Sprawdź, czy na podstawie kodu potrafisz zidentyfikować te czynniki. Function InvoiceDiscountAmount( _ sCustomerID As String, _ cInvoiceTotal As Currency, _ dtInvoice As Date _ ) As Currency Dim cReturn As Currency Const dDISCOUNT_THRESHOLD As Double = 10000 Const dDEFAULT_DISCOUNT As Double = 0.1 cReturn = 0 If cInvoiceTotal >= dDISCOUNT_THRESHOLD Then cReturn = cInvoiceTotal * dDEFAULT_DISCOUNT ElseIf IsDiscountCustomer(sCustomerID) Then cReturn = cInvoiceTotal * dDEFAULT_DISCOUNT ElseIf IsLastDayOfMonth(dtInvoice) Then cReturn = cInvoiceTotal * dDEFAULT_DISCOUNT End If InvoiceDiscountAmount = cReturn End Function
Rabat domyślny jest udzielany w trzech sytuacjach: gdy wartość faktury przekracza określony próg, gdy klientowi przysługuje rabat lub gdy jest ostatni dzień miesiąca. Porównanie wartości faktury z progiem jest stosunkowo łatwe. Aby kod był bardziej przejrzysty i czytelny, sprawdzanie dwóch pozostałych warunków przeniesiono do odrębnych funkcji. Oto one: Private Function IsDiscountCustomer(sCustomerID As String) As Boolean Dim rsCustomer As ADODB.Recordset Dim conn As ADODB.Connection Dim sSql As String Set conn = CurrentProject.Connection sSql = "SELECT GetsDiscount FROM Customers " & _ "WHERE CustomerID = '" & sCustomerID & "'" Set rsCustomer = conn.Execute(sSql) If Not rsCustomer.EOF Then IsDiscountCustomer = rsCustomer.Fields(0).Value End If End Function Private Function IsLastDayOfMonth(dtDate As Date) As Boolean
794
Część VI Podstawy programowania w Accessie ' Zerowy dzień następnego miesiąca to ' ostatni dzień bieżącego IsLastDayOfMonth = (dtDate = DateSerial(Year(dtDate), Month(dtDate), 0)) End Function
Po utworzeniu funkcji można napisać procedurę testową, aby sprawdzić, czy działa w oczekiwany sposób. Znane są trzy warunki, które powinny prowadzić do udzielenia rabatu. W testach można sprawdzić kombinacje poszczególnych warunków. Metoda Debug.Assert wstrzymuje działanie kodu, gdy test kończy się niepowodzeniem. W ramach demonstracji w funkcji IsLastDayOfMonth popełniono błąd (zostanie on wkrótce poprawiony). Rysunek 26.1 przedstawia procedurę testową po uruchomieniu. Rysunek 26.1. Metoda Debug.Assert wstrzymuje pracę kodu, gdy test kończy się niepowodzeniem
W celu przetestowania funkcji utworzono trzy tablice z informacjami przekazywanymi do funkcji. Tablica vaCustomer zawiera dane dwóch klientów. Jeden z nich powinien otrzymać zniżkę, a drugi — nie. Klientów tych wybrano z tabeli Customers. W tablicy vaTotal znajdują się kwoty z faktur. Jedna z nich upoważnia do zniżki, natomiast druga — nie. Pierwsza wartość jest równa poziomowi progowemu (powinna prowadzić do udzielenia rabatu), druga jest o złotówkę mniejsza (dla niej test powinien zakończyć się niepowodzeniem). Wartości bezpośrednio zbliżone do wartości progowej to przypadki brzegowe. W ostatniej tablicy zapisano jedną datę prowadzącą do udzielenia rabatu (jest to data ostatniego dnia miesiąca) i drugą, która nie powinna powodować obniżki ceny.
Rozdział 26. Debugowanie aplikacji Accessa
795
W procedurze znajdują się trzy pętle zagnieżdżone, co pozwala przekazać do funkcji wszystkich osiem kombinacji danych. Rabat nie powinien zostać przyznany tylko wtedy, gdy z każdej tablicy przekazywany jest drugi element (ANATR, 9999 i #2/1/2012#). Instrukcja If sprawdza, czy w każdej pętli wybierany jest ostatni element tablicy. W takiej sytuacji funkcja Debug.Assert sprawdza, czy wartość rabatu to zero. Gdy w choć jednej pętli wybrano pierwszy element tablicy, w funkcji Debug.Assert należy sprawdzić, czy obniżka wynosi 10% wartości faktury. Procedura testowa po uruchomieniu zatrzymała się w wierszu z instrukcją Debug.Assert. Po sprawdzeniu wartości zmiennych i, j i k okazało się, że dla kombinacji danych "ANATR", 9999 i #1/31/2012# rabat wyniósł zero, choć zgodnie z testem powinien równać się 999.9. Wiadomo, że w funkcji znajduje się błąd. Teraz wystarczy go znaleźć. Po dokładnym przyjrzeniu się funkcji IsLastDayOfMonth widać, że powinna wyglądać następująco: IsLastDayOfMonth = (dtDate = DateSerial(Year(dtDate), Month(dtDate) + 1, 0))
Wcześniej zapomniano o członie +1, który powoduje przejście do następnego miesiąca. Po poprawieniu błędu i ponownym uruchomieniu funkcji TEST_InvoiceDiscountAmount okazuje się, że kod działa bez problemów. Instrukcja Debug.Assert wstrzymuje wykonywanie kodu tylko wtedy, gdy test kończy się niepowodzeniem. Jeśli kod działa poprawnie, nic się nie dzieje. W końcowej części testów można umieścić instrukcję MsgBox lub Debug.Print, aby wyświetlać wizualne powiadomienie o zakończeniu pracy procedury testowej. Pisanie testu zajęło tu prawie tyle samo czasu co utworzenie trzech funkcji. Jednak niewykryty błąd może prowadzić do poważnych problemów w formularzach korzystających z przedstawionych funkcji. Z powodu błędnej procedury program może nie naliczać rabatów tam, gdzie są one należne. Użytkownik aplikacji może nie zauważyć takiego błędu, przez co klient będzie niezadowolony. Inną zaletą testowania funkcji w przedstawiony tu sposób jest to, że po wprowadzeniu zmian w funkcji można ją przetestować za pomocą tej samej procedury testowej. Jeśli testy kończą się powodzeniem, oznacza to, że modyfikacje nie doprowadziły do naruszenia reguł biznesowych aplikacji.
Kompilowanie kodu VBA Po utworzeniu procedury lub funkcji należy ją skompilować, aby sprawdzić, czy składnia w całości jest poprawna. Aby to zrobić, należy w edytorze VBA wybrać z menu Debug polecenie Compile (gdzie jest nazwą projektu ustawioną za pomocą okna dialogowego Tools/ Properties…). Na rysunku 26.2 pokazano otwarte w edytorze menu Debug. Kompilator sprawdza, czy program nie zawiera błędów, a także przekształca go na postać zrozumiałą dla komputera. Jeśli kompilacja się nie powiedzie, na ekranie wyświetli się okno z informacją o błędzie kompilacji. Przykład takiego komunikatu przedstawiono na rysunku 26.3.
796
Część VI Podstawy programowania w Accessie
Rysunek 26.2. Menu Debug w edytorze kodu VBA obejmuje przydatne narzędzia diagnostyczne
Rysunek 26.3. Błąd kompilacji
Podczas kompilacji kod jest sprawdzany bardziej szczegółowo niż robi to mechanizm sprawdzania składni analizujący pojedyncze wiersze. Kompilator sprawdza prawidłowość wywołań zmiennych oraz użycie właściwego typu danych. Każda instrukcja jest testowana pod względem poprawności wykorzystanych parametrów. Kompilator sprawdza, czy we wszystkich łańcuchach tekstowych zastosowano odpowiednie ograniczniki (np. cudzysłowy). Na rysunku 26.3 pokazano typowy błąd kompilacji. W tym przypadku w nazwie metody (GetOption) jest błąd i kompilator nie potrafi się do niej prawidłowo odwołać. Access kompiluje wszystkie nieskompilowane procedury, a nie tylko tę wyświetlaną w oknie edytora. Jeśli podczas kompilacji wystąpi błąd, należy natychmiast poprawić odpowiedni fragment kodu. Następnie trzeba raz jeszcze skompilować procedurę. Jeśli w kodzie znajdują się inne błędy, wyświetlą się kolejne komunikaty o błędach. Niestety, kompilator języka VBA zgłasza błędy kompilacji pojedynczo. Większość innych kompilatorów (np. kompilatory pakietu Visual Studio .NET) wyświetlają wszystkie błędy znalezione podczas kompilacji.
Rozdział 26. Debugowanie aplikacji Accessa
797
Po udanej kompilacji aplikacji polecenie Debug/Compile jest zablokowane. Przed udostępnieniem aplikacji użytkownikom warto się upewnić, że jest ona całkowicie skompilowana.
Baza danych ma standardową windowsową nazwę, np. Rozdział26.accdb. Istnieje jednak osobna, wewnętrzna nazwa projektu Accessa przeznaczona do wywoływania kodu VBA w aplikacji. Tę nazwę zobaczysz w trakcie kompilacji bazy danych. W trakcie tworzenia pliku bazy danych nazwa projektu i nazwa bazy danych są identyczne. Nazwa projektu nie zmienia się wraz ze zmianą nazwy pliku .accdb w systemie Windows. Aby zmienić nazwę projektu, należy skorzystać z polecenia Properties znajdującego się w menu Tools ( jest nazwą bieżącego projektu). Kompilacja bazy danych daje pewność, że aplikacja nie zawiera błędów składniowych. Kompilator najpierw rozpoznaje polecenie VBA, a następnie sprawdza liczbę przekazanych parametrów i wykorzystanych opcji oraz ich kolejność. Kompilator języka VBA nie ma możliwości wykrywania błędów logicznych w kodzie i oczywiście nie potrafi wykryć błędów wykonania. Po kompilacji programu należy skompaktować bazę danych. Za każdym razem, gdy wprowadzasz zmiany w programie, Access zachowuje oryginał (kod sprzed modyfikacji) i bieżący kod, co powoduje szybkie zwiększanie pliku bazy danych. Po kompilacji programu plik bazy danych może podwoić objętość, bo Access zapisuje skompilowaną i nieskompilowaną wersję programu. Po skompaktowaniu bazy danych objętość pliku zmniejsza się nawet o 80 – 90 procent, gdyż usuwane są wszystkie poprzednie wersje kodu.
Tradycyjne techniki debugowania Są dwie powszechnie używane techniki debugowania dostępne począwszy od Accessa w wersji 1.0. Pierwsza polega na wstawianiu instrukcji MsgBox w celu wyświetlenia wartości zmiennych, procedur itp. Druga powszechnie wykorzystywana technika polega na wstawianiu instrukcji Debug.Print w celu wyświetlania komunikatów w oknie Immediate.
Używanie instrukcji MsgBox Na rysunku 26.4 pokazano przykładowe okno komunikatu z długą instrukcją SQL-a, dzięki czemu programista może sprawdzić, czy aplikacja prawidłowo utworzyła instrukcję. Kod generujący okno z rysunku 26.4 znajdziesz w module basUsingMsgBox w przykładowej bazie danych Rozdział26.accdb. Rysunek 26.4. Instrukcja MsgBox jest dobrym narzędziem diagnostycznym (z pewnymi ograniczeniami)
798
Część VI Podstawy programowania w Accessie
Zalety stosowania instrukcji MsgBox są oczywiste.
Instrukcja MsgBox jest prosta i łatwa do wykorzystania i używania oraz zajmuje zaledwie jeden wiersz kodu.
Instrukcję MsgBox można wykorzystać do wyświetlania niemal wszystkich typów danych.
Okno z komunikatem wyświetla się na tle interfejsu użytkownika. Aby zobaczyć komunikat, nie trzeba otwierać okna Immediate ani się do niego przełączać.
Instrukcja MsgBox wstrzymuje pracę kodu, a ponieważ wiadomo, gdzie się znajduje, można precyzyjnie stwierdzić, który fragment kodu jest wykonywany.
Są również pewne problemy związane z instrukcją MsgBox.
W przypadku instrukcji MsgBox nie ma sposobu, aby zablokować wyświetlanie okna z komunikatami podczas używania aplikacji, co może wprowadzić użytkowników w błąd, a także spowodować inne problemy. Nigdy nie należy zapominać o usunięciu wszystkich instrukcji MsgBox z kodu przed dystrybucją aplikacji do jej docelowych użytkowników. Przeszukaj kod pod kątem instrukcji MsgBox i Debug.Print, aby się upewnić, czy usunąłeś wszystkie polecenia związane z debugowaniem.
Okna komunikatów są modalne, co oznacza, że nie można przełączyć się do edytora kodu bądź okna Immediate (opisanego w podpunkcie „Uruchamianie kodu w oknie Immediate” w dalszej części rozdziału) w celu sprawdzenia wartości zmiennych bądź przeanalizowania kodu aplikacji. Używanie instrukcji MsgBox to opcja wszystko albo nic (z jednym wyjątkiem, opisanym w ramce „Dyrektywy kompilatora”).
Trudno jest pobrać tekst z okna komunikatu. Nie można skopiować takiego tekstu ani pobrać jego fragmentów. Jedyna możliwość oprócz przeczytania tekstu z okna komunikatu to zrobienie zrzutu ekranu.
Korzystanie z instrukcji Debug.Print Druga, powszechnie wykorzystywana technika polega na wstawianiu instrukcji Debug. Print w celu wyświetlania komunikatów w oknie Immediate (Print jest metodą obiektu Debug). Na rysunku 26.5 pokazano sposób wyświetlania zmiennej sSQL w oknie Immediate. Inaczej niż w przypadku instrukcji MsgBox nie trzeba robić niczego specjalnego, aby wyłączyć efekt działania instrukcji Debug.Print z interfejsu użytkownika. Wynik instrukcji Debug.Print jest kierowany tylko do okna Immediate, a ponieważ użytkownicy aplikacji nigdy go nie widzą, nie trzeba się martwić tym, że użytkownikom będą przeszkadzały komunikaty diagnostyczne. Problemy z instrukcją Debug.Print dokładnie widać na rysunku 26.5. Długie instrukcje w oknie Immediate nie zawijają się. Poza tym, aby zobaczyć komunikaty diagnostyczne, trzeba wyświetlić okno Immediate. Ograniczenia te są jednak stosunkowo nieszkodliwe, w związku z czym instrukcję Debug.Print często wykorzystuje się w aplikacjach.
Rozdział 26. Debugowanie aplikacji Accessa
799
Rysunek 26.5. Wykorzystanie instrukcji Debug.Print do wyświetlania komunikatów w oknie Immediate
Dyrektywy kompilatora Ulepszeniem techniki polegającej na wykorzystaniu instrukcji MsgBox jest użycie dyrektyw kompilatora w celu wyłączenia instrukcji MsgBox, jeśli nie zdefiniowano specjalnego typu stałej w kodzie lub środowisku Accessa. Przeanalizuj kod pokazany na poniższym rysunku. Zwróć uwagę na dyrektywę kompilatora #Const nad instrukcją MsgBox oraz na dyrektywy #If i #End If otaczające instrukcję MsgBox.
Wszystkie słowa kluczowe rozpoczynające się od znaku krzyżyka (#) są widoczne tylko dla kompilatora VBA. Te słowa kluczowe (#Const, #If, #Else oraz #End If) są dyrektywami dla kompilatora VBA polecającymi włączenie (lub wyłączenie) niektórych instrukcji ze skompilowanej wersji projektu. Kompilacja [t1]warunkowa na podstawie dyrektyw kompilatora została przedstawiona w rozdziale 23.
800
Część VI Podstawy programowania w Accessie
Dyrektywę #Const widoczną na wcześniejszym rysunku można zastosować w dowolnym miejscu modułu, o ile umieści się ją nad dyrektywą #If. Logicznym miejscem dla dyrektywy #Const jest sekcja deklaracji modułu, ponieważ stałe #Const są globalne dla modułu. Na rysunku stałą kompilatora ustawiono na False. Oznacza to, że instrukcje umieszczone pomiędzy dyrektywami #If i #End If nie będą wkompilowane do projektu VBA aplikacji. W tym przypadku instrukcja MsgBox nie zostanie skompilowana i nie znajdzie się w interfejsie użytkownika. Ustawienie dyrektywy #Const na wartość True powoduje włączenie instrukcji MsgBox. Oczywiście dyrektywy kompilatora można wykorzystać dla innych instrukcji niż MsgBox. Można na przykład skorzystać z dyrektyw kompilatora w celu warunkowej kompilacji funkcji, zdefiniowania dodatkowej pomocy lub innych cech aplikacji. Dyrektywy kompilatora są szczególnie skuteczne do wyłączania instrukcji MsgBox używanych do debugowania. Przed przekazaniem aplikacji użytkownikom należy je zdezaktywować. Ponowne włączanie instrukcji MsgBox jest proste — wystarczy ustawić instrukcję #Const na wartość True. Prawdopodobnie największą przeszkodą w używaniu stałych kompilatora jest fakt, iż instrukcja #Const ma zasięg poziomu modułu. Stała kompilatora zadeklarowana w jednym module nie jest widziana przez inne moduły w aplikacji. Oznacza to, że trzeba dodać te same stałe kompilatora do wszystkich modułów, w których chcemy skorzystać z warunkowej kompilacji. W Accessie jest opcja Conditional Compilation Arguments w zakładce General okna dialogowego właściwości aplikacji (Tools/ Properties), która pozwala na obejście tego ograniczenia. Jak pokazano na poniższym rysunku, w sekcji Conditional Compilation Arguments można zdefiniować dowolną liczbę stałych kompilatora obowiązujących w całej aplikacji. Dzięki tym ustawieniom można z łatwością włączać warunkową kompilację z dowolnej lokalizacji w aplikacji, zamiast modyfikować instrukcję #Const w każdym module.
Opcja Conditional Compilation Arguments oraz inne ustawienia definiowane w oknie dialogowym właściwości projektu obowiązują tylko w bieżącej aplikacji. W odróżnieniu od opcji ustawianych w oknie dialogowym Tools/Options, ustawienia właściwości projektu nie są współdzielone przez wiele aplikacji Accessa.
Rozdział 26. Debugowanie aplikacji Accessa
801
Zwróć uwagę, że na wcześniejszym rysunku wszystkie wartości przypisane w polu Conditional Compilation Arguments są liczbami. Ustawienie argumentu na zero w polu Conditional Compilation Argument powoduje ustawienie logicznej wartości argumentu na False. Wszystkie wartości niezerowe są interpretowane jako True. W polu Conditional Compilation Arguments ustawianym w oknie dialogowym właściwości projektu nie można używać słów True i False. Wartość 0 (False) oznacza, że w kodzie można pozostawić wszystkie dyrektywy kompilacji warunkowej. Wartość ta powoduje wyłączenie dyrektyw, dzięki czemu kod może działać tak, jakby nie istniały. Terminologia stosowana dla mechanizmu warunkowej kompilacji języka VBA jest niespójna, co niektórych może wprowadzać w błąd. W module kodu języka VBA stałe kompilacji warunkowej przypisuje się za pomocą słowa kluczowego #Const, natomiast w oknie dialogowym właściwości projektu robi się to za pomocą opcji Conditional Compilation Arguments. Poza tym w module VBA stałym warunkowej kompilacji przypisuje się wartości True i False, natomiast aby przypisać te wartości w polu Conditional Compilation Arguments, należy użyć wartości –1 i 0. Jest to jedno z miejsc, w których do zdefiniowania elementów o tym samym przeznaczeniu stosuje się różną składnię w zależności od miejsca w projekcie VBA Accessa. Do stałych kompilatora można przypisywać dowolne nazwy. Tu dla wygody podano nazwę gDEBUG1, jednak równie dobrze może to być MojaZmiennaKompilatora, Beatka, HoHoHo lub dowolna inna poprawna nazwa stałej. Niektórzy narzekają, że zbyt duża liczba instrukcji Debug.Print może spowodować spowolnienie aplikacji. Chociaż okno Immediate nie jest widoczne, Access wykonuje wszystkie instrukcje Debug.Print występujące w kodzie. Aby usunąć instrukcje Debug.Print z wersji aplikacji przekazywanej do użytkowników, można otoczyć wywołania instrukcji Debug.Print dyrektywami kompilatora opisanymi w ramce „Dyrektywy kompilatora” lub usunąć takie instrukcji z wersji udostępnianej użytkownikom.
Korzystanie z mechanizmów debugowania Accessa Access zawiera rozbudowane narzędzia debugowania i inne mechanizmy. Za pomocą tych narzędzi można śledzić wykonywanie kodu VBA, wstrzymywać pracę kodu na danej instrukcji, aby sprawdzić wartości zmiennych w określonym momencie, a także wykonywać inne zadania diagnostyczne.
Uruchamianie kodu w oknie Immediate Aby otworzyć okno Immediate (nazywane też oknem Debug), należy wybrać polecenie View/Immediate lub wcisnąć kombinację Ctrl+G. Okno Immediate można otworzyć w dowolnym momencie działania aplikacji (np. można je otworzyć z poziomu okna projektu formularza). Czasami podczas pracy z formularzem lub raportem trzeba przetestować kilka wierszy kodu lub uruchomić procedurę (obie te czynności można wykonać z poziomu okna Immediate). Okno Immediate pokazano na rysunku 26.6. Zapewnia ono interakcję z kodem oraz wyświetla wyniki działania instrukcji Debug.Print. Do podstawowych zadań z zakresu debugowania należy zatrzymanie wykonywania aplikacji w taki sposób, aby można było przeanalizować kod i wartości zmiennych, dynamiczne śledzenie wartości zmiennych oraz uruchamianie aplikacji krok po kroku.
802
Część VI Podstawy programowania w Accessie
Rysunek 26.6. Dobrze poznaj okno Immediate. W Accessie korzysta się z niego bardzo często
Jednym z podstawowych zastosowań okna Immediate jest uruchamianie kodu, np. funkcji lub procedur wbudowanych albo funkcji i procedur definiowanych samodzielnie. Kilka przykładów kodu uruchamianego w oknie Immediate pokazano na rysunku 26.7. Rysunek 26.7. Uruchamianie kodu z poziomu okna Immediate to często wykonywana operacja
W pierwszym przykładzie z rysunku 26.7 pokazano technikę używaną do uruchamiania funkcji (tu jest to UsingDebugDotPrint) dodanych do projektu VBA. Jeśli funkcja jest zadeklarowana z wykorzystaniem słowa kluczowego Public i podano wszystkie wymagane parametry, wyświetlany jest wynik wykonania funkcji (tu jest nim długa instrukcja SQL-a). Ta funkcja zawiera instrukcję Debug.Print, a zwracane przez nią dane pojawiają się bezpośrednio pod wierszem z wywołaniem funkcji. W oknie Immediate uruchomiono też funkcję Now() zwracającą bieżącą datę i godzinę. Znak zapytania (?) przed nazwą funkcji Now() to skrótowy zapis odpowiadający słowu kluczowemu Print. Zamiast instrukcji ?Now można wpisać Print Now. Zarówno znak zapytania, jak i słowo kluczowe Print to dyrektywy dla okna Immediate nakazujące wyświetlenie wartości zwracanej przez funkcję Now(). W trzecim przykładzie z rysunku 26.7 pokazano uruchomienie procedury NazwaProcedura z poziomu okna Immediate. Ponieważ procedury nie zwracają wartości, nie użyto znaku zapytania. Procedura NazwaProcedury nie zawiera instrukcji Debug.Print, dlatego w oknie Immediate nie pojawiają się żadne dodatkowe informacje.
Wstrzymywanie wykonywania kodu z wykorzystaniem pułapek Aby wstrzymać wywołanie kodu, należy ustawić w nim pułapkę (ang. breakpoint). Kiedy Access napotka pułapkę, natychmiast zatrzymuje wykonywanie aplikacji, co umożliwia przełączenie się do okna Immediate w celu przeanalizowania lub ustawienia wartości zmiennych.
Rozdział 26. Debugowanie aplikacji Accessa
803
Ustawianie pułapek jest łatwe. Należy otworzyć okno kodu i kliknąć szary pasek wskaźnika marginesu z lewej strony instrukcji, na której aplikacja ma się zatrzymać (zobacz rysunek 26.8). Można również ustawić kursor w wierszu i kliknąć przycisk Breakpoint. Pułapka jest oznaczana za pomocą dużej brązowej kropki na szarym pasku po lewej stronie okna kodu oraz podświetlenia wiersza kodu na brązowo. Tekst instrukcji, w której ustawiono pułapkę, wyświetla się pogrubioną czcionką. Rysunek 26.8. Ustawianie pułapek jest proste
Wszystkie kolory i atrybuty czcionki można zmienić w zakładce Editor Format okna dialogowego Options.
Aby usunąć pułapkę, wystarczy kliknąć wskaźnik pułapki na pasku marginesu. Pułapki są usuwane automatycznie w momencie zamknięcia aplikacji. Kiedy sterowanie dotrze do pułapki, Access zatrzymuje wykonywanie programu i otwiera okno kodu na pułapce (zobacz rysunek 26.9). W tym momencie można skorzystać z okna Immediate (zobacz wcześniejszy punkt) w celu sprawdzenia wartości zmiennych i wykonania innych operacji lub użycia innych narzędzi debugowania opisanych w podrozdziale „Korzystanie z mechanizmów debugowania Accessa”. Ani okno kodu, ani Immediate nie są modalne, zatem podczas korzystania z nich zachowujesz dostęp do środowiska programisty. Rysunek 26.9. Aplikacja zatrzymuje się na pułapce
804
Część VI Podstawy programowania w Accessie
Na rysunku 26.10 zaprezentowano dwie techniki przeglądania wartości zmiennych po zatrzymaniu działania aplikacji na pułapce. Okno Locals zawiera nazwy i bieżące wartości wszystkich zmiennych w bieżącej procedurze. Aby otworzyć to okno, wybierz opcję View/Locals Window. Jeśli chcesz obejrzeć wartości zmiennych w nieco innym formacie, możesz skorzystać z polecenia wyświetlania (?) i wyświetlić wartości zmiennych w oknie Immediate.
Rysunek 26.10. Zmienne znajdujące się w zasięgu w trybie przerwania
Najbardziej podstawową operacją po zatrzymaniu się aplikacji na pułapce jest uruchamianie aplikacji krok po kroku, po jednej instrukcji, i obserwowanie zachowania aplikacji i jej zmiennych. Po osiągnięciu pułapki można skorzystać z kilku kombinacji klawiszy do sterowania działaniem aplikacji. Można uruchamiać kod krok po kroku, automatycznie wykonywać kod wewnątrz procedur lokalnych lub wykonać całą procedurę i kontynuować działania po „drugiej stronie” jej wywołania. Na rysunku 26.11 ustawiono pułapkę w początkowej części funkcji UsingBreakpoints(). Kiedy sterowanie dojdzie do tego punktu, zatrzymuje się, pozwalając programiście na przejęcie kontroli nad działaniem programu. Na rysunku 26.12, aplikacja zatrzymała swoje działanie, a programista kliknął przycisk Step Into (lub wcisnął klawisz F8). Instrukcja Step Into powoduje wykonanie kolejnej instrukcji programu. Tu ustawiana jest zmienna db, a bieżącym wierszem staje się przypisanie wartości do zmiennej sSQL (wiersz ten jest wyróżniony żółtym kolorem i strzałką na lewym marginesie). Na tym etapie instrukcja przypisująca wartość do zmiennej sSQL nie została jeszcze wykonana, dlatego zmienna ta to pusty łańcuch znaków. Aby wykonać tę instrukcję i przejść do następnego wiersza, wciśnij klawisz F8. Po ustawieniu wartości
Rozdział 26. Debugowanie aplikacji Accessa
805
Stosowanie instrukcji Stop zamiast pułapek Alternatywą ustawiania pułapek jest użycie instrukcji Stop. Instrukcja Stop wstrzymuje działanie aplikacji, ale jest bardziej trwała od pułapek. Instrukcja Stop, podobnie jak inne instrukcje VBA, jest trwała i będzie ustawiona w kolejnej sesji do czasu jej jawnego usunięcia. Można jednak otoczyć instrukcję Stop dyrektywami warunkowej kompilacji i włączyć (lub wyłączyć) ją poprzez ustawienie odpowiedniej stałej. Użycie instrukcji Stop pokazano na poniższym rysunku. Posługiwanie się instrukcjami Stop jest jednak niebezpieczne. Są to instrukcje wykonywalne, dlatego jeśli programista nie będzie ich starannie kontrolował za pomocą dyrektyw kompilatora, nie usunie ich lub nie umieści w komentarzach, mogą dosłownie zastopować działanie aplikacji, gdy użytkownik z niej korzysta. W większości sytuacji lepiej jest stosować zwykłe pułapki zamiast instrukcji Stop.
Rysunek 26.11. Pułapki ustaw w pobliżu instrukcji, które chcesz obserwować
zmiennej sSQL można wyświetlić ją w oknie Immediate. W tym celu można przełączyć się do tego okna i skorzystać z instrukcji ?sSQL. Można również obserwować zmienną sSQL w oknie Locals (sposób ten opisano w punkcie „Podgląd zmiennych w oknie Locals” w dalszej części tego rozdziału).
806
Część VI Podstawy programowania w Accessie
Rysunek 26.12. Opcja Step Into powoduje wykonywanie kodu krok po kroku
Klikanie przycisku Step Into (lub wciskanie klawisza F8) powoduje wykonywanie kodu krok po kroku. Jeśli instrukcja zawiera wywołanie innej procedury, sterowanie będzie do niej przeniesione, a kod będzie uruchamiany krok po kroku. Można też użyć przycisku Step Over (lub wcisnąć Shift+F8), aby przeskoczyć wywoływaną procedurę. Jeśli wcześniej debugowałeś wywoływaną procedurę i masz pewność, że nie zawiera błędów, nie ma powodu, aby uruchamiać jej kod krok po kroku. Kod wywoływanej procedury wykona się po kliknięciu przycisku Step Over. W tym momencie zmodyfikują się wszystkie zmienne ustawiane przez procedurę. Aby zakończyć uruchamianie kodu krok po kroku, należy kliknąć przycisk Step Out (lub wcisnąć Ctrl+F8). Spowoduje to zakończenie działania procedury. Przycisk Step Out przydaje się w sytuacji, kiedy po zainicjowaniu uruchamiania procedury krok po kroku uzyskano pewność, że nie dzieje się w niej nic interesującego. Bardzo przydatną własnością okna z kodem VBA w Accessie jest opcja Auto Data Tips w zakładce Editor okna dialogowego Options. W przypadku zaznaczenia tej opcji można przeglądać wartości dowolnych zmiennych w postaci etykietek ekranowych. W tym celu wystarczy naprowadzić kursor myszy na nazwę zmiennej w oknie kodu modułu (zobacz rysunek 26.13).
Rysunek 26.13. Opcja Auto Data Tips to doskonałe narzędzie do debugowania
Rozdział 26. Debugowanie aplikacji Accessa
807
Dane wyświetlane przez mechanizm Auto Data Tips po umieszczeniu kursora myszy nad zmienną są modyfikowane. Wartość zmienia się za każdym razem, gdy do zmiennej przypisane zostaną nowe dane. Ponieważ łatwo jest przesunąć kursor myszy nad zmienną, nie trzeba używać okna Immediate, aby wyświetlić wartości wszystkich zmiennych z kodu. Kursor można umieścić nad dowolną zmienną z procedury (nie tylko nad zmiennymi z bieżącego wiersza). Na rysunku 26.13 kursor znajduje się nad zmienną sSql w wierszu nad wierszem, w którym widoczny jest wskaźnik instrukcji. Należy pamiętać, że aby podpowiedź w postaci etykietki ekranowej widoczna na rysunku 26.13 się wyświetliła, należy zaznaczyć opcję Auto Data Tips w zakładce Editor.
Na rysunku 26.13 etykietka ekranowa zawiera zmienną, do której przypisano bardzo długi łańcuch znaków. Przedstawiona technika nie umożliwia zobaczenia całego łańcucha. Można jednak podejrzeć jego końcową część, przytrzymując klawisz Ctrl po umieszczeniu kursora nad zmienną.
Bardzo wygodną cechą pułapek jest to, że wskaźnik instrukcji (żółta strzałka na lewym marginesie) można przenosić. Za pomocą myszy można przesunąć wskaźnik do innej instrukcji z danej procedury, np. w miejsce nad bieżącym poleceniem, aby ponownie uruchomić kilka wierszy kodu. Może się zdarzyć, że wskaźnik instrukcji zostanie przeniesiony w miejsce, w którym nie można wykonać kodu (np. do instrukcji If...Then...Else lub do wnętrza pętli). Ponadto przeniesienia wskaźnika pod wykonywany kod może sprawić, że potrzebne zmienne nie będą poprawnie ustawione lub pominięty zostanie ważny fragment kodu. Jednak możliwość łatwego ponownego uruchomienia kilku wierszy jest przydatna w trakcie debugowania.
Podgląd zmiennych w oknie Locals Okno Locals (View/Locals Window) wyświetla wszystkie zmienne znajdujące się w bieżącym zasięgu. Dzięki niemu można zaoszczędzić czas potrzebny na analizę każdej zmiennej z osobna. W oknie wyświetlają się nazwy zmiennych, ich typy danych oraz bieżące wartości. Zwróć uwagę na elementy w oknie Locals na rysunku 26.14. Wiersze w oknie Locals rozpoczynające się ikoną ze znakiem plus rozwijają się i dają dostęp do dodatkowych informacji. Na przykład można ustawić pułapkę na instrukcji End Function na końcu funkcji w celu zatrzymania działania kodu i przeanalizowania wyników przypisania wartości do zmiennej rs. Rozwinięcie pozycji rs w oknie Locals powoduje wyświetlenie wszystkich właściwości obiektu rs oraz ich wartości (zobacz rysunek 26.14). Cenną cechą okna Locals jest to, że można ustawiać wartości prostych zmiennych (liczbowych, tekstowych itd.) w kolumnie Values. Wystarczy kliknąć wiersz ze zmienną i wprowadzić nową wartość. Dzięki temu można bardzo łatwo sprawdzić, jak różne kombinacje wartości zmiennych wpływają na pracę aplikacji.
808
Część VI Podstawy programowania w Accessie
Rysunek 26.14. Okno Locals umożliwia analizę wartości złożonych obiektów
Wcześniej wyjaśniono, jak dzięki przeciągnięciu myszą żółtej strzałki przejść do punktu wykonania procedury. Zmiana wartości zmiennej i przeniesienie punktu wykonania w inne miejsce pozwala sprawdzić, czy kod działa w oczekiwany sposób. Bezpośrednie manipulowanie zmiennymi jest znacznie prostsze niż stosowanie innych technik sprawdzania nietypowych i nieoczekiwanych wartości. W oknie Locals pod nazwą modułu wyświetlane są zmienne z poziomu modułu. Okno to nie zawiera zmiennych globalnych. Aby sprawdzić wartości zmiennych globalnych, należy posłużyć się oknem Immediate lub etykietkami ekranowymi.
Ustawianie czujek w oknie Watches W dużych aplikacjach i w programach z dużą liczbą zmiennych w zasięgu w oknie Locals może wyświetlać się wiele zmiennych. Okno Watches umożliwia wskazanie zmiennych, które mają być monitorowane podczas krokowego uruchamiania kodu. Wartości obserwowanych zmiennych zmieniają się dynamicznie w miarę uruchamiania kodu (aby móc oglądać zmienne, trzeba się oczywiście zatrzymać na jakiejś pułapce). Zaletą stosowania okna Watches jest to, że wyświetlane zmienne nie muszą pochodzić z lokalnej procedury. Zmienne wyświetlane w oknie Watches mogą pochodzić z dowolnej części aplikacji. Ustawienie czujki (ang. watch) jest bardziej skomplikowane od używania okna Locals lub ustawienia pułapki: 1. Wybierz opcję View/Watch Window, aby wyświetlić okno Watches.
Rozdział 26. Debugowanie aplikacji Accessa
809
2. Kliknij prawym przyciskiem myszy w dowolnym miejscu okna Watches i wybierz opcję Add Watch z menu kontekstowego. Pojawi się okno dialogowe Add Watch (zobacz rysunek 26.15). Rysunek 26.15. Okno dialogowe Add Watch zawiera kilka ciekawych opcji
3. Wpisz nazwę zmiennej lub dowolnego wyrażenia w polu tekstowym Expression. W oknie dialogowym Add Watch jest kilka ważnych opcji. Oprócz nazwy zmiennej lub wyrażenia (wyrażenie może mieć na przykład postać Len(sSQL) = 0) w oknie są opcje umożliwiające wskazanie modułu i procedury wewnątrz modułu, które mają być obserwowane. Na rysunku 26.16 pokazano okno dialogowe Add Watch skonfigurowane do obserwowania zmiennej sSQL, ale tylko w procedurze UsingBreakpoints z modułu modUsing Breakpoints. Jeśli zmienna o tej nazwie jest dostępna także w innych procedurach i modułach, nie pojawi się w tym miejscu. Rysunek 26.16. W oknie Watches wyświetlają się wszystkie szczegóły dotyczące obserwowanej zmiennej
W dolnej części okna dialogowego Add Watch są następujące opcje:
Watch Expression — wartość zmiennej będzie się dynamicznie zmieniać w oknie Watches. Aby obserwować wartość zmiennej, trzeba jawnie zdefiniować pułapkę lub użyć instrukcji Stop.
Break When Value Is True — opcja umożliwia zatrzymanie działania aplikacji, jeśli wartość obserwowanej zmiennej lub wyrażenia przyjmie wartość True. Jeśli ustawisz wyrażenie Len(sSQL) = 0, program zatrzyma się, gdy wartość zmiennej sSQL zmieni się na pusty ciąg znaków.
Break When Value Changes — ta dyrektywa powoduje, że Access wstrzymuje wykonywanie aplikacji za każdym razem, kiedy wartość zmiennej lub wyrażenia zmieni się. Z oczywistych względów ustawienie to może spowodować wstrzymywanie działania aplikacji w bardzo wielu miejscach. Ustawienie to może jednak okazać się przydatne, gdy wartość zmiennej jest nieoczekiwanie modyfikowana i trudno jest ustalić, dlaczego tak się dzieje.
810
Część VI Podstawy programowania w Accessie Należy rozsądnie korzystać z czujek. Nie ma sensu zatrzymywać działania programu zbyt często, ponieważ krokowe wykonywanie programu będzie wówczas trwało w nieskończoność. Z drugiej strony, nie wolno dopuścić do sytuacji, w której zmiana jakiejś istotnej zmiennej nie zostanie zauważona z powodu niewłaściwego ustawienia czujek.
Okno Watches w akcji zaprezentowano na rysunku 26.16. W oknie widoczna jest tu zmienna rs, którą można rozwinąć, oraz zmienna sSql z przypisanym łańcuchem znaków. Okno Watches może być niezależne lub zadokowane do dowolnej krawędzi okna edytora VBA. Jeśli nie odpowiada Ci obecna pozycja okna Watches, przeciągnij je w inne miejsce za pomocą paska tytułu. Gdy przeniesiesz okno w obszar dokowania, pojawi się szary prostokąt w miejscu, w którym według Accessa chcesz zadokować okno. Wystarczy zwolnić przycisk myszy, a okno zostanie umieszczone w nowej lokalizacji. Access zadokuje je lub pozostawi jako samodzielne okno. Gdy ponownie otworzysz okno edytora VBA, okno Watches będzie się znajdowało w ustawionym wcześniej miejscu. Jeśli nie chcesz dokować okna, kliknij prawym przyciskiem myszy w dowolnym miejscu okna Watches i usuń zaznaczenie opcji Dockable.
Czujki warunkowe Chociaż obserwacja zmiennych w oknach Locals lub Watches może być dość przyjemna, można w ten sposób stracić wiele cennego czasu w nadziei na zaobserwowanie czegoś interesującego. Znacznie bardziej efektywne jest ustawienie czujek warunkowych dla zmiennej i poinstruowanie kompilatora języka VBA, aby działanie zostało przerwane tylko wtedy, jeśli będzie spełniony określony warunek. Okno dialogowe Add Watch (zobacz rysunek 26.17) umożliwia wprowadzanie wyrażeń logicznych (true bądź false), na przykład rs.Fields("OrderID").Value=10251, w polu tekstowym w górnej części okna. Należy określić miejsca w aplikacji (procedury i moduły), w jakich ma być stosowane wyrażenie, i poinformować Access, jakie działania ma wykonać mechanizm języka VBA po obliczeniu wartości wyrażenia. Tu program ma wstrzymać pracę, gdy pętla dojdzie do rekordu, w którym pole OrderID ma wartość 10251 (czyli gdy przedstawione wcześniej wyrażenie przyjmie wartość True). Rysunek 26.17. Warunkowa czujka wstrzymuje działanie aplikacji, gdy wyrażenie rs.Fields("OrderID").Value=10251 ma wartość true
Uruchomienie procedury FillRecordset1 z modułu modSQLStatement po ustawieniu przedstawionej czujki spowoduje zatrzymanie kodu w instrukcji Loop. Można wtedy sprawdzić w oknie Locals inne wartości ze zbioru danych lub wpisać dowolne instrukcje w oknie Immediate, aby zbadać problem.
Rozdział 26. Debugowanie aplikacji Accessa
811
Czujki warunkowe ustawione za pomocą okna dialogowego Add Watch są dodawane do okna Watches. Wyrażenie czujki widoczne jest w kolumnie Expression tego okna. Są również inne sposoby korzystania z czujek warunkowych, na przykład definiowanie warunków złożonych (X=True And Y=False) oraz wymuszanie zatrzymania działania aplikacji, jeśli wartość zmieni się w stosunku do tej, którą ustawiono w polu tekstowym. Prosty przykład pokazany na rysunku 26.17 to tylko niewielki wycinek możliwości, jakie można uzyskać za pomocą czujek warunkowych. Okno Watches nie tylko wyświetla statyczne dane. W razie potrzeby można kliknąć pozycję w kolumnie Expression i zmienić obserwowane wyrażenie. Załóżmy, że ustawiłeś czujkę z wyrażeniem TotalSale > 100 w taki sposób, aby kod był wstrzymywany, gdy wyrażenie to przyjmie wartość True. Może się okazać, że działanie programu jest przerywane zbyt często. Zamiast usuwać wyrażenie czujki i zaczynać pracę od początku możesz zmodyfikować wyrażenie i zastąpić wartość 100 liczbą 200 lub dowolną inną.
Możesz ustawić dowolną liczbę czujek, jednak (podobnie jak inne narzędzia diagnostyczne) są one usuwane w momencie zamknięcia Accessa. Jeśli w trakcie korzystania z czujek warunkowych stwierdzisz, że pewne wyrażenie jest przydatne, możesz je zapisać i ponownie zastosować w przyszłości.
Używanie stosu wywołań Ostatni mechanizm diagnostyczny omawiany w tym rozdziale jest nieco trudniejszy do zrozumienia, ponieważ obejmuje wiele poziomów działania aplikacji. W licznych aplikacjach Accessa znajdują procedury, które wywołują inne procedury, a te wywołują jeszcze inne procedury. Według naszej wiedzy nie ma limitu liczby procedur, które można sekwencyjnie wywołać w projekcie VBA. Oznacza to, że w aplikacji może występować drzewo procedur o głębokości wielu poziomów, z których jeden powoduje problem w aplikacji. Najczęściej zdarza się to wtedy, gdy aplikację wielokrotnie modyfikowano lub gdy nie przemyślano dostatecznie optymalizowania wykorzystania kodu w aplikacji. Jednak nawet w starannie zaprojektowanych aplikacjach występuje czasem głęboko zagnieżdżony kod, co utrudnia zrozumienie powiązań między fragmentami programu. Wyobraź sobie funkcję, która często wykonuje w aplikacji pewną operację (np. oblicza koszty wysyłki). Generalną zasadą jest, że takiej funkcji nie umieszcza się w każdym module w aplikacji, ale raczej wstawia się ją do pojedynczego modułu i deklaruje ze słowem kluczowym Public po to, by można ją było rozpoznać i używać jej w całej aplikacji. Następnie wywołuje się ją we wszystkich procedurach, w których trzeba obliczyć koszty wysyłki. Co więcej, wyobraź sobie, że w tej aplikacji jest wiele funkcji i procedur, które wywołują inne procedury, w zależności od logiki aplikacji w wybranym momencie. Załóżmy teraz, że użytkownicy zgłaszają, iż koszty wysyłki w pewnych warunkach są obliczane prawidłowo, a w innych nie.
812
Część VI Podstawy programowania w Accessie
Można oczywiście spróbować uruchomić krok po kroku cały kod w aplikacji w nadziei na znalezienie przyczyny błędów w obliczeniach kosztów wysyłki. Nie jest to jednak wydajny sposób rozwiązania problemu. Znacznie szybciej byłoby ustawić czujkę warunkową na jakiejś istotnej zmiennej wewnątrz funkcji obliczającej koszty wysyłki i wymusić zatrzymanie aplikacji, jeśli określony warunek będzie miał wartość True. Następnie wystarczy otworzyć okno stosu wywołań (ang. Call Stack; zobacz rysunek 26.18) i obejrzeć ścieżkę, jaką kompilator VBA wykonał w celu dotarcia do tego miejsca w kodzie. Rysunek 26.18. Okno stosu wywołań pokazuje sposób dotarcia sterowania do bieżącej pozycji
Ostatni wpis w oknie stosu wywołań (Rozdział26.basCallStack1.Procedure1) informuje, że pierwszą wywołaną funkcją była Procedure1 (z modułu basCallStack1). Następny wpis (Rozdział26.basCallStack2.Procedure2) oznacza, że procedura Procedure1 wywołała procedurę Procedure2 (z modułu basCallStack2) itd. W ten sposób można stosunkowo łatwo prześledzić ścieżkę kodu VBA do punktu, w którym zatrzymano wykonywanie kodu. Dwukrotne kliknięcie dowolnej pozycji w oknie stosu wywołań powoduje przejście do instrukcji, która spowodowała wywołanie kolejnej procedury. Użycie okna stosu wywołań w połączeniu z czujkami warunkowymi umożliwia zatrzymanie kodu w dowolnym miejscu i zdiagnozowanie sposobu działania kodu do pułapki.
Przechwytywanie błędów w kodzie Nawet staranne testowanie i debugowanie kodu nie pozwala wykryć wszystkich usterek. W każdym większym projekcie znajdują się błędy, których programiści nie zdołali znaleźć w trakcie testowania i debugowania. Zadaniem programisty jest upewnić się, czy program potrafi sprawnie obsłużyć nieoczekiwane problemy.
Na czym polega przechwytywanie błędów? Gdy VBA natrafi na problem w kodzie, zgłasza błąd. Może zdarzyć się wtedy wiele rzeczy. Najważniejsze jest to, że silnik VBA szuka wtedy instrukcji On Error i tworzy obiekt Err. Słowa kluczowe On Error należy umieścić w kodzie, aby poinformować silnik VBA, co należy robić po wystąpieniu błędu. On Error Resume Next Instrukcja On Error Resume Next nakazuje silnikowi VBA ignorowanie błędów w kodzie następującym po tej instrukcji. Jest to bardzo niebezpieczna instrukcja. Jeśli ją zastosowano, a kod wymaga udanego wykonania wcześniejszych instrukcji, błędy mogą się nawarstwiać, co prowadzi do poważnych problemów. Jeżeli jednak zachowasz ostrożność przy stosowaniu tej instrukcji, może okazać się ona bardzo przydatna.
Rozdział 26. Debugowanie aplikacji Accessa
813
W VBA dostępny jest obiekt Collection, w którym można przechowywać wiele elementów. Gdy element jest dodawany do kolekcji, musi być powiązany z niepowtarzalnym kluczem. Próba dodania istniejącego już klucza powoduje błąd. Można wykorzystać tę cechę obiektu Collection i instrukcję On Error Resume Next, aby uzyskać listę niepowtarzalnych elementów. Sub IgnoringErrors() Dim colUnique As Collection Dim vaFruit As Variant Dim i As Long vaFruit = Array(“Apple”, “Pear”, “Orange”, “Apple”, “Grape”, “Pear”) Set colUnique = New Collection For i = LBound(vaFruit) To UBound(vaFruit) On Error Resume Next colUnique.Add vaFruit(i), vaFruit(i) On Error GoTo 0 Next i For i = 1 To colUnique.Count Debug.Print colUnique.Item(i) Next i End Sub
W tej procedurze używana jest tablica z powtarzającymi się elementami. Aby wyeliminować powtórzenia, można dodać każdy element do kolekcji, używając nazw elementów jako kluczy (jest to drugi element metody Add). Gdy VBA natrafi na instrukcję colUnique. Add dla elementu, który już znajduje się w kolekcji, zgłosi błąd. Polecenie On Error Resume Next nad taką instrukcją spowoduje, że silnik VBA zignoruje błąd i będzie kontynuować pracę. Powtarzający się element nie zostanie dodany, dzięki czemu w kolekcji znajdą się tylko niepowtarzalne elementy. W tej procedurze pokazano, jak w przydatny sposób zablokować zgłaszanie znanego błędu. Wiersz po wierszu generującym błąd informuje silnik VBA, że należy traktować błędy w standardowy sposób. Resetowanie mechanizmu obsługi błędów w ten sposób gwarantuje, że błędy nie zostaną przypadkowo pominięte. Warto też dodać wcięcie w instrukcjach między poleceniami On Error, aby graficznie wyróżnić blok kodu, w którym błędy mają być ignorowane. Instrukcja On Error Resume Next powoduje ignorowanie wszystkich błędów, które w normalnych warunkach spowodowałyby zatrzymanie pracy kodu. Choć ignorowanie wybranych błędów może być przydatne, technika ta nie pozwala odróżnić celowo pomijanych błędów od tych popełnionych przypadkowo. Dlatego należy starannie zdiagnozować instrukcje umieszczone w bloku On Error Resume Next.
On Error Goto 0 Instrukcja On Error Goto 0 przywraca domyślne ustawienia mechanizmu obsługi błędów. Jeśli w kodzie nie występują żadne instrukcje On Error, silnik VBA przy wykryciu każdego błędu zatrzymuje pracę programu i wyświetla komunikat. Instrukcja On Error Goto 0
814
Część VI Podstawy programowania w Accessie
powoduje przywrócenie takiego stanu. Zwykle stosuje się ją razem z instrukcją On Error Resume Next, aby przywrócić domyślny stan mechanizmu obsługi błędów po celowym włączeniu ignorowania określonego problemu. On Error Goto Etykieta Instrukcję On Error najczęściej stosuje się do przeniesienia sterowania do kodu o określonej etykiecie w procedurze. Etykiety to specjalne instrukcje pełniące funkcję zakładki w kodzie. Składają się z nazwy, po której następuje dwukropek, i nie można umieszczać przed nimi wcięcia. Gdy silnik VBA zgłasza błąd w kodzie pod instrukcją On Error Goto Etykieta, program przechodzi do wiersza pod podaną etykietą i kontynuuje działanie. Sub BranchError() Dim x As Long On Error GoTo ErrHandler x = 1 / 0 Debug.Print x ErrHandler: MsgBox "Wystąpił błąd" End Sub
W tym prostym przykładzie błąd jest wynikiem próby dzielenia przez zero. Po wystąpieniu tego błędu silnik VBA przeskakuje do wiersza pod etykietą ErrHandler:, wyświetla okno komunikatu i przechodzi do instrukcji End Sub. Instrukcja Debug.Print nie jest wtedy wykonywana. Słowo kluczowe Resume Wcześniej pokazano, jak zastosować instrukcję Resume Next razem z On Error, aby pominąć określone błędy. Instrukcję Resume można też stosować jako samodzielne polecenie. Wtedy powoduje powrót do wiersza, który spowodował błąd, i ponowne zgłoszenie błędu. Jest to przydatne, gdy programista chce dodać obsługę błędu, a przy tym zachować możliwość sprawdzenia wiersza, który spowodował problemy. Technika ta może jednak prowadzić do powstania pętli nieskończonej, w której program nieustannie zgłasza błąd i wznawia działanie. Instrukcję Resume można też zastosować razem z etykietą do przeskakiwania w inne miejsce programu. Polecenie Resume Etykieta zwykle prowadzi do kodu, który wykonuje operacje porządkujące i kończy działanie procedury. Etykieta to specjalny, zakończony dwukropkiem wiersz w kodzie VBA. Etykiety pełnią funkcję zakładek w kodzie — są miejscami, do których można przeskoczyć (np. za pomocą instrukcji Resume). Sub ErrorResumeOptions() Dim x As Long Dim lResp As Long On Error GoTo ErrHandler
Rozdział 26. Debugowanie aplikacji Accessa
815
x = 1 / 0 Debug.Print x ErrExit: Exit Sub ErrHandler: lResp = MsgBox("Czy chcesz zbadać błąd?", vbYesNo) If lResp = vbYes Then Stop Resume Else Resume ErrExit End If End Sub
Kod ten (podobnie jak we wcześniejszych przykładach) celowo powoduje błąd w wyniku próby dzielenia przez zero. Uruchamiany jest wtedy mechanizm obsługi błędów i program przeskakuje do etykiety ErrHandler:. W bloku obsługi błędów kod wyświetla pytanie o to, czy użytkownik chce zbadać błąd. Gdy użytkownik kliknie Nie w oknie komunikatu, wykonana zostanie instrukcja Resume ErrExit, a sterowanie przejdzie do etykiety ErrExit, po czym procedura uruchomi polecenie Exit Sub. Kliknięcie przycisku Tak spowoduje, że najpierw procedura wywoła instrukcję Stop. Gdyby nie ta instrukcja, polecenie Resume spowodowałoby powrót do wiersza, który wywołał błąd, a program wróciłby do bloku obsługi błędu. Instrukcja Stop pozwala programiście przejść przez kod wiersz po wierszu. Można wtedy najpierw wywołać instrukcję Resume, aby stwierdzić, który wiersz spowodował błąd, a następnie zbadać zmienne w celu zdiagnozowania problemu.
Obiekt Err Silnik VBA — oprócz zgłaszania błędu i przeskakiwania do innych miejsc kodu na podstawie instrukcji On Error — tworzy też obiekt Err, który zawiera informacje na temat błędu. Obiekt ten jest dostępny zawsze, nawet gdy program nie zgłosił żadnego błędu. Gdy silnik VBA napotka błąd, to niezależnie od tego, czy istnieje blok obsługi błędów, właściwość Number obiektu Err jest ustawiana na numer błędu, który wystąpił. Jeśli program nie zgłosił żadnego błędu, wartość tej właściwości to zero. Obiekt Err ma też właściwość Description. Numer błędu może być niezrozumiały, natomiast właściwość Description zwykle pomaga zidentyfikować błąd.
Dodawanie obsługi błędów do procedur Niektóre procedury są na tyle proste, że obsługa błędów jest w nich niepotrzebna. We wszystkich pozostałych procedurach należy zastosować obsługę błędów, aby uniknąć przenoszenia użytkowników do edytora VBE w momencie wystąpienia nieoczekiwanych problemów. Dostępne techniki obsługi błędów to: umieszczanie instrukcji On Error Goto Label w początkowej części procedury, ignorowanie obsługi błędów w odpowiednich miejscach,
816
Część VI Podstawy programowania w Accessie
dodawanie etykiety prowadzącej do kodu porządkującego używane zmienne i kończącego pracę procedury oraz dodawanie etykiety prowadzącej do kodu obsługującego błędy, który wyświetla komunikat o błędzie i zarządza przepływem sterowania w programie. Oto typowa procedura z obsługą błędów: Sub ATypicalErrorHandler() Dim statements On Error GoTo ErrHandler Różne instrukcje On Error Resume Next Celowe błędy (ignorowane) On Error GoTo ErrHandler Różne instrukcje ErrExit: Kod porządkujący Exit Sub ErrHandler: MsgBox Err.Description, vbOKOnly If gbDebugMode Then Stop Resume Else Resume ErrExit End If End Sub
Procedura ta zaczyna się od instrukcji On Error Goto ErrHandler, która powoduje przejście programu do etykiety ErrHandler w momencie wystąpienia nieoczekiwanych problemów. W procedurze pokazano, jak zablokować obsługę błędów za pomocą instrukcji On Error Resume Next przechwytującej celowe błędy. Po instrukcjach z celowymi usterkami praca mechanizmu obsługi błędów jest wznawiana. Blok przed sekcją obsługi błędów wykonuje operacje porządkujące i kończy pracę procedury. Jeśli błędy nie wystąpią, blok ten zostanie uruchomiony, a procedura zakończy pracę bez wykonywania kodu obsługi błędów. Sekcja obsługi błędów wyświetla komunikat, używając właściwości Description obiektu Err. Używana jest też zmienna globalna gbDebugMode, którą programista może ustawić na True w trakcie debugowania i na False, gdy aplikacja jest udostępniana użytkownikom. Jeśli zmienna gbDebugMode ma wartość True, program po napotkaniu problemów wstrzymuje działanie i programista może przejść przez kod, aby zbadać błąd. Gdy wartość tej zmiennej to False, wykonywany jest blok ErrExit i użytkownik widzi tylko okno komunikatu.
Część VII
Zaawansowane techniki programowania w Accessie W tej części:
Rozdział 27. Dostęp do danych za pomocą kodu VBA
Rozdział 28. Zaawansowany dostęp do danych z wykorzystaniem kodu VBA
Rozdział 29. Integrowanie baz SQL Server i Access
Rozdział 30. Dostosowywanie wstążek
Rozdział 31. Dystrybucja aplikacji Accessa
W rozdziałach z tej części omówiliśmy zagadnienia ważne dla profesjonalistów zajmujących się tworzeniem baz danych. Opisaliśmy tutaj dostosowywanie wstążek Accessa, dostęp do danych zewnętrznych za pomocą kodu VBA, integrowanie Accessa z bazami danych SQL Server i dystrybucję aplikacji Accessa. Wielu programistów nigdy nie będzie potrzebowało mechanizmów opisanych w tej części. Ważne jest jednak, aby poznać możliwości oferowane przez systemy podobne do Accessa. W każdej wersji Accessa rozbudowywane są jego możliwości jako platformy programowania rozwiązań dla przedsiębiorstw. Pojawiają się też nowe funkcje przydatne w profesjonalnych aplikacjach typu klient – serwer. W części VII znajdziesz przegląd zaawansowanych funkcji Accessa. Dzięki temu nie tylko będziesz wiedzieć, że takie funkcje istnieją, ale też zobaczysz, jak wykorzystać je we własnych aplikacjach.
818
Część VII Zaawansowane techniki programowania w Accessie
Rozdział 27.
Dostęp do danych za pomocą kodu VBA W tym rozdziale:
Praca z danymi Accessa
Omówienie modelu obiektowego ADO
Przegląd obiektów DAO
Aktualizowanie tabel za pomocą kodu VBA
Dostęp do danych i zarządzanie danymi stanowią rdzeń każdej aplikacji bazodanowej. Chociaż można tworzyć dobre aplikacje z wykorzystaniem związanych formularzy, wykorzystanie kodu VBA w celu uzyskania dostępu do danych i manipulowania nimi zapewnia większą elastyczność w porównaniu z aplikacjami opartymi na związanych formularzach. Wszystko, co można zrobić za pomocą związanych formularzy i formantów, można zrobić również, wykorzystując kod VBA i technologię ADO (ang. ActiveX Data Objects) oraz DAO (ang. Data Access Objects) do pobierania danych i pracy z nimi. Język VBA oferuje pokaźny zestaw poleceń przeznaczonych do wykonywania operacji na rekordach w tabeli, wyświetlania danych w formantach znajdujących się na formularzu oraz do wykonywania innych operacji. W rozdziale tym przedstawiono kilka przykładów procedur, w których do wykonania określonych operacji na rekordach wykorzystano język SQL i technologię ADO. W bazie danych Rozdział27.accdb znajduje się wiele przykładów formularzy. Niektóre z nich można wykorzystać jako punkt wyjścia, natomiast inne można wykorzystać do porównania z formularzami zmodyfikowanymi w tym rozdziale.
Praca z danymi Pierwszą rzeczą, na jaką warto zwrócić uwagę przy omawianiu obiektów dających dostęp do danych, jest to, że modele obiektowe DAO i ADO różnią się od modelu obiektowego Accessa. DAO i ADO reprezentują obiekty zarządzane i „posiadane” przez silniki
820
Część VII Zaawansowane techniki programowania w Accessie
baz danych Accessa (ACE i Jet), które są komponentami programowymi instalowanymi wraz z pakietem Office. W przeszłości w Excelu (z dodatkiem MSQuery) i Visual Basicu (niezależnym produkcie do rozwijania aplikacji) można było korzystać z silnika Jet bezpośrednio lub poprzez technologię ODBC (ang. open database connectivity) albo Microsoft Query. Język VBA z Accessa umożliwia manipulowanie obiektami baz danych na zapleczu. Pozwala to na wykonywanie w aplikacjach wielu operacji. Access udostępnia dwa różne modele obiektowe do obsługi danych — ADO i DAO. ADO (ang. ActiveX Data Objects) to nowszy z tych dwóch modeli. Oparto go na technologii ActiveX Microsoftu, która umożliwia tworzenie niezależnych obiektów przeprowadzających złożone operacje bez interwencji ze strony hosta. W ADO obiekty ActiveX potrafią wykonywać wiele zadań związanych z dostępem do danych bez zakłócania pracy Accessa. Ponieważ obiekty ADO mają dużo możliwości, model obiektowy ADO (a tym samym i hierarchia obiektów w ADO) jest dość ubogi. Wystarczy niewielka liczba obiektów, aby wykonać niemal wszystkie zadania związane z dostępem do danych w aplikacjach Accessa. Access obsługuje też starszy model obiektowy dający dostęp do danych, a mianowicie DAO (ang. Data Access Objects). Obiekty DAO, w odróżnieniu od obiektów ADO, są proste i wykonują konkretne zadania. Tworzenie takich obiektów i zarządzanie nimi wymaga większej ilości kodu VBA. Obiekty DAO są często używane, a w przeszłości były jedynym mechanizmem dostępu do danych w Accessie. Ważne jest, aby nie mylić obiektów Accessa z obiektami DAO. W interfejsie Accessa często nie widać różnicy między obiektami Accessa a obiektami silnika bazy danych. W kodzie dostępnych jest wiele rozwiązań, które można uznać za funkcje obiektów dostępu do danych, jednak w rzeczywistości są mechanizmami Accessa (i na odwrót). W trakcie pisania kodu trzeba uwzględniać różnice między obiektami obu rodzajów. Obiekty ADO i DAO mają wiele wbudowanych właściwości i metod. Inne właściwości są dodawane przez Accessa. W wielu sytuacjach korzystanie z obiektów ADO i DAO w procedurach VBA zapewnia znacznie większe możliwości niż używanie samych formularzy i raportów powiązanych z kwerendami i tabelami. W dalszej części rozdziału przekonasz się, że wystarczy niewiele wierszy kodu ADO lub DAO, aby wykonać na danych skomplikowane operacje (np. zaktualizować lub usunąć istniejące rekordy albo dodać nowe rekordy do tabel). Zastosowanie kodu VBA sprawia, że aplikacja może reagować na wykrycie w formularzu różnych warunków, takich jak brakujące lub błędne wartości. Można też stosunkowo łatwo wykonywać doraźne kwerendy, które standardowo wymagałyby pisania skomplikowanych instrukcji o wielu parametrach. Na temat zagadnień przedstawionych w dalszej części rozdziału napisano całe obszerne książki. Tu możliwe jest tylko omówienie podstaw stosowania ADO i DAO w aplikacjach Accessa. W połączeniu z materiałem z innych rozdziałów książki zapewni to dobre wprowadzenie umożliwiające zarządzania danymi w aplikacjach Accessa za pomocą kodu VBA.
Rozdział 27. Dostęp do danych za pomocą kodu VBA
821
ADO i DAO nie są identyczne. Obie te technologie umożliwiają dodawanie i modyfikowanie danych w tabelach, tworzenie zbiorów rekordów, manipulowanie danymi z takich zbiorów i zapełnianie formularzy danymi. Jednak ADO ma istotną przewagę w zakresie pracy z zewnętrznymi źródłami danych. Wkrótce się przekonasz, że ADO wymaga dostawcy, który określa źródło danych używane przez obiekty ADO w aplikacji. Dostawcy ADO są dostosowani do konkretnych źródeł danych, takich jak bazy SQL Server lub Access. Dostawca zapewnia obiektom ADO specjalne możliwości (takie jak testowanie połączenia ze źródłem danych) zależne od powiązanego źródła danych. DAO to ogólniejsza technologia dostępu do danych, która nie jest dostosowana do konkretnych źródeł danych. ADO należy wybrać, gdy potrzebne są zaawansowane operacje dostępu do danych, DAO zaś bardzo dobrze się nadaje do standardowego wykonywania kwerend, aktualizowania danych i podobnych zadań.
Dalej omówiono poszczególne obiekty i wyjaśniono, jak każdy z nich wzbogaca możliwości dostępu do danych w ADO. Choć Access nie jest obiektowy, jest oparty na obiektach. W dalszej części rozdziału opisano modele obiektowe używane w kodzie VBA do zarządzania danymi w aplikacjach Accessa. Model obiektowy to struktura obiektów wykonujących zadania z zakresu zarządzania danymi. Dobre zrozumienie modeli ADO i DAO jest bardzo ważne w kontekście używania kodu VBA do zarządzania danymi w Accessie. Liczne obiekty opisane w tym rozdziale obejmują kolekcje składające się z zera lub większej liczby obiektów. Kolekcja to kontener przechowujący wszystkie egzemplarze obiektów danego typu. Sama kolekcja też jest obiektem. Kolekcja przypomina talię kart z bejsbolistami. Każda karta w talii różni się od pozostałych, ale wszystkie karty mają pewne charakterystyczne cechy (rozmiar, wydrukowane statystyki itd.). W Accessie obiekt zbioru danych (zarówno w ADO, jak i w DAO) obejmuje kolekcję obiektów pól. Każdy obiekt zbioru danych ma cechy wspólne z innymi obiektami tego rodzaju, a każdy obiekt pola przypomina pod pewnymi względami inne obiekty tego rodzaju. Nazwa kolekcji to prawie zawsze liczba mnoga typu obiektu przechowywanego w danej kolekcji. Tak więc kolekcja Fields obejmuje różne obiekty typu Field. Ważne jest, aby wiedzieć, kiedy pojęcie dotyczy obiektu o danej nazwie, a kiedy odpowiada ogólnej kategorii elementów bazy danych. W tej książce rozpoczynane od wielkiej litery słowo Pole oznacza obiekt, natomiast słowo „pole” (rozpoczynane małą literą) to ogólne określenie dowolnego pola tabeli. Podobnie Pola to kolekcja, a „pola” oznaczają pewną liczbę różnych pól.
Każdy obiekt ADO lub DAO ma zestaw właściwości i metod. Te właściwości i metody umożliwiają zdefiniowanie obiektu lub nakazanie obiektowi wykonania zadania. Kolekcja Properties składa się z obiektów Property. Każdy obiekt Property ma własny zestaw właściwości. Właściwości można wskazywać bezpośrednio lub za pomocą interfejsu Accessa. Ponadto użytkownik może utworzyć właściwość i dodać ją do kolekcji Properties. Zwykle właściwości wskazuje się w następujący sposób: NazwaObiektu.Nazwa Właściwości. Aby uzyskać dostęp do właściwości Name pola, należy zastosować następującą składnię: MojePole.Name
822
Część VII Zaawansowane techniki programowania w Accessie
Metody działają nieco inaczej. Metoda to operacja, którą obiekt może wykonać lub przeprowadzić na obiekcie. Obiekty dostępu do danych służą do manipulowania danymi z bazy i ich wyświetlania. Dlatego każdy obiekt musi umożliwiać wykonywanie operacji na danych. Nie można dodawać ani usuwać metod obiektów ADO i DAO. Jest to jedna z kilku cech, które sprawiają, że Access nie jest w pełni obiektowy. Metody obiektu można tylko wywoływać. Poniższy kod przenosi wskaźnik w zbiorze rekordów MojZbiorRekordow do następnego rekordu: MojZbiorRekordow.MoveNext
Każdy obiekt ADO i DAO ma zbiór powiązanych z nim metod (to samo dotyczy właściwości). Jeśli chcesz dowiedzieć się czegoś więcej na temat danego obiektu ADO lub DAO, użyj przeglądarki obiektów (zobacz rysunek 27.1). Możesz ją otworzyć z poziomu edytora kodu VBA przez wciśnięcie przycisku F2 lub za pomocą opcji View/Object browser. Przeglądarka obiektów umożliwia przyjrzenie się metodom i właściwościom każdego obiektu, a także argumentom metod. Przeglądarka obiektów jest dostępna we wszystkich aplikacjach Microsoftu współdziałających z językiem VBA. Rysunek 27.1. Przeglądarka obiektów umożliwia przyjrzenie się właściwościom i metodom obiektów
Przeglądarka obiektów jest łatwa w użyciu. Wystarczy zaznaczyć bibliotekę (np. ADODB) na liście rozwijanej w lewym górnym rogu okna, a następnie przewinąć listę obiektów w lewym panelu przeglądarki, aby znaleźć potrzebny obiekt. Gdy wybierzesz obiekt, w prawym panelu pojawią się właściwości, metody i zdarzenia (jeśli dany obiekt je udostępnia). Kliknięcie właściwości, metody lub zdarzenia powoduje wyświetlenie składni danego elementu w obszarze pod listami. Choć w przeglądarce obiektów nie pojawia się przykładowy kod, bardzo często wystarczy przyjrzeć się składni właściwości, metody lub zdarzenia, aby rozpocząć pisanie kodu VBA lub dokładnie poznać działanie obiektu.
Rozdział 27. Dostęp do danych za pomocą kodu VBA
823
Wprowadzenie do obiektów ADO Omawianie ADO warto rozpocząć od przedstawienia modelu obiektowego ADO i opisania przeznaczenia każdego obiektu. Dalej znajdziesz liczne fragmenty przykładowego kodu, w których pokazano, jak wykorzystać obiekty ADO do wykonania standardowych zadań na bazie danych. Model obiektowy ADO przedstawiono na rysunku 27.2. Jak widać, model ten jest stosunkowo prosty i obejmuje niewiele typów obiektów. Zauważ, że model obiektowy ADO nie jest hierarchiczny. Każdy obiekt jest niezależny. Obiekty nie są podrzędne względem innych obiektów modelu. Rysunek 27.2. Model obiektowy ADO
Aby zastosować obiekt ADO, trzeba wskazać bibliotekę ADO. Rysunek 27.3 przedstawia okno dialogowe References (aby je otworzyć, wybierz opcję Tools/References w edytorze kodu VBA) z zaznaczoną biblioteką ADO (Microsoft ActiveX Data Objects). W Twoim komputerze zainstalowana może być inna wersja biblioteki ADO. W oknie dialogowym References dostępnych może być kilka bibliotek ADO. Wybierz tę o najwyższym numerze, aby mieć pewność, że używasz najnowszej wersji dostępnej w Accessie. Jeśli chcesz zachować zgodność z istniejącym systemem, możesz wybrać bibliotekę o niższym numerze wersji. Rysunek 27.3. Wskazywanie biblioteki ADO
824
Część VII Zaawansowane techniki programowania w Accessie
W dalszym przykładowym kodzie zwróć uwagę na to, że wszystkie zmienne na obiekty ADO są deklarowane jako typy obiektów ADODB. Choć nie jest to konieczne, poprzedzanie nazwy typu obiektu nazwą biblioteki pozwala uniknąć niejednoznaczności. Może się ona pojawić, jeśli Access nie potrafi ustalić typu obiektu używanego w instrukcjach VBA. Na przykład zarówno ADO, jak i DAO udostępniają obiekt Recordset. Jeśli w deklaracji typu obiektu zabraknie przedrostka ADODB lub DAO, Access może błędnie przyjąć, który typ Recordset jest używany w instrukcji VBA.
Obiekt Connection w ADO Jak wskazuje nazwa, obiekt Connection (czyli połączenie) zapewnia połączenie ze źródłem danych. Dostęp do źródła danych jest niezbędny przy operacjach na danych, dlatego obiekt Connection jest potrzebny w niemal każdej sytuacji, gdy używa się ADO. Po wskazaniu biblioteki ADO można w prosty sposób utworzyć obiekt Connection (biblioteka ADO używana w kodzie VBA to ADODB): Dim adConn as ADODB.Connection Set adConn = New ADODB.Connection
Są to dwie instrukcje typowe dla programowania obiektowego w języku VBA. W pierwszej tworzona jest zmienna adConn typu ADODB.Connection. Oznacza to, że język VBA będzie traktował zmienną adConn jako obiekt typu Connection z wszystkimi właściwościami i metodami udostępnianymi przez ten typ z biblioteki ADO. Jednak w trakcie wywoływania pierwszej instrukcji adConn jest tylko miejscem na obiekt i nie istnieje jeszcze w pamięci. Druga instrukcja tworzy obiekt w zmiennej adConn. VBA generuje wtedy obiekt typu Connection w pamięci komputera, wiąże zmienną adConn z obiektem w pamięci i przygotowuje go do użycia. Obiekt typu Connection przed użyciem trzeba otworzyć. Poniżej pokazano najprostszy sposób otwierania obiektu typu Connection w ADO: adConn.Open CurrentProject.Connection
Obiekt typu Connection nawiązuje tu połączenie z używaną obecnie bazą danych. Jak się wkrótce przekonasz, poprawne otwarcie obiektu typu Connection wymaga ustawienia wielu właściwości, jeśli jednak otwiera się go przy użyciu właściwości Connection bieżącej bazy danych, wszystkie potrzebne opcje są już ustawione. CurrentProject. Connection to długi ciąg znaków (ciąg połączenia), który obejmuje wszystkie niezbędne informacje na temat używanej bazy danych. Poniżej znajdziesz typowe ustawienia właściwości obiektu typu Connection: Provider=Microsoft.ACE.OLEDB.12.0;User ID=Admin; Data Source=C:\Access2013\Rozdział27\Rozdział27.accdb; Mode=Share Deny None;Extended Properties=""; Jet OLEDB:System database=C:\...\Access\System.mdw; Jet OLEDB:Registry Path=...\Access Connectivity Engine; Jet OLEDB:Database Password=""; Jet OLEDB:Engine Type=6; Jet OLEDB:Database Locking Mode=1;
Rozdział 27. Dostęp do danych za pomocą kodu VBA Jet Jet Jet Jet Jet Jet Jet Jet Jet
825
OLEDB:Global Partial Bulk Ops=2; OLEDB:Global Bulk Transactions=1; OLEDB:New Database Password=""; OLEDB:Create System Database=False; OLEDB:Encrypt Database=False; OLEDB:Don’t Copy Locale on Compact=False; OLEDB:Compact Without Replica Repair=False; OLEDB:SFP=False; OLEDB:Support Complex Data=True
Z uwagi na czytelność dodano znaki podziału wiersza i skrócono niektóre instrukcje.
Liczne z tych informacji nie są niezbędne w obiektach typu Connection, jednak Microsoft chciał mieć pewność, że niczego nie brakuje. Zwróć uwagę na człon Data Source we właściwości ConnectionString. Podano tu konkretny plik .accdb. Ścieżkę można zmienić, co oznacza, że za pomocą obiektu typu Connection można otworzyć niemal dowolną bazę danych Accessa, jeśli ścieżka jest poprawna i kończy się plikiem .accdb. Poniższa procedura otwiera obiekt typu Connection dla używanej bazy danych, wyświetla wartość właściwości Provider tego obiektu, a następnie zamyka i usuwa obiekt. Public Sub OpenConnection() Dim adConn As ADODB.Connection Set adConn = New ADODB.Connection cnn.Open CurrentProject.Connection ' Połączenie jest otwarte Debug.Print adConn.Provider adConn.Close Set adConn = Nothing End Sub
W trakcie pracy z ADO bardzo ważne jest, aby po zakończeniu korzystania z obiektu zamknąć go (jeśli udostępnia on metodę Close) i ustawić na wartość Nothing. Obiekty ADO zwykle pozostają w pamięci po otwarciu, dlatego trzeba je bezpośrednio zamknąć i usunąć (ustawić na Nothing), aby zwolnić pamięć. Jeśli obiekt ADO nie zostanie poprawnie zamknięty, może pozostać w pamięci i przysporzyć użytkownikowi problemów. Obiekt Connection wymaga dostawcy i źródła danych. Dostawca ADO (sterownik) jest dołączany do obiektu typu Connection. Istnieją na przykład dostawcy dla baz danych SQL Server — jeden dla silnika Jet i drugi dla silnika ACE. Każdy dostawca wie, jak łączyć się z danymi określonego rodzaju, i zapewnia obiektowi typu Connection mechanizmy dostosowane do konkretnego źródła danych.
826
Część VII Zaawansowane techniki programowania w Accessie
Wadą obiektów typu Connection, która przysparza programistom Accessa wielu problemów, jest składnia właściwości ConnectionString tych obiektów. Właściwość ta musi być odpowiednio skonstruowana i trzeba w niej podać dostawcę zainstalowanego w lokalnym komputerze. Istnieje pewna sztuczka pozwalająca ustalić właściwość ConnectionString dla dostawcy ADO. Najpierw utwórz pusty plik tekstowy i zmień jego rozszerzenie z .txt na .udl (ang. universal data link). Następnie kliknij dwukrotnie ów pusty plik, a system Windows otworzy okno dialogowe Właściwości łącza danych (zobacz rysunek 27.4). Za pomocą tego okna dialogowego możesz wybrać dostawcę (zakładka Dostawca) i źródło danych (zakładka Połączenie). Następnie możesz zamknąć okno.
Rysunek 27.4. Konfigurowanie ciągu połączenia za pomocą okna dialogowego Właściwości łącza danych
W ostatnim kroku otwórz plik .udl w Notatniku i skopiuj ciąg połączenia. Wklej go w programie VBA. Ciąg połączenia z poniższej procedury został wygenerowany właśnie w ten sposób. Public Sub OpenConnection() Dim adConn As ADODB.Connection Dim sConn As String Set adConn = New ADODB.Connection ' Podaj ścieżkę do pliku Rozdział27.accdb na swoim komputerze (może być ona ' inna od podanej poniżej): sConn = "Provider=Microsoft.ACE.OLEDB.12.0;" & _ "Data Source=C:\Access2013\Rozdział27\Rozdział27.accdb;" & _ & "Persist Security Info=False"
Rozdział 27. Dostęp do danych za pomocą kodu VBA
827
adConn.ConnectionString = sConn adConn.Open CurrentProject.Connection ' Połączenie jest otwarte Debug.Print adConn.Provider adConn.Close Set adConn = Nothing End Sub
Ta sztuczka działa, ponieważ system Windows traktuje plik .udl jak kontener na ciąg połączenia ADO. Dwukrotne kliknięcie tego pliku powoduje otwarcie okna dialogowego Właściwości łącza danych, które jest domyślnym edytorem plików .udl. Za pomocą tego okna można określić wszystkie atrybuty potrzebne w ciągu połączenia ADO. Atrybuty te są następnie zapisywane w pliku .udl. W zakładce Dostawca okna dialogowego Właściwości łącza danych widoczni są wszyscy dostawcy zainstalowani lokalnie w komputerze. ADO to mechanizm działający lokalnie, dlatego aby działał poprawnie, dostawca musi być zainstalowany lokalnie. Dostawcy ADO widoczni na rysunku 27.4 zostali zainstalowani wraz z systemem Windows lub z pakietem Office 2013.
Obiekt Command w ADO Drugim ważnym elementem ADO jest typ Command (czyli polecenie). Obiekt ten, jak nazwa wskazuje, wykonuje polecenie na źródle danych otwartym za pomocą obiektu typu Connection. Instrukcja może być bardzo prosta (np. sama nazwa kwerendy Accessa), a także bardzo skomplikowana (np. długa instrukcja SQL-a pobierająca dziesiątki pól i obejmująca klauzule WHERE i ORDER BY). Obiekt typu Command to najczęściej stosowany sposób uruchamiania procedur składowanych z baz SQL Server w aplikacjach Accessa. W dalszej części rozdziału przekonasz się, że dane wyjściowe uzyskane dzięki uruchomieniu obiektu typu Command można skierować do zbioru rekordów. Dane ze zbioru rekordów można następnie wykorzystać do zapełnienia formularza lub formantów (pól tekstowych, pól kombi i list). Istnieje wiele sposobów na zastosowanie obiektów typu Command. W poniższej procedurze przedstawiono jeden z nich. Tu obiekt typu Command zapełnia zbiór rekordów danymi pobranymi bezpośrednio z tabeli tblCustomers (zbiory rekordów opisano w późniejszym punkcie). Procedura ta (ExecuteCommand) znajduje się w module modADO_Commands przykładowej bazy danych Rozdział27.accdb. Public Sub ExecuteCommand() Dim adRs As ADODB.Recordset Dim adCmd As ADODB.Command Const sTABLE As String = "tblCustomers" Set adRs = New ADODB.Recordset Set adCmd = New ADODB.Command
828
Część VII Zaawansowane techniki programowania w Accessie adCmd.ActiveConnection = CurrentProject.Connection adCmd.CommandText = sTABLE Set adRs = adCmd.Execute Debug.Print adRs.GetString adRs.Close Set adRs = Nothing Set adCmd = Nothing End Sub
Procedura ta wykonuje następujące operacje:
Deklaruje obiekty typu Recordset i Command oraz tworzy ich egzemplarze.
Ustawia właściwość ActiveConnection obiektu typu Command na wartość właściwości Connection bieżącego projektu.
Ustawia właściwość CommandText obiektu typu Command na nazwę tabeli bazy danych.
Zapełnia zbiór rekordów wartością zwracaną po uruchomieniu obiektu typu Command.
Zwróć uwagę na metodę GetString zbioru rekordów. Pozwala ona w wygodny sposób wyświetlić całą zawartość takiego zbioru. Rysunek 27.5 przedstawia dane wyjściowe procedury ExecuteCommand w oknie Immediate. Rysunek 27.5. Metoda GetString to wygodny sposób, by sprawdzić zawartość zbioru rekordów
Okno debugowania omówiono szczegółowo w rozdziale 26.
W tym prostym przykładzie przedstawiono prawie wszystkie potrzebne informacje na temat obiektów typu Command w ADO. Obiekt tego typu trzeba połączyć z dostępnym obiektem typu Connection za pomocą właściwości ActiveConnection. Do właściwości tej można przypisać ciąg połączenia lub otwarty obiekt typu Connection. Nie ma tu znaczenia, do jakiej bazy prowadzi obiekt typu Connection. Może to być baza Accessa, SQL Server, Oracle lub dowolne inne źródło danych. Obiekt typu Command, aby pobrać dane, wykorzystuje umiejętność obsługi danego źródła danych przez obiekt typu Connection. Obiekty typu Command są najbardziej przydatne, gdy używa się ich razem z kwerendami z parametrami. Każdy obiekt typu Command obejmuje kolekcję Parameters z obiektami typu Parameter. Każdy obiekt z tej kolekcji odpowiada parametrowi potrzebnemu w kwerendzie lub w procedurze składowanej zapisanej we właściwości CommandText obiektu typu Command.
Rozdział 27. Dostęp do danych za pomocą kodu VBA
829
Do właściwości CommandText bardzo często przypisywana jest instrukcja SQL-a z parametrami. Oto przykładowa instrukcja tego typu: SELECT * FROM tblCustomers WHERE State = 'Małopolskie' OR Województwo = "Mazowieckie"
W niniejszej książce zetkniesz się z wieloma przykładami zastosowania obiektu ADO typu Command do zapełniania zbiorów rekordów i wykonywania operacji na danych.
Obiekt Recordset w ADO Obiekt Recordset w ADO jest bardzo wszechstronny. Najczęściej zapełnia się go przez uruchomienie instrukcji z obiektu typu Command lub bezpośrednio, za pomocą metody Open. W procedurze Open_ADO_Recordset pokazano, jak łatwo jest za pomocą obiektu typu Recordset otworzyć tabelę Accessa (procedura ta znajduje się w module basADO_Recordset w przykładowej bazie danych Rozdział27.accdb). Public Sub Open_ADO_Recordset() Dim adRs As ADODB.Recordset Set adRs = New ADODB.Recordset adRs.Open "SELECT * FROM tblCustomers;", _ CurrentProject.Connection Debug.Print adRs.GetString adRs.Close Set adRs = Nothing End Sub
Tu zbiór rekordów jest zapełniany w wyniku otwarcia tabeli tblCustomers. Zauważ, że do pobierania rekordów z tej tabeli służy instrukcja SQL-a. W instrukcji tej można umieścić klauzule WHERE lub ORDER BY, aby filtrować i sortować pobierane dane. Inny sposób napisania tej procedury polega na przypisaniu do właściwości ActiveConnection odrębnej instrukcji. Public Sub Open_ADO_Rs_Connection() Dim adRs As ADODB.Recordset Set adRs = New ADODB.Recordset adRs.ActiveConnection = CurrentProject.Connection adRs.Open "SELECT * FROM tblCustomers;" Debug.Print adRs.GetString adRs.Close Set adRs = Nothing End Sub
830
Część VII Zaawansowane techniki programowania w Accessie
Procedura Open_ADO_Rs_Connection znajduje się w module basADO_Recordsets w przykładowej bazie danych Rozdział27.accdb. Wielu programistów preferuje podejście zastosowane w procedurze Open_ADO_Rs_Connection, ponieważ ułatwia ono stwierdzenie, co się dzieje z obiektem typu Recordset i gdzie ustawiane są jego właściwości. Choć te bardzo krótkie procedury łatwo jest zrozumieć, w bardziej rozbudowanym kodzie wyszukiwanie wszystkich referencji do obiektów podobnych do adRs może być trudne (zwłaszcza gdy instrukcje VBA są długie i skomplikowane). Obiekty typu Recordset (podobnie jak inne obiekty w ADO) trzeba zadeklarować i utworzyć. Jeśli do zapełniania obiektu typu Recordset służy metoda Open, jej argumentem musi być otwarte połączenie (to samo dotyczy obiektów typu Command). Obiekty typu Recordset są używane w wielu różnych miejscach tej książki. Najczęściej używane metody obiektów tego typu to: Open, Close, MoveFirst, MoveNext, MovePrevious i MoveLast. Poruszanie się po zbiorach rekordów Zbiory rekordów nie byłyby tak przydatne, jak są, gdyby można je było tylko otworzyć lub zamknąć albo gdyby jedynym sposobem wykorzystania danych z tych zbiorów było użycie metody GetString. W zależności od kontekstu określenie zbiór rekordów może oznaczać różne rzeczy:
wiersze danych zwrócone przez kwerendę,
dane powiązane z formularzem Accessa,
obiekt zapełniony danymi w wyniku wykonania operacji ADO.
We wszystkich tych sytuacjach zbiór rekordów to struktura danych obejmująca wiersze i kolumny z danymi. Wiersze to rekordy, a kolumny to pola. Zrozumiałe jest więc, że Access udostępnia sposoby poruszania się po zbiorach rekordów. W trakcie wyświetlania tabeli lub wyników kwerendy w formie arkusza danych można wykorzystać pionowe i poziome paski przewijania lub strzałki, aby poruszać się w górę i w dół oraz w lewo i prawo po arkuszu ze zbiorem rekordów. Nie jest zaskoczeniem, że w ADO obiekty typu Recordset obsługują metody poruszania się po rekordach zawartych w ich zbiorach. W poniższej procedurze przedstawiono podstawowe metody poruszania się po zbiorach rekordów w ADO. W punkcie „Obiekty DAO” w dalszej części rozdziału zobaczysz, że zbiory rekordów w DAO udostępniają metody o identycznych nazwach. Public Sub RecordsetNavigation() Dim adRs As ADODB.Recordset Set adRs = New ADODB.Recordset adRs.ActiveConnection = CurrentProject.Connection adRs.CursorType = adOpenStatic adRs.Open "SELECT * FROM tblCustomers;"
Rozdział 27. Dostęp do danych za pomocą kodu VBA
831
Debug.Print adRs!CustomerID, adRs!Company adRs.MoveNext Debug.Print adRs!CustomerID, adRs!Company adRs.MoveLast Debug.Print adRs!CustomerID, adRs!Company adRs.MovePrevious Debug.Print adRs!CustomerID, adRs!Company adRs.MoveFirst Debug.Print adRs.Fields("CustomerID").Value, _ adRs.Fields("Company").Value adRs.Close Set adRs = Nothing End Sub
Procedura rozpoczyna się od otwarcia obiektu typu Recordset zapełnionego danymi z tabeli tblCustomers. Powoduje to natychmiastowe wyświetlenie pól CustomerID i Company pierwszego rekordu. Następnie procedura przeskakuje po zbiorze rekordów po kilka wierszy naraz i wyświetla przy tym pola CustomerID i Company poszczególnych rekordów. W ostatnim kroku wraca do pierwszego rekordu i wyświetla jego dane. Dane wyjściowe procedury RecordsetNavigation przedstawia rysunek 27.6. Rysunek 27.6. Poruszanie się po zbiorach rekordów
Jest to oczywiście bardzo prosty przykład, pokazujący, jak łatwo można się poruszać po zbiorach rekordów w ADO. Programista może używać dowolnego rekordu ze zbioru i w razie potrzeby przechodzić do wcześniejszych lub dalszych wierszy. Zbiory rekordów w Accessie obsługują wskaźnik do bieżącego rekordu. W danym momencie bieżący jest tylko jeden rekord ze zbioru. Przy wprowadzaniu zmian w zbiorze rekordów lub poruszaniu się po jego wierszach kod wpływa tylko na bieżący rekord. W procedurze RecordsetNavigation pokazano dwie techniki wskazywania poszczególnych pól rekordów. Można zastosować operator wykrzyknika (!) i kolekcję Fields. Po przejściu do wiersza można wskazać pola jak składowe zbioru rekordów. Access manipuluje tylko jednym rekordem w danym momencie, dlatego każde wskazanie pola dotyczy pól bieżącego rekordu.
832
Część VII Zaawansowane techniki programowania w Accessie
Właściwość CursorType Zwróć uwagę na właściwość CursorType procedury RecordsetNavigation. Tu wartość tej właściwości to adOpenStatic. Właściwość CursorType przyjmuje kilka wartości; adOpen Static oznacza, że do otwierania zbioru rekordów służy kursor statyczny. Access wykorzystuje kursory do śledzenia bieżącego rekordu w zbiorze. Kursor statyczny powoduje, że dane w zbiorze też są statyczne i nie można dodawać nowych rekordów. Kursory statyczne doskonale się sprawdzają, gdy programista używa zbioru rekordów do przeglądania danych z powiązanej tabeli i nie musi dodawać nowych rekordów. Możliwe wartości właściwości CursorType przedstawia tabela 27.1. Tabela 27.1. Wartości właściwości CursorType Wartość
Działanie właściwości CursorType
adOpenDynamic
Kursor dynamiczny obsługuje wszystkie metody poruszania się. Zbiór rekordów udostępnia wtedy wszystkie sposoby edycji. Można dodawać nowe rekordy i modyfikować istniejące. Zmiany wprowadzone przez innych użytkowników są zapisywane w zbiorze rekordów znajdującym się w danym momencie w pamięci.
adOpenForwardOnly
Powoduje, że zbiór rekordów jest statyczną kopią powiązanych danych. Nie można wtedy dodawać nowych rekordów, a zbiór rekordów nie odzwierciedla zmian wprowadzonych w tabelach przez innych użytkowników. Najważniejsze jest to, że dla zbiorów tego typu działają tylko metody MoveNext i MoveLast.
adOpenKeySet
Obsługuje wszystkie sposoby poruszania się i umożliwia edycję rekordów. Nie są jednak widoczne zmiany wprowadzone w wyniku dodania lub usunięcia rekordów przez innych użytkowników.
adOpenStatic
Otwiera statyczny zbiór rekordów, w którym nie widać zmian wprowadzonych w powiązanych tabelach przez innych użytkowników. Działa podobnie jak kursory adOpenForwardOnly, jednak obsługuje wszystkie sposoby poruszania się.
Każdy typ kursorów ma określony wpływ na dane ze zbioru rekordów. Nie należy na przykład używać kursorów adOpenForwardOnly, jeśli użytkownik chce mieć możliwość przechodzenia do wcześniejszych i dalszych rekordów. Kursory tego typu stosuje się najczęściej do aktualizowania rekordów w trybie masowym, np. przy modyfikowaniu numerów kierunkowych lub stawek podatkowych w wielu rekordach. Nie ma też sensu stosowanie kursora dynamicznego (adOpenDynamic) do wykonywania prostych zadań, takich jak sprawdzanie, czy w zbiorze rekordów wprowadzono aktualizacje. Kursor dynamiczny śledzi zmiany wprowadzone przez bieżącego użytkownika i modyfikacje w powiązanych tabelach. Dlatego jest wolniejszy oraz wymaga więcej pamięci i cykli procesora niż prostszy kursor adOpenForwardOnly. Wykrywanie końca lub początku zbioru rekordów Metody MovePrevious i MoveNext przenoszą wskaźnik do bieżącego rekordu o jeden wiersz. Jeśli wskaźnik prowadzi do pierwszego lub ostatniego rekordu, metody te bez zgłaszania błędu przesuwają wskaźnik za początek lub koniec zbioru. W trakcie poruszania się po zbiorze rekordów trzeba sprawdzać, czy wskaźnik bieżącego rekordu prowadzi do poprawnego rekordu. Dopiero potem można użyć danych lub wykonać na rekordzie operacje.
Rozdział 27. Dostęp do danych za pomocą kodu VBA
833
Obiekt Recordset w ADO obsługuje dwie właściwości logiczne EOF i BOF, które określają, kiedy wskaźnik bieżącego rekordu wskazuje poza koniec lub początek zbioru rekordów. EOF i BOF to akronimy od ang. end of file (koniec pliku) i beginning of file (początek pliku). Właściwości EOF i BOF mają wartość False, gdy wskaźnik prowadzi do poprawnego rekordu. EOF ma wartość True, gdy wskaźnik prowadzi poza koniec zbioru rekordów, a BOF ma wartość True, jeśli wskaźnik znajduje się przed początkiem takiego zbioru. Obie właściwości jednocześnie mają wartość True tylko wtedy, gdy zbiór nie obejmuje żadnych rekordów. W procedurze Use_EOF_BOF pokazano, jak używać właściwości EOF i BOF dla obiektów typu Recordset w ADO. Public Sub Use_EOF_BOF() Dim adRs As ADODB.Recordset Set adRs = New ADODB.Recordset adRs.ActiveConnection = CurrentProject.Connection adRs.CursorType = adOpenStatic adRs.Open "SELECT * FROM tblCustomers " _ & "WHERE State = 'Śląskie' " _ & "ORDER BY Company;" Debug.Print "Liczba rekordów: " & adRs.RecordCount If adRs.BOF And adRs.EOF Then Debug.Print "Brak rekordów do przetworzenia" Exit Sub End If Do Until adRs.EOF Debug.Print adRs!Company adRs.MoveNext Loop adRs.MoveLast Do Until adRs.BOF Debug.Print adRs!Company adRs.MovePrevious Loop adRs.Close Set adRs = Nothing End Sub
We wcześniejszych przykładach z tego rozdziału stosowano podobny kod. Główne różnice polegają na tym, że tu kod sprawdza wartości właściwości EOF i BOF przed uruchomieniem metod MoveLast i MovePrevious. Zauważ, że właściwości te przyjmują wartość True dopiero po wywołaniu wspomnianych metod. Przy poruszaniu się w kierunku końca zbioru rekordów kod sprawdza wartość właściwości EOF po wykonaniu metody MoveNext (na początku pętli Do Until).
834
Część VII Zaawansowane techniki programowania w Accessie
Określanie liczby rekordów Często przed rozpoczęciem długotrwałych operacji warto ustalić, ile rekordów znajduje się w zbiorze. W przeciwnym razie użytkownik może nierozsądnie wybrać kryteria, które powodują zwrócenie zbyt wielu rekordów, aby możliwe było ich wydajne obsłużenie. Na szczęście obiekty typu Recordset w ADO udostępniają właściwość RecordCount, która określa, ile rekordów znajduje się w zbiorze. Public Sub UseRecordCount() Dim adRs As ADODB.Recordset Dim lCnt As Long Set adRs = New ADODB.Recordset adRs.ActiveConnection = CurrentProject.Connection adRs.CursorType = adOpenStatic adRs.Open "SELECT * FROM tblCustomers;" Do While Not adRs.EOF lCnt = lCnt + 1 Debug.Print "Rekord " & lCnt & " z " & adRs.RecordCount adRs.MoveNext Loop adRs.Close Set adRs = Nothing End Sub
Właściwość RecordCount nie działa w zbiorach rekordów z kursorem adOpenForwardOnly. Zauważ, że tu właściwość CursorType ustawiana jest na wartość adOpenStatic. Po ustawieniu jej na adOpenForwardOnly właściwość RecordCount przyjmuje wartość –1 i nie zmienia się dopóty, dopóki zbiór rekordów znajduje się w pamięci. Właściwość RecordCount umożliwia wygodne ustalenie, czy zbiór w ogóle obejmuje jakieś rekordy. Jedyny problem z właściwością RecordCount polega na tym, że jeśli zbiór jest duży, jej zastosowanie negatywnie wpływa na wydajność kodu. Obiekt typu Recordset zlicza wtedy rekordy ze zbioru i do czasu zakończenia tej operacji wstrzymuje wykonywanie innych zadań. Znacznie szybszym sposobem wykrywania pustych zbiorów rekordów jest sprawdzanie, czy właściwości EOF i BOF obie mają wartość True. If adRs.BOF And rs.EOF Then Debug.Print "Brak rekordów do przetworzenia" Exit Sub End If
Właściwości te mają tę samą wartość (True) tylko wtedy, gdy kursor znajduje się jednocześnie przed pierwszym rekordem i po ostatnim. Jest to możliwe tylko w sytuacji, gdy zbiór nie obejmuje żadnych rekordów.
Rozdział 27. Dostęp do danych za pomocą kodu VBA
835
Obiekty typu Recordset w ADO mają też wiele innych funkcji, których nie opisano w tym rozdziale. Wiele z nich przedstawiono w rozdziale 28., a dalsze — w różnych innych rozdziałach tej książki. Obiekty typu Recordset w ADO są wartościowym narzędziem dla programistów Accessa i warto dokładnie się im przyjrzeć w różnych kontekstach.
Obiekty DAO DAO (ang. Data Access Objects) to starszy model obiektowy zapewniający dostęp do danych w Accessie. Model DAO jest używany w Accessie od samego początku i często wykorzystuje się go w aplikacjach Accessa. Obiekty DAO (w odróżnieniu od obiektów ADO) mają strukturę hierarchiczną. Niektóre obiekty są podrzędne względem innych i nie mogą istnieć bez obiektu nadrzędnego. „Ojcem” wszystkich obiektów DAO jest DBEngine. Jest to korzeń drzewa obiektów DAO. Wszystkie pozostałe obiekty są pochodne od DBEngine (zobacz rysunek 27.7). Rysunek 27.7. Model obiektowy DAO
Dalej zostały opisane najczęściej używane obiekty DAO. Hierarchia obiektów DAO jest zgodna z uporządkowaniem obiektów baz danych w Accessie. Na przykład tabele Accessa (obiekty typu TableDef) obejmują pola (obiekty typu Field). Pole ma zbiór właściwości pozwalających określić szczegółowe informacje na temat typu danych, domyślne wartości, reguły sprawdzania poprawności itd. Aby zapewnić przejrzystość, na rysunku 27.7 zostały pominięte właściwości powiązane z poszczególnymi obiektami DAO. Można jednak przyjąć, że każdy obiekt z rysunku 27.7 powiązany jest ze zbiorem właściwości.
Każdy obiekt DAO ma odpowiednią dla typu kolekcję właściwości. Obiekty typu TableDef mają pewne właściwości wspólne z obiektami typu QueryDef, jednak każdy typ ma też właściwości charakterystyczne dla siebie. Oba typy mają na przykład właściwość Name, ale tylko typ TableDef ma właściwość SQL. To samo dotyczy metod. Każdy obiekt DAO
836
Część VII Zaawansowane techniki programowania w Accessie
ma operacje, które tylko on potrafi wykonywać. Na przykład obiekty typu QueryDef mają metodę Execute (służy do wykonywania kwerend), której nie mają obiekty typu TableDef. Nauczenie się tego, które właściwości i metody należą do poszczególnych obiektów DAO, jest prawdopodobnie największym wyzwaniem stojącym przed programistami Accessa. W trakcie lektury dalszych punktów zwróć uwagę na to, że pominięto pewne szczegóły. Ponieważ każdy obiekt DAO udostępnia wiele właściwości i metod oraz istnieje wiele sposobów korzystania z takich obiektów w aplikacjach Accessa, nie da się dokładnie opisać całego modelu obiektowego DAO w jednym rozdziale. Zamiast tego w książce przedstawiono konkretne techniki stosowania tego modelu (a także modelu ADO). W indeksie znajdziesz rozdziały i punkty dotyczące konkretnych obiektów zapewniających dostęp do danych. W Accessie 2007 wprowadzono silnik ACE (ang. Microsoft Access Engine). Jest to nowy silnik bazodanowy dla produktów z pakietu Microsoft Office. To dzięki technologii ACE w wersjach Accessa od 2007 do 2013 dostępne są zaawansowane funkcje (np. załączniki i pola o wielu wartościach). Z uwagi na nowe typy danych ACE wymaga zaktualizowanej wersji modelu DAO (ACEDAO), która obsługuje nowe możliwości. Największą różnicą między DAO i ACEDAO jest wprowadzenie obiektów typu Recordset2 i Field2, a także nowych właściwości i metod potrzebnych do obsługi funkcji dodanych w Accessie 2007. W Accessie 2013 nadal obsługiwana jest najnowsza wersja tradycyjnego modelu DAO, czyli DAO 3.6. Choć w tym miejscu opisano tradycyjny model DAO, wszystkie wyjaśnienia i przykłady dotyczą także wersji ACEDAO. Format .mdb w Accessie 2013 obsługuje tylko DAO 3.6 (nie współdziała z modelem ACEDAO).
Obiekt DBEngine w DAO Obiekt typu DBEngine reprezentuje silnik ACE i jest korzeniem hierarchii obiektów w DAO. Nie jest elementem żadnej kolekcji, a wszystkie kolekcje to typy podrzędne względem DBEngine. Istnieje tylko jeden egzemplarz obiektu tego typu. Jest to też jeden z bardzo nielicznych obiektów dających dostęp do danych, którego programiści nie mogą tworzyć samodzielnie. Jest otwierany w momencie wywołania operacji DAO po uruchomieniu Accessa. Udostępnia stosunkowo nieliczne właściwości i metody. Aby nowe właściwości zostały uwzględnione, trzeba je zmienić przed wywołaniem operacji obiektu dającego dostęp do danych. W przeciwnym razie wystąpi błąd. Ponieważ DBEngine to korzeń hierarchii, kod DAO prawie zawsze zaczyna się od obiektu tego typu.
Obiekt Workspace w DAO Obiekt Workspace (obszar roboczy) reprezentuje otwartą, aktywną sesję użytkowników Accessa. Wszystkie bazy danych są otwierane w obszarze roboczym — albo w ramach domyślnej sesji bazy danych, albo w obszarze utworzonym za pomocą metody Create Workspace obiektu typu DBEngine. Jeśli chcesz śledzić transakcje w aplikacji (BeginTrans...EndTrans), uwzględniane będą wszystkie zbiory rekordów otwierane w bieżącym obszarze roboczym. Jeżeli nie chcesz stosować transakcji dla konkretnego zbioru rekordów, utwórz nowy obszar roboczy, a następnie otwórz dany zbiór rekordów w nowym obiekcie typu Workspace.
Obiekty typu Workspace zapewniają też bezpieczeństwo (ale tylko dla plików w formacie .mdb). Metody zabezpieczające obiektów typu Workspace umożliwiają tworzenie własnych interfejsów i procedur bezpieczeństwa. Jeśli to konieczne, możesz tworzyć użytkowników i grupy za pomocą metod CreateUser oraz CreateGroup obiektu Workspace.
Rozdział 27. Dostęp do danych za pomocą kodu VBA
837
Obiekt Database w DAO Obiekt Database reprezentuje źródło danych i przypomina obiekt Connection z ADO. Access potrafi otwierać bazy danych w różnych formatach. Gdy korzystasz bezpośrednio z silnika ACE lub Jet, bazą danych mogą być różne źródła — plik dBASE, plik FoxPro, plik .mdb, a nawet źródło danych ODBC. Ważne są tu wartości zmiennych obiektu typu Database. Poniższy kod używa otwartej obecnie bazy Accessa. Dim daDb As DAO.Database Set daDb = CurrentDb
CurrentDb to metoda obiektu Application, który reprezentuje całe środowisko Accessa
i wszystkie jego obiekty. Zastosowanie tej metody to szybki i łatwy sposób na otwarcie bazy danych, nad którą użytkownik aktualnie pracuje. Można też otworzyć bazę danych Accessa spoza bieżącej bazy. Dim daDb As DAO.Database Set daDb = OpenDatabase("C:\Northwind.mdb")
Zauważ, że metoda OpenDatabase przyjmuje ścieżkę do istniejącego pliku .mdb lub .accdb. Wykonanie tej metody może się nie powieść. Zależy to od tego, czy zewnętrzna baza danych jest dostępna i czy aktualny stan środowiska umożliwia otwarcie innej aplikacji Accessa. Podobnie jak przy stosowaniu obiektów ADO poprzedzaj deklaracje obiektów DAO członem „DAO”, aby Access wiedział, którą bibliotekę ma wybrać do utworzenia obiektu. Zarówno w ACEDAO, jak i w DAO 3.6 przedrostkiem jest „DAO”.
Obiekt TableDef w DAO Obiekt TableDef w DAO reprezentuje tabelę z bazy danych Accessa. Może to być tabela lokalna lub powiązana z bieżącą bazą danych. Poniższa procedura (znajdziesz ją w przykładowej bazie Rozdział27.accdb) tworzy nową tabelę o nazwie MyTempTable, dodaje do niej trzy pola tekstowe, a następnie dołącza tę tabelę do kolekcji TableDefs bieżącej bazy. Public Sub CreateNewTableDef() Dim daDb As DAO.Database Dim daTdf As DAO.TableDef Const sTABLENAME As String = "MyTempTable" Set daDb = Application.CurrentDb ' Ta instrukcja nakazuje Accessowi usunąć tabelę, ale ' zignorować błędy, które mogą wystąpić, jeśli ' tabela jeszcze nie istnieje:
838
Część VII Zaawansowane techniki programowania w Accessie On Error Resume Next db.TableDefs.Delete "tblTymczasowa" On Error GoTo 0 ' Tworzenie nowego obiektu typu TableDef Set daTdf = db.CreateTableDef(sTABLENAME) With daTdf ' Tworzenie pól i dołączanie ich do zmiennej tdfNew: .Fields.Append .CreateField("FirstName", dbText) .Fields.Append .CreateField("LastName", dbText) .Fields.Append .CreateField("Phone", dbText) End With ' Dołączanie nowego obiektu typu TableDef do bieżącej bazy danych: daDb.TableDefs.Append daTdf daDb.Close Set daDb = Nothing End Sub
Po uruchomieniu tego kodu w bazie Rozdział27.accdb utworzona zostanie nowa tabela o nazwie MyTempTable. Zostanie ona na trwałe dodana do bazy. Zauważ, że procedura CreateNewTableDef przed utworzeniem nowej tabeli (za pomocą obiektu TableDef) usuwa istniejącą tabelę. Access nie zezwala na dołączenie nowego obiektu typu TableDef do kolekcji TableDefs, jeśli w bazie istnieje już tabela o użytej nazwie. Jeśli nowo utworzony obiekt typu TableDef (lub inny) nie pojawia się w okienku nawigacji, wciśnij klawisz F5, aby je odświeżyć. Procedura CreateNewTableDef obejmuje dwie instrukcje, które określają, jak Access ma obsługiwać błędy w kodzie. W rozdziale 26. opisano instrukcje obsługi błędów w kodzie VBA i wyjaśniono, dlaczego w takich procedurach używa się instrukcji On Error Resume Next i On Error GoTo 0.
Obiekty typu TableDef są przechowywane w kolekcji TableDefs. Poniższa procedura wyświetla nazwy wszystkich obiektów typu TableDef (w tym tabel ukrytych i systemowych) z bieżącej bazy danych. Public Sub DisplayAllTableDefs() Dim daDb As DAO.Database Dim daTdf As DAO.TableDef Set daDb = CurrentDb With daDb Debug.Print .TableDefs.Count & _ " obiektów TableDef w bazie " & .Name For Each daTdf In .TableDefs Debug.Print " " & daTdf.Name Next daTdf End With
Rozdział 27. Dostęp do danych za pomocą kodu VBA
839
daDb.Close Set daDb = Nothing End Sub
Obiekty typu QueryDef w DAO Obiekt typu QueryDef reprezentuje zapisaną kwerendę w bazie danych Accessa. Za pomocą kodu VBA można powiązać zmienną typu QueryDef z istniejącą kwerendą, utworzyć nową kwerendę, zmienić instrukcję SQL-a w kwerendzie, podać wartości parametrów kwerendy, a także wykonać kwerendę. W obiektach tego typu można zastosować kwerendę SELECT, która zwraca zbiór rekordów, lub kwerendę funkcjonalną, która modyfikuje kod w powiązanych tabelach. Tworzenie obiektów typu QueryDef w kodzie przebiega podobnie jak tworzenie obiektów typu TableDef. Różnica polega na tym, że nowego obiektu typu QueryDef nie trzeba bezpośrednio dodawać do kolekcji QueryDefs bazy danych. Public Sub CreateQueryDef() Dim daDb As DAO.Database Dim daQdf As DAO.QueryDef Const sQRYNAME As String = "MyQueryDef" Set daDb = CurrentDb Set daQdf = daDb.CreateQueryDef(sQRYNAME, _ "SELECT * FROM tblCustomers") daDb.Close Set daDb = Nothing End Sub
Bezpośrednio po wykonaniu metody CreateQueryDef Access doda do bazy nowy obiekt typu QueryDef. Obiekt taki trzeba bezpośrednio usunąć, jeśli nie ma być widoczny w oknie nawigacyjnym. CurrentDb.TableDefs.Delete "NazwaKwerendy"
W razie potrzeby można utworzyć obiekt typu QueryDef bez nazwy. Wtedy nowy obiekt nie jest zapisywany i nie pojawia się w oknie nawigacji. Technika ta jest przydatna na przykład przy zapełnianiu pola kombi lub listy danymi, gdy programista nie chce tworzyć trwałego obiekty typu QueryDef, ponieważ warunki zmieniają się przy każdym uruchomieniu kodu. Jedną ze stosowanych od lat zaawansowanych technik Accessa jest dynamiczne modyfikowanie instrukcji SQL-a w istniejących obiektach typu QueryDef. Po zmianie właściwości SQL kwerenda zwraca zbiór rekordów określony przez nową instrukcję. Public Sub ChangeQueryDefSQL() CurrentDb.QueryDefs("MyQueryDef").SQL = _ "SELECT * FROM tblProducts;" End Sub
840
Część VII Zaawansowane techniki programowania w Accessie
Zauważ, że w procedurze ChangeQueryDefSQL nie pojawiają się deklaracje zmiennych obiektowych (np. daDb lub daQdf), które odpowiadałyby obiektom typu Database lub QueryDef. W procedurze do wskazania obiektu typu Database wykorzystano obiekt CurrentDb i bezpośrednio uzyskano dostęp do właściwości SQL obiektu zwróconego przez właściwość QueryDefs. W dłuższych procedurach lepszym rozwiązaniem jest stosowanie zmiennych obiektowych, jednak w krótkich procedurach, takich jak ta, bezpośrednie użycie obiektu CurrentDb jest łatwiejsze i zwiększa czytelność kodu. Obiekt typu Recordset w DAO można bardzo łatwo zapełnić bezpośrednio przy użyciu obiektu typu QueryDef (więcej informacji o obiektach typu Recordset znajdziesz w następnym punkcie). Zauważ, o ile prostsza jest poniższa procedura od jej odpowiednika w ADO. Public Function GetRecordset() As DAO.Recordset Dim daRs As DAO.Recordset Dim daQdf As DAO.QueryDef Set daQdf = CurrentDb.QueryDefs("MyQueryDef") ' Otwieranie obiektu Recordset przy użyciu obiektu QueryDef: Set daRs = daQdf.OpenRecordset(dbOpenSnapshot) daRs.MoveLast Debug.Print "Liczba rekordów: " & daRs.RecordCount Set GetRecordset = daRs End Sub
Warto zauważyć, że jako wynik funkcji tuż przed jej zakończeniem ustawiany jest lokalnie zadeklarowany obiekt typu Recordset (daRs). Jest to jeden ze sposobów tworzenia w procedurze zbioru rekordów bez konieczności powielania kodu, który tworzy dany zbiór, i uruchamiania obiektu typu QueryDef w każdym miejscu, gdzie aplikacja potrzebuje tego zbioru.
Obiekty typu Recordset w DAO Obiekt typu Recordset należy zadeklarować, a następnie powiązać z nim tabelę, kwerendę lub źródło danych ODBC z aplikacji. Za pomocą metod takich obiektów można aktualizować, modyfikować i usuwać rekordy, poruszać się do przodu i do tyłu po zbiorze rekordów, a także znajdować konkretne rekordy przy użyciu metod Find i Seek. Istnieje kilka rodzajów obiektów Recordset — Table, Dynaset i Snapshot — które stosuje się w zależności od potrzeb. Załóżmy, że chcesz tylko znaleźć w tabeli pole o konkretnej wartości. Dobrym wyborem jest wtedy typ Snapshot, który służy do przeglądania danych w trybie tylko do odczytu. Możliwe też, że chcesz w locie uruchamiać kwerendy z wykorzystaniem tabeli, używając w nich parametrów od użytkownika. Wtedy można generować instrukcje SQL-a na podstawie danych od użytkownika i tworzyć zbiory rekordów typu Dynaset. Aby określić rodzaj zbioru rekordów, należy podać stałą dbOpenTable, dbOpenDynaset lub dbOpenSnapshot jako argument metody OpenRecordset obiektu typu Database. Poniżej pokazano, jak otworzyć zbiór rekordów typu Snapshot przy użyciu ciągu z instrukcją SQL-a.
Rozdział 27. Dostęp do danych za pomocą kodu VBA
841
Dim daDb As DAO.Database Dim daRs As DAO.Recordset Dim sSql As String sSql = "SELECT * FROM tblCustomers" Set daDb = CurrentDb Set daRs = daDb.OpenRecordset(sSql, dbOpenSnapshot)
Jeśli nie określisz bezpośrednio rodzaju obiektu Recordset, Access wybierze potencjalnie najwydajniejszą metodę. Źródeł danych ODBC nie można otwierać za pomocą opcji dbOpenTable. Koniecznie trzeba zastosować stałą dbOpenDynaset lub dbOpenSnapshot. W wielu miejscach tej książki przekonasz się, że zbiory rekordów w DAO można otwierać na różne sposoby. W poniższej procedurze pokazano tylko jeden z nich. Tu zbiór rekordów jest tworzony bezpośrednio na podstawie tabeli tblCustomers. W oknie debugowania wyświetlane jest każde pole z każdego wiersza tej tabeli (obiekty typu Field i kolekcje Fields omówiono w następnym punkcie). Public Sub OpenDAORecordset1() Dim daDb As DAO.Database Dim daRs As DAO.Recordset Dim i As Long Set daDb = CurrentDb ' Otwieranie zbioru rekordów bezpośrednio za pomocą tabeli: Set daRs = daDb.OpenRecordset("tblCustomers") Debug.Print "Zbiór rekordów oparty na tabeli: " & daRs.Name ' Wyświetlanie rekordów Do While Not daRs.EOF For i = 0 To daRs.Fields.Count - 1 Debug.Print daRs.Fields(i).Name & ": " & daRs.Fields(i).Value Next i Debug.Print Loop
daRs.MoveNext
daRs.Close Set daRs = Nothing Set daDb = Nothing End Sub
Obiekty typu Field (ze zbiorów rekordów) w DAO Obiekty typu Field w zbiorach rekordów reprezentują kolumnę z tabeli lub kwerendy. Obiekty typu Field w zbiorach rekordów różnią się nieco od ich odpowiedników w obiektach typu TableDef i QueryDef, ponieważ zawierają wartości. Każdy obiekt typu TableDef obejmuje kolekcję Fields, w której znajdują się dane przechowywane w tabeli powiązanej z danym obiektem.
842
Część VII Zaawansowane techniki programowania w Accessie
ADO czy DAO? Z uwagi na oczywiste podobieństwa między technologiami ADO i DAO możesz się zastanawiać, którą z nich wybrać przy tworzeniu nowej aplikacji Accessa (w istniejących aplikacjach Accessa zazwyczaj obowiązuje już jedno z tych podejść). Microsoft wciąż obsługuje obie te technologie, a także wprowadził ACEDAO — wersję DAO dostosowaną do nowych wersji Accessa. Które rozwiązanie będzie najlepsze w Twojej aplikacji? Odpowiedź zależy od sytuacji (jak to zwykle bywa przy rozwijaniu baz danych). Choć technologia DAO ma bardziej złożony model obiektowy, jest nieco szybsza i łatwiejsza w użyciu przy wykonywaniu niektórych zadań. Ponieważ nie jest tu potrzebny ciąg połączenia, kod jest zwykle zrozumiały i łatwy do napisania. Procedury DAO można często pisać z pamięci, bez sprawdzania składni w książkach lub internecie. DAO, zwłaszcza dla małych zbiorów danych, działa trochę szybciej od ADO. Technologia ADO jest za to lepsza przy łączeniu się z zewnętrznymi bazami danych. Nie ma tu znaczenia, czy źródłem danych jest inna aplikacja Accessa czy baza SQL Server. Połączenia ADO dla niektórych dostawców danych obejmują właściwości, które określają stan (nawiązane, trwa nawiązywanie, zerwane itd.). W pewnych sytuacjach informacje te są bardzo przydatne. W jednej aplikacji można swobodnie używać kodu ADO i DAO. Nie można jednak korzystać w ramach jednego projektu z DAO i ACEDAO. Pamiętaj o poprzedzaniu wywołań obiektów członami „DAO” (albo „ACEDAO”) lub „ADODB” w zależności od używanej składni. Często decyzja o zastosowaniu DAO lub ADO podejmowana jest na podstawie znalezionego kodu przykładowego, który można wykorzystać w rozwijanej aplikacji. Istnieją tysiące przykładowych fragmentów kodu VBA opartych na tych technologiach. Z technicznego punktu widzenia nie istnieją powody do preferowania DAO lub ADO. Jedynym wyjątkiem jest sytuacja, gdy korzysta się z danych z baz SQL Server. Ponieważ Microsoft udostępnia natywnego dostawcę ADO dla takich baz, ADO jest lepszym wyborem przy stosowaniu baz SQL Server. Po nawiązaniu połączenia z bazą SQL Server obiekt typu Command z ADO doskonale nadaje się do wywoływania procedur składowanych lub doraźnie tworzonych kwerend dla tabel SQL Server. W bazach SQL Server kod ADO prawie zawsze działa szybciej i wydajniej niż DAO, ponieważ w DAO dostęp do takich baz można uzyskać tylko za pomocą źródła danych OLEDB powiązanego z bazą SQL Server. Interfejs OLEDB został opisany w rozdziale 29. W Accessie 2013 domyślną biblioteką dającą dostęp do danych jest ACEDAO. Każda nowa baza w tej wersji ma już ustawioną referencję do biblioteki ACEDAO (ang. Access Database Engine Object) z pakietu Microsoft Office 15.0. Jeśli w aplikacjach Accessa 2013 chcesz zastosować ADO, musisz ręcznie dodać referencję do biblioteki Microsoft ActiveX Data Objects 6.1.
W książce tej znajduje się wiele nawiązań do modeli DAO i ADO, dlatego długie omówienia nie są w tym miejscu potrzebne. Warto jednak wiedzieć, że obiekty typu Field w DAO udostępniają znacznie więcej właściwości niż widać to w oknie do projektowania tabel Accessa. W przykładowej bazie danych Rozdział27.accdb znajdziesz poniższą procedurę, która wymienia wszystkie poprawne właściwości pola Company z tabeli tblCustomers. Public Sub DisplayFieldProperties() Dim Dim Dim Dim
daDb As DAO.Database daTdf As DAO.TableDef daFld As DAO.Field daProp As DAO.Property
Rozdział 27. Dostęp do danych za pomocą kodu VBA
843
Set daDb = CurrentDb Set daTdf = daDb.TableDefs("tblCustomers") Set daFld = daTdf.Fields("Company") Debug.Print "Właściwości pola Company:" For Each daProp In daFld.Properties On Error Resume Next Debug.Print Space(2) & daProp.Name & " = " & daProp.Value On Error GoTo 0 Next daProp daDb.Close End Sub
Nie każda właściwość obiektu typu Field jest w danym momencie prawidłowa. Niektóre właściwości są ustawiane dopiero po przypisaniu danych do pola lub gdy pole pełni funkcję indeksu. Na przykład właściwość Value obiektu typu Field nie jest dostępna bezpośrednio z poziomu kodu. Zamiast tego do ustawiania i pobierania wartości pól należy używać składowych odpowiadających polom obiektu typu Recordset. Instrukcja On Error Resume Next sprawia, że kod jest wykonywany, nawet jeśli właściwości są nieprawidłowe. Błędy, które mogą wystąpić przy używaniu nieprawidłowych właściwości, są tu ignorowane.
Pisanie kodu VBA do aktualizowania tabeli Aktualizowanie danych w tabeli za pośrednictwem formularza jest bardzo proste. Wystarczy umieścić na formularzu odpowiednie formanty obsługujące poszczególne pola tabeli bazy danych. Na rysunku 27.8 przedstawiono przykładowy formularz wyświetlający dane dotyczące transakcji (frmSales). Formanty znajdujące się na formularzu służą do aktualizowania danych w tabelach tblSales, tblSalesLineItems i tblSalesPayments, ponieważ pola z tych tabel są bezpośrednio powiązane z formantami z tego formularza. Istnieją jednak sytuacje, w których istnieje potrzeba aktualizacji danych w tabeli bez wyświetlania ich na ekranie. Na przykład po wprowadzeniu informacji na formularzu frmSales, pole LastSalesDate w tabeli tblCustomers powinno zostać zaktualizowane w celu uwzględnienia ostatniej daty, kiedy klient zakupił produkt. Wartość pola Last SalesDate będzie wówczas pobrana z pola txtSaleDate znajdującego się na formularzu frmSales. Ze względu na to, że data ostatniej sprzedaży pochodzi z formantu txtSaleDate w formularzu frmSales, użytkownik nie powinien być zmuszony do dwukrotnego wprowadzania tej daty. Teoretycznie można by umieścić pole LastSalesDate jako pole obliczeniowe uaktualniane po wprowadzeniu danych w polu Data sprzedaży. Wyświetlenie tego pola byłoby jednak mylące. Poza tym data ta nie dotyczy bieżącej transakcji. Najlepszym sposobem na aktualizację danych w polu LastSalesDate tabeli tblCustomers jest zastosowanie odpowiedniej procedury napisanej w języku VBA. Za pomocą kodu VBA można aktualizować poszczególne pola, dodawać nowe rekordy albo usuwać niepożądane.
844
Część VII Zaawansowane techniki programowania w Accessie
Rysunek 27.8. Formularz służący do aktualizowania danych w tabelach
Aktualizacja pól rekordu z zastosowaniem ADO Do zaktualizowania pola LastSalesDate można wykorzystać procedurę zdarzenia Po aktualizacji (zobacz rysunek 27.9). W procedurze tej użyto technologii ADO do bezpośredniego manipulowania tabelą tblCustomers. Instrukcje programowe używane do uzyskania dostępu i wykonywania operacji na danych w bazie Accessa określa się jako ADO. ADO obejmuje szereg różnych obiektów — każdy z własnym zbiorem właściwości i metod, które pozwalają na wykonywanie różnorodnych operacji na danych. ADO nie jest językiem programowania. Jest to składnia w języku VBA zaprojektowana pod kątem dostępu do danych. Składnia oznacza tu słowa i zwroty, które można stosować w kodzie VBA do wykonywania konkretnych zadań. ADO to uniwersalny mechanizm umożliwiający dostęp do danych z różnych lokalizacji. We wcześniejszych przykładach pokazano, jak za pomocą Accessa aktualizować dane w bazie lokalnej. Lokalna baza danych to taka, której wszystkie tabele, kwerendy, formularze i raporty są przechowywane w komputerze lokalnym bądź na jednym serwerze. Access jest jednak ogólnym narzędziem projektowania baz danych, co sprawia, że może współpracować z różnymi bazami danych. To oznacza, że w jednej bazie danych Accessa można utworzyć formularze i raporty, które pobierają dane z innej bazy danych Accessa, znajdującej się w innym komputerze lub na innym serwerze. Można nawet połączyć bazę danych utworzoną w Accessie z bazą danych utworzoną za pomocą innego narzędzia (np. Oracle, SQL Server).
Rozdział 27. Dostęp do danych za pomocą kodu VBA
845
Rysunek 27.9. Wykorzystanie ADO do aktualizacji tabeli
ADO to interfejs udostępniający dane i umożliwia tworzenie programów operujących na danych lokalnej lub zdalnej bazy danych. Za pośrednictwem ADO można wykonać wszystkie operacje na bazach danych: kwerendy, aktualizacje danych, konwersję typów danych, indeksowanie, blokowanie danych, sprawdzanie poprawności danych, a także obsługę transakcji. Oto fragment procedury, która prezentuje sposób wykorzystania typu Recordset interfejsu ADO w celu otwarcia tabeli: Dim adRs As ADODB.Recordset Set adRs = New ADODB.Recordset adRs.ActiveConnection = CurrentProject.Connection adRs.Source = "tblCustomers" adRs.CursorType = adOpenDynamic adRs.LockType = adLockOptimistic adRs.Open
Obiekt Recordset interfejsu ADO ma metodę Open, która umożliwia wybranie danych z tabeli lub za pomocą kwerendy. Obiekt Recordset to po prostu zbiór rekordów z tabeli bazy danych lub uzyskany w wyniku wykonania kwerendy.
846
Część VII Zaawansowane techniki programowania w Accessie
Metoda Open ma cztery parametry: Source — źródło danych, które ma być otwarte. Może to być nazwa tabeli (tak jak
w tym przykładzie), nazwa kwerendy lub instrukcja SQL-a pobierająca rekordy. Wskazywana tabela może być lokalna lub dołączona. — połączenia z bazą danych. Jest to łącze komunikacyjne do bazy danych. Do łączenia się z aktywną bazą danych w Accessie służy predefiniowane połączenie CurrentProject.Connection.
ActiveConnection
— kursor jest wskaźnikiem lub zbiorem wskaźników do rekordów. Kursor można traktować jak narzędzie do śledzenia rekordów w interfejsie ADO. W zależności od ustawień właściwości związanych z pobieraniem danych kursory ADO mogą poruszać się tylko w przód (adOpenForwardOnly) lub też w przód i wstecz (adOpenDynamic). Kursor dynamiczny (adOpenDynamic) umożliwia poruszanie się w obu kierunkach, natomiast kursor adOpenForwardOnly umożliwia poruszanie się tylko do przodu. Właściwość CursorType opisano szczegółowo w podpunkcie „Właściwość CursorType” we wcześniejszej części rozdziału.
CursorType
— określa sposób blokowania rekordów przez interfejs ADO podczas ich aktualizacji. Wartość adLockOptimistic zezwala innym użytkownikom na pracę z rekordem w czasie, gdy ten jest zablokowany przez kod ADO, natomiast wartość adLockPessimistic podczas wprowadzania zmian w danych rekordu całkowicie blokuje innym użytkownikom dostęp do niego.
LockType
Tę samą instrukcję ADO można zapisać w nieco bardziej zwięzły sposób: Dim adRs As ADODB.Recordset Set adRs = New ADODB.Recordset adRs.Open "tblCustomers", CurrentProject.Connection, _ adOpenDynamic, adLockOptimistic
W tym przykładzie właściwości obiektu Recordset ustawiono wewnątrz instrukcji Open. Obie składnie są prawidłowe, a ich wybór całkowicie zależy od programisty. Ponieważ kod uzyskuje bezpośredni dostęp do tabeli, nie można określić klauzuli ORDER BY. Dlatego kolejność zwracanych danych jest nieznana. Oto inny prosty przykład pobrania pojedynczego rekordu na podstawie wartości pola CustomerID: Dim adRs As ADODB.Recordset Set arRs = New ADODB.Recordset adRs.ActiveConnection = CurrentProject.Connection adRs.Source = _ "SELECT * FROM tblCustomers WHERE CustomerID = 17" adRs.CursorType = adOpenDynamic adRs.LockType = adLockOptimistic adRs.Open
Rozdział 27. Dostęp do danych za pomocą kodu VBA
847
Warto zauważyć, że na rysunku 27.9 nie podano tabeli. Wartością właściwości Source jest instrukcja SELECT SQL-a. Instrukcja użyta tu do pobierania rekordów zwraca pojedynczy rekord na podstawie wartości pola CustomerID. Ponieważ w tym przypadku właściwość LockType ustawiono na wartość adLockOptimistic, użytkownicy mogą modyfikować dane rekordu. Właściwości CursorType i LockType są opcjonalne. Jeśli nie określi się wartości właściwości CursorType i LockType, ADO automatycznie utworzy zbiór rekordów typu adOpenForward Only/adLockReadOnly. Obiekt tego typu nie może być modyfikowany. Aby wprowadzać zmiany w zbiorach rekordów, trzeba poznać różne połączenia wartości właściwości CursorType i LockType oraz ich wpływ na działanie zbioru rekordów. Korzystając z ActiveX Data Objects, prawie zawsze można dokonać odpowiednich operacji na danych, używając tylko obiektu Recordset. Obiekty te są złożone z kolumn i wierszy (podobnie do tabel baz danych). Po otwarciu obiektu można rozpocząć pracę z danymi w wierszach i kolumnach. W tej książce obiekty Recordset stosowane są wielokrotnie. Rekordy zwracane przez kwerendę są udostępniane jako obiekty Recordset. W momencie otwierania tabeli Access zapisuje rekordy tabeli jako obiekty Recordset i wyświetla je w widoku arkusza danych. Użytkownik nigdy nie widzi samych tabel Accessa — widzi tylko reprezentację danych tabeli w postaci obiektu Recordset wyświetlonego w widoku arkusza danych. Otwarcie obiektu Recordset z możliwością modyfikacji — tzn. użycie typu kursora adOpen Dynamic lub adOpenKeySet oraz ustanowienie blokady typu adLockOptimistic — powoduje otwarcie obiektu Recordset w trybie edycji. Istotną różnicą między tabelą otwartą w arkuszu danych a zbiorem rekordów ADO jest to, że zbiór rekordów nie udostępnia wizualnej reprezentacji przechowywanych danych. Arkusz danych obejmuje wiersze i kolumny, a nawet nagłówki kolumn, dzięki którym wiadomo, jakie nazwy mają pola w powiązanej tabeli. Zbiory rekordów w ADO (a także w DAO) istnieją tylko w pamięci. Nie ma łatwego sposobu na zwizualizowanie danych ze zbioru rekordów. Programista musi pamiętać nazwy pól, liczbę wierszy i inne aspekty danych ważne w rozwijanej aplikacji. W trakcie pracy z arkuszami danych i zbiorami rekordów aktywny jest zawsze tylko jeden rekord. W arkuszu danych jest on wyróżniony kolorem. W zbiorach rekordów nie istnieje podobna wskazówka, dlatego trzeba zawsze pamiętać, który rekord jest aktywny. Na szczęście ADO i DAO udostępniają kilka metod śledzenia rekordów w zbiorach, a także techniki do poruszania się po zbiorach. Można też stosunkowo łatwo sprawdzić nazwy pól i zmodyfikować dane przechowywane w poszczególnych polach. W tym i w wielu dalszych rozdziałach przedstawiono liczne techniki zarządzania danymi za pomocą języka VBA. Programista Accessa w trakcie lektury prawie na pewno pozna nowe, skuteczniejsze sposoby pracy z danymi w aplikacjach Accessa. Przed modyfikacją dowolnej wartości w polach obiektu Recordset trzeba się upewnić, że modyfikowana wartość znajduje się w odpowiednim rekordzie. Po otwarciu obiektu Recordset bieżący rekord jest pierwszym rekordem tego obiektu. Jeśli w obiekcie Recordset nie ma żadnych rekordów, właściwość EOF ma wartość True.
848
Część VII Zaawansowane techniki programowania w Accessie Próba wykonania operacji na danych obiektu Recordset, który nie zawiera żadnych rekordów, powoduje błąd działania aplikacji. Bezpośrednio po otwarciu zbioru rekordów koniecznie sprawdź wartość właściwości EOF: Set adRs = new ADODB.Recordset rs.Open "tblCustomers".... itd. If Not adRs.EOF Then 'Można przetwarzać rekordy End If
Błędy występują, gdy kod przejdzie za pozycję EOF (MoveNext) lub przed BOF (MovePrevious). Po wywołaniu metody Move* zawsze należy sprawdzać wartość właściwości EOF lub BOF.
Modyfikacja pola w bieżącym rekordzie obiektu Recordset w ADO wymaga przypisania nowej wartości określonemu polu. W DAO przed przypisaniem nowej wartości należy wywołać metodę Edit obiektu Recordset. W procedurze Form_AfterUpdate, przedstawionej na rysunku 27.9, przypisano wartość pola txtSaleDate formularza frmSales do pola LastSaleDate obiektu Recordset. Po wprowadzeniu modyfikacji w rekordzie należy skorzystać z metody Update obiektu Recordset w celu zatwierdzenia zmian w bazie danych. Metoda Update kopiuje dane z bufora pamięci do obiektu Recordset, powodując zastąpienie rekordu, który był tam wcześniej. Zastępowany jest cały rekord, a nie tylko uaktualniane pola. Operacja ta nie wpływa na pozostałe rekordy ze zbioru. Korzystając z ADO, należy pamiętać, że zmiany są zapisywane automatycznie przy przechodzeniu do kolejnego rekordu bądź przy zamykaniu obiektu Recordset. Dodatkowo zmiany w modyfikowanym rekordzie są zapisywane przy zamykaniu zbioru rekordów i przy wyjściu z procedury, w której zadeklarowano obiekt Recordset (lub nadrzędną baz danych). Mimo to dla poprawienia czytelności kodu warto korzystać z metody Update. W celu anulowania zmian wprowadzonych w obiekcie Recordset w ADO trzeba skorzystać z metody CancelUpdate. Aby anulowanie zmian było możliwe, metodę CancelUpdate należy wywołać przed przejściem do kolejnego rekordu ze zbioru danych ADO. Jest tak, ponieważ przejście do innego rekordu powoduje zatwierdzenie zmian, po czym nie można już ich anulować. Instrukcja rsContacts.Close, znajdująca się na końcu procedury Form_AfterUpdate, służy do zamknięcia obiektu Recordset. Zamykanie tych obiektów po zakończeniu korzystania z nich stanowi dobrą praktykę programistyczną. Należy również zwrócić uwagę na to, że na rysunku 27.9 obiekt Recordset jawnie ustawiono na wartość Nothing (Set rsContacts = Nothing), aby usunąć go z pamięci. Pominięcie tego ważnego etapu może doprowadzić do „wycieków pamięci”, ponieważ obiekty ADO zazwyczaj pozostają w pamięci do czasu, kiedy zostaną jawnie ustawione na wartość Nothing i w ten sposób usunięte.
Aktualizacja pola obliczeniowego w rekordzie W przykładowym formularzu frmSales znajduje się pole txtTaxAmount, w którym znajduje się informacja o wysokości podatku pobieranego od danej transakcji. Wartość kwoty podatku nie jest obliczana na podstawie prostego wyliczenia. Kwota podatku jest ustalana na podstawie następujących danych:
Rozdział 27. Dostęp do danych za pomocą kodu VBA
Sumy wartości zamówionych produktów, które podlegają opodatkowaniu.
Wysokości stawki podatkowej, jaka obowiązuje danego klienta.
Wartości w polu txtOtherAmount, jeśli taka istnieje i podlega opodatkowaniu.
849
Kiedy użytkownik zmieni informacje dotyczące aktualnie realizowanej transakcji, dowolna spośród wymienionych powyżej wartości może wpłynąć na zmianę kwoty podatku. Wartość kwoty podatku musi być wyznaczana ponownie za każdym razem, gdy wystąpi choć jedno z następujących zdarzeń:
dodanie lub modyfikacja pozycji transakcji,
usunięcie pozycji transakcji,
zmiana kupującego na innego klienta,
zmiana strefy opodatkowania (txtTaxLocation),
zmiana wartości w polu txtOtherAmount.
W celu ponownego wyliczenia kwoty podatku w sytuacji, kiedy wystąpi jedno z powyższych zdarzeń, należy skorzystać z procedur VBA. Ponowne wyznaczenie wartości pola przy aktualizacji lub dodaniu nowego rekordu Rysunek 27.10 przedstawia kod źródłowy wykonywany przy wprowadzaniu lub aktualizacji pozycji transakcji na formularzu frmSales. Rysunek 27.10. Ponowne wyznaczenie wartości pola po aktualizacji formularza
Do ponownego obliczania podatku po dodaniu nowej pozycji transakcji lub zmodyfikowaniu takiej pozycji (np. w wyniku zmiany ceny lub liczby produktów) wystarczy jedno zdarzenie. Procedura powinna być wyzwolona zdarzeniem Po aktualizacji podformularza. Zdarzenie Po aktualizacji występuje po dodaniu nowego rekordu albo po aktualizacji istniejącego. Procedura Form_AfterUpdate w podformularzu fsubSalesLineItems jest wykonywana wtedy, gdy nowa pozycja jest wprowadzana w podformularzu albo dokonywana jest zmiana dowolnego z elementów podformularza. Procedura ta ponownie określa wartość
850
Część VII Zaawansowane techniki programowania w Accessie
formantu z kwotą podatku (txtTaxAmount) w formularzu frmSales. Zmienna dTaxRate jest wykorzystana w procedurze do tymczasowego przechowania wartości stawki podatkowej klienta (jest to wartość zapisana w formancie txtTaxRate). Zmienna cTaxAmount jest wykorzystywana do tymczasowego przechowywania wartości zwracanej przez funkcję CalcTax(), która służy do wyznaczenia nowej wartości podatku. Wywołując tę funkcję w procedurze Form_AfterUpdate, trzeba przekazać dwa parametry: wartość zmiennej dTaxRate i numer faktury wprowadzanego elementu (Me.InvoiceNumber). Funkcję CalcTax() pokazano na rysunku 27.11. Rysunek 27.11. W funkcji CalcTax() wykorzystano interfejs ADO do obliczenia podatku
Funkcja CalcTax() korzysta z ADO w celu utworzenia obiektu Recordset używanego do podsumowania wszystkich liczb i cen z tabeli tblSalesLineItems dla bieżącej transakcji. Funkcja otrzymuje dwa argumenty: stawkę podatkową kupującego (dTaxPercent) i numer faktury bieżącej transakcji (lInvoiceNum). Za pomocą interfejsu ADO funkcja sprawdza, czy obiekt Recordset zawiera rekord. Jeśli w obiekcie Recordset znajduje się tylko wartość EOF (koniec pola), obiekt nie zawiera żadnego rekordu, czyli nie odnaleziono żadnego elementu bieżącej transakcji, a zmienna CalcTax ma nadal wartość 0. Jeżeli w obiekcie Recordset znajdują się rekordy, funkcja CalcTax wyznacza zwracaną wartość, mnożąc wartość pola Subtotal przez stawkę opodatkowania (dTaxRate). Na końcu procedury przedstawionej na rysunku 27.12 następuje umieszczenie wyznaczonej wartości (pobranej ze zmiennej cTaxAmount) w zmiennej txtTaxRate. Jeżeli na formularzu frmSales zmienisz wartości w polach Nabywca, Strefa podatkowa albo Stawka podatkowa, wykorzystywane jest zdarzenie Po aktualizacji, które ponownie wyznacza kwotę podatku. Kod źródłowy procedury txtTaxRate_AfterUpdate przedstawiono na rysunku 27.12. Logika zaimplementowana w procedurze txtTaxRate_AfterUpdate jest identyczna do tej, jaką zaimplementowano w procedurze fsubSalesLineItems_AfterUpdate. Ten sam kod można wykorzystać również dla formantów Nabywca i Strefa podatkowa. Jedyna
Rozdział 27. Dostęp do danych za pomocą kodu VBA
851
Rysunek 27.12. Ponowne wyliczanie wartości pola po aktualizacji danych w formancie
różnica pomiędzy kodem z rysunku 27.10 a kodem z rysunku 27.12 polega na tym, że procedura z rysunku 27.10 wykonuje się przy każdej modyfikacji w formularzu do wprowadzania pozycji transakcji, natomiast kod z rysunku 27.12 wykonuje się w przypadku modyfikacji pola txtTaxRate w głównym formularzu. Sprawdzanie statusu usuniętego rekordu Do ponownego wyznaczenia wartości formantu txtTaxAmount po usunięciu pozycji transakcji należy wykorzystać zdarzenie Potwierdzenie po usunięciu. Kod źródłowy odpowiedniej procedury przedstawiono na rysunku 27.13 (jest on podobny do kodu obsługi zdarzenia Po aktualizacji podformularza). Warto przy tym zauważyć, że procedura ustawia pole txtTaxAmount głównego formularza transakcji, choć kod działa dla podformularza fsubSalesLineItems osadzonego w formularzu frmSales. Rysunek 27.13. Ponowne wyznaczenie wartości formantu po usunięciu rekordu
Access zawsze wymaga potwierdzenia operacji usuwania rekordu zainicjowanych przez użytkownika. Za każdym razem wyświetla się okno informacyjne z pytaniem o potwierdzenie usunięcia. Jeśli użytkownik potwierdzi zamiar usunięcia rekordu, następuje usunięcie bieżącego rekordu ze zbioru rekordów formularza i tymczasowe zapisanie go w pamięci po to, by w razie konieczności można było cofnąć operację. Zdarzenie Potwierdzenie po usunięciu występuje po właściwym usunięciu rekordu albo po anulowaniu usunięcia. Jeśli zdarzenie Potwierdzenie przed usunięciem nie zostanie odwołane, to tuż po
852
Część VII Zaawansowane techniki programowania w Accessie
zatwierdzeniu usunięcia rekordu przez użytkownika (w oknie dialogowym) wystąpi zdarzenie Potwierdzenie po usunięciu. Zdarzenie Potwierdzenie po usunięciu występuje także po odwołaniu zdarzenia Potwierdzenie przed usunięciem. Procedura obsługi zdarzenia Potwierdzenie po usunięciu zwraca informację o statusie usunięcia. W tabeli 27.2 przedstawiono możliwe wartości statusu. Tabela 27.2. Status usunięcia Status
Opis
acDeleteOK
Usunięcie przeprowadzone z powodzeniem
acDeleteCancel
Usunięcie anulowane w programie
acDeleteuserCancel
Usunięcie anulowane przez użytkownika
Wewnątrz procedury można ustawić argument Status procedury obsługi zdarzenia Potwierdzenie po usunięciu na dowolną spośród wymienionych powyżej wartości. Na przykład jeśli w wyniku wykonania kodu procedury obsługi zdarzenia Potwierdzenie po usunięciu okaże się, że usunięcie rekordu może spowodować problemy w innym miejscu aplikacji, argument Status należy ustawić na wartość acDeleteCancel. If Then Status = acDeleteCancel Exit Sub Else Status = acDeleteOK End If
Argument Status umożliwia zmianę w kodzie VBA decyzji użytkownika o usunięciu rekordu, gdy warunki upoważniają do takiej zmiany. W przypadku ustawienia argumentu Status na wartość acDeleteCancel następuje odtworzenie w zbiorze rekordów kopii rekordu z tymczasowego bufora i anulowanie procesu usuwania. Jeśli z kolei argument Status zostanie ustawiony na wartość acDeleteOK, proces usuwania będzie kontynuowany, a gdy użytkownik przejdzie do innego rekordu w zbiorze rekordów, nastąpi wyczyszczenie tymczasowego bufora. Eliminowanie powtarzającego się kodu W przykładach z tego podrozdziału pojawiły się trzy procedury zawierające niemal identyczny kod. Gdy będzie trzeba go zmodyfikować, zmiany będą konieczne w procedurach obsługi zdarzeń Form_AfterDelConfirm i Form_AfterUpdate podformularza oraz txtTaxRate_AfterUpdate formularza głównego. Jeśli zmiany będą niespójne lub zapomnisz zmodyfikować kod w jednej z tych procedur, w projekcie pojawią się błędy. Gdy odkryjesz, że piszesz identyczny lub bardzo podobny kod w kilku procedurach obsługi zdarzeń, najlepiej jest przenieść taki kod do modułu standardowego i wywoływać go w tych procedurach. Tu nie wystarczy skopiować kodu do modułu standardowego, ponieważ kod w różnych miejscach jest wprawdzie bardzo podobny, ale nie identyczny. Do poradzenia sobie z różnicami w kodzie (np. sposobem wskazywania formantu txt Tax Rate) trzeba wykorzystać parametry nowej procedury.
Rozdział 27. Dostęp do danych za pomocą kodu VBA
853
Public Sub UpdateTaxRate(frmMain As Form, _ dTaxRate As Double, _ lInvoiceNumber As Long) Dim cTaxAmount As Currency cTaxAmount = CalcTax(dTaxRate, lInvoiceNumber) frmMain.txtTaxAmount.Value = cTaxAmount End Sub
Procedura ta znajduje się w module modSalesFunctions. Zamiast umieszczać podobny kod w trzech procedurach obsługi zdarzeń, można wywoływać w nich nową procedurę. Gdy potrzebne będą zmiany, wystarczy zaktualizować tę jedną procedurę. W poniższym kodzie pokazano, jak procedura ta jest wywoływana w procedurze obsługi zdarzenia Form_AfterUpdate podformularza i procedurze obsługi zdarzenia txtTaxRate_AfterUpdate głównego formularza. Private Sub txtTaxRate_AfterUpdate() UpdateTaxRate Me, CDbl(Nz(Me.txtTaxRate.Value, 0)), _ Me.InvoiceNumber.Value End Sub Private Sub Form_AfterUpdate() UpdateTaxRate Me.Parent, _ CDbl(Nz(Me.Parent.txtTaxRate.Value, 0)), _ Me.InvoiceNumber.Value End Sub
W głównym formularzu przekazywane jest słowo kluczowe Me (oznacza ono sam formularz), natomiast pozostałe parametry są pobierane z formantów. W podformularzu wykorzystano wyrażenie Me.Parent, aby wskazać główny formularz i pobrać z niego potrzebne wartości.
Wstawienie nowego rekordu Dodawanie nowego rekordu za pomocą ADO jest tak samo łatwe jak wcześniej omówiona aktualizacja. Aby wstawić nowy rekord, trzeba skorzystać z metody AddNew. Poniżej przedstawiono procedurę ADO wstawiającą rekord dla nowego klienta w tabeli tblCustomer Contacts z wykorzystaniem tej metody: Private Sub AddNewCustomer(sFirstName As String, sLastName As String) Dim adRs As ADODB.Recordset Set adRs = New ADODB.Recordset adRs.Open "tblCustomerContacts", CurrentProject.Connection, _ adOpenDynamic, adLockOptimistic With adRs
854
Część VII Zaawansowane techniki programowania w Accessie .AddNew 'Dodanie nowego rekordu 'Wprowadzenie danych: .Fields("LastName").Value = sLastName .Fields("FirstName").Value = sFirstName .Update 'Zatwierdzenie zmian End With adRs.Close Set adRs = Nothing End Sub
W powyższym przykładzie widać, że zastosowanie metody AddNew jest bardzo podobne do wykorzystywania ADO w celu edycji obiektu Recordset. Metoda AddNew najpierw tworzy odpowiedni bufor przeznaczony do przechowania wartości nowego rekordu. Po wykonaniu instrukcji AddNew procedura przypisuje wartości poszczególnym polom. Metoda Update dodaje nowy rekord na koniec listy elementów obiektu Recordset oraz do źródłowej tabeli.
Usuwanie rekordu Aby usunąć rekord z tabeli, należy skorzystać z metody Delete ADO. Poniżej przedstawiono kod ADO służący do usunięcia rekordu z tabeli tblCustomerContacts. Private Sub DeleteContact(CustomerID As Long) Dim adRs As ADODB.Recordset Dim sSQL as String Set adRs = New ADODB.Recordset sSQL = "SELECT * FROM tblCustomerContacts " _ & "WHERE ID = " & ContactID & ";" adRs.Open sSQL, CurrentProject.Connection, _ adOpenDynamic, adLockOptimistic With adRs If Not .EOF Then .Delete 'Usunięcie rekordu End If End With adRs.Close Set adRs = Nothing End Sub
Zwróć uwagę na to, że po usunięciu rekordu za pomocą metody Delete nie trzeba używać metody Update. Po wykonaniu metody Delete rekord jest na stałe usuwany z obiektu Recordset.
Rozdział 27. Dostęp do danych za pomocą kodu VBA
855
Usuwanie rekordów za pomocą interfejsu ADO nie powoduje wyświetlenia okna dialogowego z prośbą o potwierdzenie zamiaru usunięcia rekordów. Zmiany wprowadzone za pomocą kodu ADO nie są potwierdzane, ponieważ zakłóciłoby to pracę użytkownika. Dlatego programista odpowiada za to, aby przed usunięciem danych sprawdzić, czy na pewno należy przeprowadzić tę operację. Po usunięciu rekordu nie można anulować zmian w powiązanej tabeli. Access wymusza jednak przestrzeganie więzów integralności. Jeśli usunięcie rekordu narusza więzy integralności, Access zgłasza błąd.
Usuwanie powiązanych rekordów znajdujących się w kilku tabelach Podczas usuwania rekordów za pomocą poleceń ADO trzeba pamiętać o uwzględnieniu zależności (relacji) w aplikacji. Przed usunięciem rekordu trzeba sprawdzić, czy przypadkiem nie wchodzi on w relację jeden do wielu z inną tabelą. Przyjrzyj się schematowi relacji (zobacz rysunek 27.14) dla tabel wykorzystanych na formularzu frmSales. Tabela tblSales jest związana z dwoma tabelami — tblSalesLine Items i tblSalesPayments.
Rysunek 27.14. Sprawdzanie tabel powiązanych relacją jeden do wielu
Okno dialogowe Edytowanie relacji przedstawia relacje pomiędzy tabelami tblSales i tblSalesLineItems. Są to relacje typu jeden do wielu (1:M) z wymuszeniem więzów integralności. Relacja typu jeden do wielu oznacza, że dla każdego rekordu z tabeli nadrzędnej (tblSales) istnieje przynajmniej jeden rekord w tabeli zależnej (tblSalesLineItems). Każdy rekord w tabeli nadrzędnej musi być niepowtarzalny. Nie mogą istnieć dwie transakcje o identycznych wartościach pól InvoiceNumber, SalesDate itd.
856
Część VII Zaawansowane techniki programowania w Accessie
Omówienie relacji między tabelami znajdziesz w rozdziale 4.
W relacji jeden do wielu każdy rekord zależny (z tabeli tblSalesLineItems) musi być powiązany z jednym (i tylko jednym) rekordem z tabeli nadrzędnej (tblSales). Jednak każdy rekord transakcji z tabeli tblSales może być powiązany z większą liczbą rekordów z tabeli tblSalesLineItems. Jeśli włączysz wymuszenie więzów integralności przy relacji jeden do wielu, przekażesz Accessowi informację, że rekord znajdujący się w tabeli tblSales nie może zostać usunięty, jeśli w tabeli tblSalesLineItems znajduje się inny rekord o tym samym numerze faktury. Jeżeli Access napotka żądanie usunięcia rekordu, które narusza więzy integralności, wyświetli komunikat o błędzie i anuluje operację (chyba że w oknie dialogowym Edytowanie relacji włączono kaskadowe usuwanie; zobacz rysunek 27.14). W rozdziale 4. wyjaśniono, że w oknie dialogowym Edytowanie relacji można ustawić opcje Kaskadowo aktualizuj pola pokrewne i Kaskadowo usuń rekordy pokrewne. Domyślnie opcje te są wyłączone — nie bez powodu. Jeśli kaskadowe usuwanie jest włączone, to po uruchomieniu kodu VBA usuwającego rekord transakcji skasowane zostaną też wszystkie powiązane rekordy z tabel tblSalesLineItems i tblSalesPayments. W zależności od sytuacji może to być pożądane lub nie. Jeśli zamówienie jest anulowane, zwykle można usunąć powiązane pozycje. Jednak gdy zamówienie anulowano po dokonaniu płatności, usunięcie historii wpłat klienta może prowadzić do problemów. Nabywcy będą oczekiwać zwrotu zapłaty, jednak Access właśnie usunął informacje o wpłacie. W większości sytuacji najlepiej jest używać pola Aktywny (o typie danych z wartościami Tak i Nie) do określania stanu rekordu nadrzędnego. Pole to ma wartość Tak, jeśli złożono zamówienie. Wartość ta zmienia się na Nie, jeśli zamówienie zostało anulowane lub zrealizowane. Możesz też pomyśleć o dodaniu do tabeli tblSales pola z datą anulowania zamówienia (CancellationDate) i ustawianiu go na dzień wycofania zamówienia. Jeśli pole CancellationDate jest puste, oznacza to, że zamówienia nie anulowano. W trakcie pisania kodu ADO usuwającego rekord trzeba najpierw sprawdzić, czy nie występują relacje jeden do wielu między tabelą zawierającą usuwany rekord a innymi tabelami bazy danych. Jeśli istnieją tabele zależne, najpierw trzeba usunąć umieszczone w nich powiązane rekordy — dopiero wtedy Access zezwoli na usunięcie rekordu z tabeli nadrzędnej. Na szczęście ADO ma odpowiednie polecenia, dzięki którym można jednocześnie usunąć rekordy w tabelach głównych i zależnych określonej relacji. Rysunek 27.15 przedstawia kod źródłowy procedury usuwającej rekord związanej z przyciskiem cmdDelete formularza frmSales. Procedura cmdDelete_Click usuwa te rekordy z tabel tblSalesPayments, tblSalesLineItems i tblSales, które mają numer faktury wyświetlony na formularzu.
Rozdział 27. Dostęp do danych za pomocą kodu VBA
857
Rysunek 27.15. Wykorzystywanie ADO do usunięcia kilku rekordów
Pierwsza instrukcja procedury cmdDelete_Click (If Me.NewRecord Then) korzysta z właściwości NewRecord, aby sprawdzić, czy zawartość wyświetlana na formularzu nie należy do nowego rekordu. Jeśli wyświetlane dane należą do nowego rekordu, wykonywana jest kolejna instrukcja, Me.Undo, której zadaniem jest cofnięcie zmian wprowadzonych w rekordzie. Jeżeli dane na formularzu nie należą do nowego rekordu, na ekranie wyświetlane jest okno dialogowe, w którym użytkownik decyduje, czy zatwierdzić usunięcie. Klikając przycisk Tak, użytkownik zgadza się na usunięcie danych, a procedura kasuje rekord z tabel. W dwóch stałych (sSQL_DELPMTS i sSQL_DELLINE) zapisano instrukcje SQL-a służące do wyszukiwania i usuwania w tabelach tblSalesPayments i tblSalesLineItems rekordów, których numer faktury jest taki sam jak wybrany w formularzu frmSales. Numer faktury jest dodawany na końcu stałych, a cała instrukcja jest przekazywana jako parametr do metody Execute obiektu CurrentDb. Tej metodzie można przekazać argument w formie nazwy kwerendy bądź kodu instrukcji SQL-a. Metoda Execute wykonuje określoną kwerendę lub instrukcję SQL-a. Jeśli kwerenda lub instrukcja SQL-a zawierają klauzulę WHERE, a metoda Execute nie odnajdzie żadnego rekordu spełniającego kryteria tej klauzuli, błąd nie wystąpi. Jeśli jednak instrukcja SQL-a lub kwerenda ma niepoprawną składnię lub błędnie wprowadzoną nazwę pola, w trakcie wykonywania metody Execute wystąpi błąd.
Po zakończeniu usuwania danych z tabel tblSalesPayments i tblSalesLineItems można usunąć rekord z tabeli tblSales.
858
Część VII Zaawansowane techniki programowania w Accessie
Rozdział 28.
Zaawansowany dostęp do danych z wykorzystaniem kodu VBA W tym rozdziale:
Wyszukiwanie rekordów w formularzu za pomocą pola kombi
Wykorzystywanie opcji filtra formularza
Filtrowanie danych z formularza za pomocą kwerend z parametrami
W kilku poprzednich rozdziałach poznałeś podstawy programowania w Accessie, nauczyłeś się korzystać z kilku wbudowanych funkcji VBA i różnych konstrukcji tego języka. Dowiedziałeś się, czym jest DAO i ADO oraz w jaki sposób uzyskać dostęp do danych w tabelach i kwerendach za pomocą obiektów Recordset. Zdobyłeś również wiele informacji na temat formularzy i kwerend. W tym rozdziale wykorzystasz wcześniej nabytą wiedzę i nauczysz się dodatkowo, w jaki sposób wyświetlić wybrane dane w formularzach i raportach, używając technik polegających na wykorzystaniu formularzy, kodu w Visual Basicu i kwerend. W bazie danych Rozdział28.accdb znajduje się zestaw formularzy. Niektóre z nich można wykorzystać jako punkt wyjścia, natomiast inne można wykorzystać do porównania z formularzami zmodyfikowanymi w tym rozdziale. We wszystkich przykładach wykorzystano zmodyfikowaną wersję formularza frmProducts i dane pochodzące z tabeli tblProducts.
860
Część VII Zaawansowane techniki programowania w Accessie
Wyszukiwanie danych w formularzach za pomocą niezwiązanych pól kombi Wyświetlając formularz w Accessie, często trzeba przejrzeć setki lub nawet tysiące rekordów, zanim odnajdzie się poszukiwany właściwy rekord bądź ich grupę. Można by poinstruować użytkowników, aby korzystali z przycisku Znajdź, nauczyć ich wyszukiwania rekordów i tak dalej, ale w ten sposób podważa się celowość tworzenia programowanej aplikacji. Tworząc aplikację, programista chce zwiększyć produktywność jej użytkowników, a nie uczyć ich obsługi Accessa. Na rysunku 28.1 zamieszczono formularz frmProducts z dodatkowym formantem — polem kombi, które nie jest związane z żadnym źródłem. Pole to jest wykorzystywane do wyszukania rekordu w tabeli tblProducts, a następnie wyświetlenia go na formularzu z wykorzystaniem kilku wierszy kodu. W tym rozdziale zaprezentowano kilka sposobów tworzenie pól kombi i korzystania z nich do szybkiego wyszukiwania rekordów w formularzu.
Rysunek 28.1. Formularz frmProductsExample1 zawierający niezwiązane pole kombi
Projekt pola kombi pokazano na rysunku 28.2. Zwróć uwagę na to, że właściwość Źródło formantu nie ma żadnej wartości. Pole kombi nie jest związane z żadnym polem znajdującym się w tabeli — jest wykorzystywane tylko przez formularz. Nie służy natomiast do zmiany danych w używanej bazie. Przedstawione pole kombi zawiera dwie kolumny pobierane przez kwerendę z rysunku 28.3. Pierwsza kolumna, LongDescription, to połączenie pól ModelYear i Description z tabeli tblProducts. Druga kolumna to pole ProductID z tej samej tabeli. Kolumna ProductID jest kolumną związaną pola kombi. Wartość z tej kolumny jest zwracana przez pole kombi po wybraniu danego wiersza. Szerokość drugiej kolumny to 0, co powoduje jej ukrycie po rozwinięciu pola kombi.
Rozdział 28. Zaawansowany dostęp do danych z wykorzystaniem kodu VBA
861
Rysunek 28.2. Arkusz właściwości niezwiązanego pola kombi
Rysunek 28.3. Kwerenda wykorzystana we właściwości Źródło formantu pola kombi cboQuickSearch
W przykładowym kodzie przedstawionym w dalszej części używana jest właściwość cboQuickSearch.Value. Warto pamiętać, że wartością pola kombi jest identyfikator produktu wybranego w tym polu.
Omawiane pole kombi będzie wykorzystywane w kilku przykładach w tym rozdziale. Dalej zapoznasz się ze sposobami wyszukiwania rekordów z wykorzystaniem pola kombi i odpowiedniego kodu źródłowego.
862
Część VII Zaawansowane techniki programowania w Accessie
Wykorzystanie metody FindRecord Zobaczmy, jak działa pole kombi do szybkiego wyszukiwania w formularzu frmProducts Example1. Wybór kategorii produktu za pomocą pola cboQuickSearch wyzwala zdarzenie Po aktualizacji. Kod procedury obsługi tego zdarzenia wyszukuje dane w formularzu, po czym natychmiast wyświetlany jest znaleziony rekord. Metoda FindRecord wyszukuje rekord w zbiorze powiązanym z formularzem. Wykorzystanie polecenia FindRecord w programie jest odpowiednikiem kliknięcia ikony lornetki na wstążce Accessa. W trakcie wyszukiwania informacji w arkuszu danych najpierw należy kliknąć przeszukiwaną kolumnę (np. LastName). Następnie trzeba kliknąć ikonę lornetki na wstążce, aby otworzyć okno dialogowe Znajdowanie i zamienianie, i wprowadzić nazwisko do znalezienia w zbiorze rekordów. Access wie, że ma sprawdzić pole LastName, ponieważ tę kolumnę zaznaczono w arkuszu danych. Po wprowadzeniu Kowalski jako kryterium wyszukiwania Access przeniesie wskaźnik rekordu w arkuszu danych do pierwszego wiersza, w którym pole LastName ma wartość Kowalski. Przy używaniu kodu do przeszukiwania zawartości związanego formularza Accessa te same operacje wykonywane są za pomocą instrukcji języka VBA. Aby utworzyć procedurę zdarzenia Po aktualizacji pola kombi, wykonaj następujące czynności: 1. Otwórz formularz frmProductsExample1 w widoku projektu, kliknij pole cboQuickSearch i wyświetl okno właściwości (wciśnij F4). 2. Wybierz zakładkę Zdarzenie, a następnie kliknij zdarzenie Po aktualizacji. 3. Kliknij strzałkę pola kombi właściwości Po aktualizacji i wybierz [Procedura Zdarzenia]. 4. Kliknij przycisk kreatora kodu znajdujący się z prawej strony pola. Na ekranie wyświetli się procedura obsługi zdarzenia w osobnym oknie kodu VBA. Szkielet procedury obsługi zdarzenia (Private Sub cboQuickSearch_ AfterUpdate()...End Sub) utworzy się automatycznie w module z kodem formularza. Jak dowiedziałeś się wcześniej, w przypadku tworzenia procedury zdarzenia nazwa formantu i zdarzenia tworzą nazwę procedury. 5. Wpisz cztery wiersze kodu zamieszczone na rysunku 28.4. Rysunek 28.4. Wykorzystanie metody FindRecord do wyszukiwania rekordu
Rozdział 28. Zaawansowany dostęp do danych z wykorzystaniem kodu VBA
863
Pierwszy wiersz sprawdza, czy formant cboQuickSearch zawiera wartość (jest różny od Null). Jeśli formant jest pusty, program przechodzi do instrukcji End If i pomija wyszukiwanie. Jeżeli w formancie znajduje się wartość, wykonywany jest kod z bloku If. Rozpoczyna się on od następującej instrukcji: Me.txtProductID.SetFocus
Powyższa instrukcja przenosi kursor do formantu txtProductID. Tak jak trzeba ręcznie przemieścić kursor do kolumny w arkuszu danych w celu skorzystania z ikony Znajdź na wstążce Accessa, tak również w programie należy umieścić kursor w formancie. W tym przypadku kursor przenoszony jest do formantu zawierającego wartość ProductID, ponieważ operacja wyszukiwania będzie dotyczyła określonej wartości pola ProductID ze zbioru rekordów powiązanego z formularzem. Kolejna instrukcja w bloku If ma następującą postać: DoCmd.FindRecord Me.cboQuickSearch.Value
Metoda FindRecord wykorzystuje tu wartość z pola kombi (wartość pola ProductID) do wyszukania rekordu wybranego produktu. Access dopasowuje wartość formantu cboQuick Search do wartości pola ProductID ze zbioru rekordów powiązanego z formularzem. Pierwsza wartość, jaką znajduje metoda FindRecord, zależy od kilku parametrów, między innymi od wielkości liter, a także od kierunku wyszukiwania (do przodu, wstecz). Aby zobaczyć wszystkie możliwe opcje, należy w oknie edytora Visual Basica wpisać polecenie DoCmd.FindRecord i wcisnąć spację. Metoda FindRecord zawsze zwraca jeden rekord, ale umożliwia przeglądanie wielu rekordów.
Wykorzystywanie zakładek Metoda FindRecord jest przeznaczona do wyszukiwania rekordów, gdy wykorzystywany formant znajduje się na formularzu. Jest również odpowiednią metodą do lokalizowania pojedynczych wartości. Jednak w trakcie tworzenia aplikacji wielokrotnie trzeba wyszukiwać rekordy na podstawie wartości kilku pól. Inny sposób wyszukiwania rekordów polega na wykorzystaniu zakładek (właściwości Bookmark). W tym przykładzie wykorzystano formularz frmProductsExample2. Na rysunku 28.5 przedstawiono kod w procedurze zdarzenia Po aktualizacji (After Update) pola kombi. W kodzie tym wykorzystano właściwość Bookmark do znalezienia w zbiorze rekordów formularza rekordu pasującego do kryteriów wyszukiwania. Oto kilka pierwszych wierszy kodu: Dim rsClone As DAO.Recordset Dim sCriteria As String Const sSEARCHFLD As String = "[ProductID]" If Not IsNull(Me.cboQuickSearch.Value) Then Set rsClone = Me.RecordsetClone
864
Część VII Zaawansowane techniki programowania w Accessie
Rysunek 28.5. Wykorzystanie właściwości Bookmark i RecordsetClone do odnalezienia rekordu
W pierwszych trzech wierszach deklarowany jest obiekt Recordset o nazwie rsClone, zmienna tekstowa sCriteria i stała sSEARCHFLD, do której przypisywana jest nazwa przeszukiwanego pola. Elementy te będą wykorzystane w dalszej części kodu. Dalej procedura kończy pracę, jeśli pole cboQuickSearch ma wartość Null. Wartość ta oznacza, że użytkownik nie wybrał w polu kombi żadnego elementu. W następnej instrukcji obiekt Recordset ustawiany jest na kopię związanego zbioru rekordów formularza (za pomocą właściwości RecordsetClone). Właściwość RecordsetClone (czyli „kopia zbioru rekordów”) działa dokładnie tak, jak wskazuje na to jej nazwa. Tworzy w pamięci kopię zbioru rekordów formularza, którą można wykorzystać do wyszukiwania rekordów. Użycie w trakcie wyszukiwania pierwotnego zbioru rekordów związanego z formularzem sprawia, że bieżący rekord wyświetlany w formularzu się zmienia. W takiej sytuacji brak szukanego rekordu w zbiorze związanym z formularzem powoduje przejście do ostatniego rekordu, co może zmylić użytkowników. Metoda FindFirst obiektu Recordset wymaga podania ciągu zawierającego kryteria wyszukiwania wewnątrz zbioru rekordów (tak, to prawda — na podstawie określonych danych programista żąda od właściwości RecordsetClone wyszukania w zbiorze rekordów określonego rekordu). Ciąg zawierający kryteria wyszukiwania może być dowolnie skomplikowany. Poniższa instrukcja scala człon [ProductID] (zapisany w stałej) ze znakiem równości i wartością formantu cboQuickSearch. sCriteria = sSEARCHFLD & " = " & Me.cboQuickSearch.Value
Rozdział 28. Zaawansowany dostęp do danych z wykorzystaniem kodu VBA
865
Program dodaje do ciągu wartość Me.cboQuickSearch.Value. Przy założeniu, że formant cboQuickSearch ma wartość 17, ciąg z kryteriami ma teraz następującą postać: [ProductID] = 17
Ciąg z kryteriami jest poprawny, ponieważ ProductID to pole liczbowe. Pola tekstowe wymagają dodania cudzysłowów wokół wartości. Oto przykład: sCriteria = sSEARCHFLD & " = '" & Me.cboQuickSearch.Value & "'"
Wtedy kryteria wyglądałyby tak: [ProductID] = '17'
W tym przykładzie programista ma dużą kontrolę nad łańcuchem znaków z kryteriami, ponieważ wykorzystano wartość z pola kombi. W innych sytuacjach fragmenty takiego łańcucha znaków mogą pochodzić z pola tekstowego, w którym użytkownicy mogą wprowadzić niemal dowolne dane. Jeśli na przykład użytkownik wpisze apostrof w polu tekstowym, powstanie zagnieżdżony apostrof (czyli apostrof w łańcuchu znaków ujętym w cudzysłów lub apostrofy). Na szczęście można łatwo uniknąć zagnieżdżonych apostrofów. Jeśli chcesz, aby apostrof pojawił się w łańcuchu znaków ujętym w apostrofy, wpisz dwa apostrofy. W celu znalezienia nazwiska O’Mally zastosuj następujące kryterium: sCriteria = [LastName] = 'O''Mally'
W momencie przetwarzania łańcucha znaków z kryteriami dwa apostrofy w członie O''Mally są przekształcane na jeden. Aby zastosować tę technikę dla pola tekstowego, zastosuj funkcję Replace i zastąp jeden apostrof dwoma: sCriteria = "[LastName] = " & Replace(Me.txtLastName, String(1, "'"), String(2,
"'")) Tworzenie kryteriów wyszukiwania w kodzie jest czasem skomplikowane. Należy pamiętać, że celem jest zbudowanie ciągu, który można skopiować do edytora SQL-a i uruchomić. Najlepszym sposobem często jest zaprojektowanie odpowiedniej kwerendy, wyświetlenie jej w widoku SQL, a następnie skopiowanie do edytora z kodem VBA. Następnie wystarczy wprowadzić nazwy pól i formantów odpowiadające klauzuli WHERE, nie zapominając o łącznikach łańcuchów tekstowych oraz ogranicznikach wokół łańcuchów i dat.
Po wprowadzeniu odpowiedniego kryterium wyszukiwania można skorzystać z metody FindFirst do odnalezienia poszukiwanego rekordu we właściwości RecordsetClone. W poniższej instrukcji wykorzystano metodę FindFirst obiektu Recordset, przekazując jako parametr wcześniej utworzone kryterium. rsClone.FindFirst sCriteria
Nie trzeba tworzyć zmiennej sCriteria i przypisywać do niej ciągu z kryteriami — można odpowiednie kryterium podać bezpośrednio w wywołaniu metody rsClone.FindFirst, np.: rsClone.FindFirst "ProductID = " & Me.cboQuickSearch.Value
W przypadku bardziej złożonych wyrażeń lepiej korzystać ze zmiennych dodatkowych przechowujących odpowiednie łańcuchy tekstowe. Dzięki nim można osobno testować poszczególne części ciągu kryteriów w edytorze kwerend.
866
Część VII Zaawansowane techniki programowania w Accessie
Dalsze instrukcje służą do sprawdzenia, czy wskaźnik rekordu w formularzu należy przesunąć na kolejną pozycję. Zwróć uwagę na właściwość Bookmark (zakładkę) wykorzystaną w poniższym bloku kodu. Zakładka to nic innego, jak wskaźnik rekordu w zbiorze rekordów. Metoda FindFirst ustawia zakładkę obiektu Recordset na znalezionym rekordzie. If Not rsClone.NoMatch Then Me.Bookmark = rsClone.Bookmark End If
Jeśli nie znaleziono rekordu, właściwość NoMatch zbioru rekordów ma wartość True. Ponieważ program ma ustawić zakładkę w przypadku znalezienia rekordu, potrzebny jest komputerowy odpowiednik podwójnego przeczenia. Instrukcję można zinterpretować jako zdanie: „jeśli nieprawdą jest, że nie znaleziono rekordu, to należy ustawić zakładkę”. Dlaczego projektanci w firmie Microsoft zdecydowali się na implementację metody NoMatch zamiast Match (co uprościłoby logikę do instrukcji postaci If rsClone.Match Then...), pozostanie tajemnicą dla wszystkich. Jeśli odnaleziony rekord pasuje do uprzednio zdefiniowanego kryterium, zakładka formularza (właściwość Me.Bookmark) jest ustawiana na zakładce obiektu Recordset (rsClone. Bookmark), a w formularzu wyświetla się znaleziony rekord. Nie jest to filtrowanie rekordów, a jedynie ustawienie zakładki formularza na pierwszym rekordzie spełniającym kryteria. Wszystkie pozostałe rekordy w formularzu nadal są widoczne. Ostatnie wiersze kodu źródłowego zamykają i usuwają obiekt Recordset. Kryteria wyszukiwania mogą być dowolnie skomplikowane, mogą wykorzystywać wiele pól i różne typy danych. Należy pamiętać, aby poszczególne łańcuchy oddzielić za pomocą apostrofów (nie cudzysłowów, ponieważ służą one do otaczania całych ciągów znaków), a daty — przy użyciu kratki (#). Wartości liczbowych nie trzeba wyróżniać.
Zaleca się używanie sposobu z wykorzystaniem metody FindFirst i właściwości Bookmark zamiast metody FindRecord, ponieważ w ten sposób można wprowadzać bardziej złożone kryteria, a formant wykorzystywany do wyszukiwania nie musi być widoczny. Aby skorzystać z metody FindFirst, nie trzeba ustawiać kursora w formancie, według którego program ma przeprowadzić wyszukiwanie. Zbiór rekordów utworzony na podstawie właściwości RecordsetClone formularza to zbiór z modelu DAO. Tylko zbiory rekordów z modelu DAO obsługują metody FindFirst, FindLast, FindNext i FindPrevious. Nie ma powodu, dla którego Microsoft miałby modyfikować formularze (a także raporty) Accessa pod kątem wykorzystania zbiorów rekordów z modelu ADO. Model DAO doskonale się sprawdza przy korzystaniu ze związanych formularzy i raportów.
Filtrowanie danych formularza Chociaż metody FindRecord oraz FindFirst umożliwiają szybkie odnalezienie rekordu spełniającego odpowiednie kryteria, po odnalezieniu właściwego rekordu pozostałe nadal są widoczne, a rekordy spełniające kryteria niekoniecznie są wyświetlane razem. Dzięki za-
Rozdział 28. Zaawansowany dostęp do danych z wykorzystaniem kodu VBA
867
stosowaniu odpowiedniego filtru można ukryć niepożądane informacje, wyświetlając tylko dane odnalezionego rekordu (lub zbioru rekordów). Filtry należy stosować w przypadku, gdy w aplikacji występują duże zbiory rekordów, a użytkownik chce przeglądać tylko ich podzbiór — rekordy spełniające podane kryteria. Do filtrowania formularza można wykorzystać kod lub kwerendę. W tym miejscu opisano oba te podejścia.
Filtrowanie za pomocą kodu Na rysunku 28.6 zamieszczono dwa wiersze kodu potrzebnego do utworzenia i zastosowania filtru do zbioru rekordów formularza. Każdy formularz ma właściwość Filtr, która pozwala określić sposób filtrowania powiązanych rekordów. Domyślnie właściwość Filtr jest pusta, co oznacza, że w formularzu nie stosuje się filtru (wyświetlają się wszystkie rekordy). Rysunek 28.6. Kod służący do włączania i wyłączania filtru zdefiniowanego w formularzu
W pierwszym wierszu kodu ustawiono właściwość Filter: Me.Filter = "ProductID = " & Me.cboQuickSearch.Value
Zwróć uwagę, że wykorzystano w niej dokładnie ten sam ciąg, który przekazano jako kryteria do metody FindFirst obiektu Recordset. Drugi wiersz kodu (Me.FilterOn = True) włącza filtr. Za pomocą właściwości Filtr można wprowadzić dowolne kryteria filtrowania, ale jeśli jawnie nie ustawi się właściwości FilterOn na wartość True, filtr nie będzie zastosowany do zestawu rekordów formularza. Filtr ukrywa wszystkie rekordy, które nie spełniają kryteriów. Wyświetla tylko te, które spełniają warunki filtru. Me.FilterOn = True
Jeśli włączy się filtr, należy także zadbać o możliwość jego wyłączenia. Obok pola kombi na formularzu frmProductsExample1 znajduje się niewielki przycisk (cmdClear Filter), który będzie wykorzystywany do wyłączania filtru oraz ustawiania właściwości
868
Część VII Zaawansowane techniki programowania w Accessie
Filtr formularza na pusty ciąg znaków (vbNullString). Druga z procedur widocznych na rysunku 28.6 to procedura obsługi zdarzenia Click wspomnianego przycisku: Private Sub cmdClearFilter_Click() Me.Filter = vbNullString Me.FilterOn = False Me.cboQuickSearch.Value = Null End Sub
Jeśli utworzysz filtr formularza, a następnie zapiszesz formularz w widoku projektu z ustawieniami tego filtra, to filtr również będzie zapisany. Po ponownym otwarciu formularza filtr będzie aktywny. Przed zapisaniem formularza należy pamiętać o wyczyszczeniu jego właściwości Filtr. Poniższy kod usuwa filtr za pomocą procedury zdarzenia Close formularza: Private Sub Form_Close() Me.Filter = vbNullString Me.FilterOn = False End Sub
Oprócz wiersza czyszczącego zawartość pola kombi kod jest identyczny z kodem z procedury cmdClearFilter_Click. Aby baza kodu była bardziej przejrzysta, warto przenieść powtarzający się kod do odrębnej procedury. Dwie procedury zdarzeń i nową procedurę z powtarzającym się kodem przedstawiamy poniżej: Private Sub cmdClearFilter_Click() ResetFilter Me.cboQuickSearch.Value = Null End Sub Private Sub Form_Close() ResetFilter End Sub Private Sub ResetFilter() Me.Filter = vbNullString Me.FilterOn = False End Sub
Teraz obie procedury nie zawierają powtarzającego się kodu — w zamian wywołują procedurę ResetFilter.
Wykorzystanie kwerend Może się zdarzyć, że w tworzonej aplikacji jeden formularz będzie kontrolował zawartość innego formularza. Czasami trzeba wyświetlić wybrane dane na podstawie decyzji podjętej przez użytkownika. Na przykład po uruchomieniu raportu na ekranie wyświetla
Rozdział 28. Zaawansowany dostęp do danych z wykorzystaniem kodu VBA
869
się okno dialogowe, w którym użytkownik podaje kilka dat albo wybiera produkt bądź klienta. Jednym z rozwiązań przedstawionych problemów jest zastosowanie kwerendy z parametrami. Tworzenie kwerend z parametrami Kwerenda z parametrami to kwerenda zawierająca kryteria, w których wykorzystuje się zmienną, funkcję bądź formant formularza. W standardowej kwerendzie w obszarze definiowania kryteriów wpisuje się konkretne wartości (np. Kochanowski, 26, 01-161978). Można również wprowadzić prośbę (np. [Podaj nazwisko]) lub użyć formantu (np. Forms!frmProducts![cboQuickFind]). W bazie danych Rozdział28.accdb znajduje się kwerenda z parametrami o nazwie qryProductParameterQuery. Najprostszym sposobem zbudowania kwerendy parametrycznej jest utworzenie zwykłej kwerendy wybierającej, do której wystarczy dodać odpowiednie kryteria i uruchomić, aby sprawdzić, czy działa poprawnie. Następnie należy zmienić kryteria na następującą postać: Like [] & "*"
lub: Like "*" & [] & "*"
gdzie określa pytanie, jakie program ma wyświetlić użytkownikowi. Na rysunku 28.7 pokazano kwerendę z parametrami, w której wyświetla się prośba do użytkownika o wprowadzenie kategorii produktu. Rysunek 28.7. Tworzenie prostej kwerendy z parametrami
Po każdym uruchomieniu kwerendy użytkownik musi w oknie dialogowym podać wartość parametru, niezależnie od tego, czy kwerenda jest wykorzystywana jako źródło rekordów na formularzu, w raporcie czy też jako źródło danych dla listy albo pola kombi. W zależności od wprowadzonych kryteriów zwracane wyniki są filtrowane. Na rysunku 28.8 pokazano otwarte okno dialogowe z prośbą o wprowadzenie parametru — kategorii produktów.
870
Część VII Zaawansowane techniki programowania w Accessie
Rysunek 28.8. Uruchamianie kwerendy z parametrami
W poprzednich rozdziałach opisano, że operator Like pozwala na wyszukiwanie danych z wykorzystaniem symboli wieloznacznych. Na przykład aby odfiltrować rekordy zwracane przez kwerendę w taki sposób, by wyświetliły się wszystkie rekordy, których kategoria rozpoczyna się od ciągu Osobowe (lub OSOBOWE) w oknie dialogowym Wprowadzanie wartości parametru, należy wpisać Osobowe. Bez wykorzystywania parametrów ciąg Like Osobowe* należałoby umieścić jako kryterium kwerendy. Ponieważ symbol wieloznaczny (*) jest częścią parametru, użytkownicy nie muszą go wprowadzać przy okazji odpowiedzi na pytanie wyświetlające się w oknie dialogowym. Symbole wieloznaczne * (dowolna liczba znaków) i ? (dowolny znak) można wykorzystywać z operatorem Like we wszystkich kwerendach i instrukcjach SQL-a. Jeśli wybrana jest opcja Składnia zgodne z programem SQL Server (ANSI 92) (Plik/Opcje i zakładka Projektanci obiektu) lub gdy do uruchamiania instrukcji SQL-a używana jest składnia ADO, symbolami wieloznacznymi są % (dowolne znaki w danym miejscu) i _ (jeden znak na danej pozycji).
Skutkiem dodania gwiazdki do parametru jest to, że jeśli użytkownik nie wprowadzi żadnej wartości, za kryterium przyjęty zostanie ciąg "LIKE *", a kwerenda zwróci wszystkie rekordy. Jeżeli usuniesz gwiazdkę z wyrażenia generującego kryterium i użytkownik nie poda kategorii produktu, kwerenda nie zwróci żadnych rekordów. Na rysunku 28.9 pokazano okno dialogowe Parametry kwerendy (aby je otworzyć, należy kliknąć prawym przyciskiem myszy w górnym obszarze okna projektu kwerendy i z menu podręcznego wybrać polecenie Parametry). Okno Parametry kwerendy służy do wprowadzania parametrów wymagających specjalnego formatowania, np. wpisów typu data/godzina lub specjalnie formatowanych liczb. W celu zaprezentowania działania okna Parametry kwerendy umieszczono w nim jeden zapis. Należy wpisać tekst parametru, a następnie wybrać dla niego typ danych.
Rozdział 28. Zaawansowany dostęp do danych z wykorzystaniem kodu VBA
871
Rysunek 28.9. Okno dialogowe Parametry kwerendy
Aby wprowadzić bardziej złożone parametry, na przykład serię dat, można skorzystać z wyrażenia postaci Between [Podaj datę początkową] and [Podaj datę końcową] w polu Kryterium pola typu Data/Godzina. Po uruchomieniu kwerendy na ekranie wyświetli się najpierw okno z prośbą o podanie daty początkowej, a następnie drugie okno dla daty końcowej. Po podaniu tych parametrów kwerenda odpowiednio odfiltruje dane.
Niestety, w kwerendach z parametrami w Accessie nie można podać domyślnych wartości parametrów. Najlepiej jest zawsze umieszczać gwiazdkę w wyrażeniu generującym kryteria. Dzięki temu gdy użytkownik zamknie okno dialogowe na parametry bez wprowadzania wartości, kwerenda zwróci wszystkie rekordy, ponieważ wyrażenie przyjmie postać LIKE "*". Konstrukcję LIKE "*" można stosować tylko dla pól tekstowych. Dla pól liczbowych można tworzyć kryteria w formie [pytanie] OR ([pytanie] IS NULL). Trzeba przy tym pamiętać, aby oba wystąpienia członu pytanie były identyczne (dobrym rozwiązaniem jest ich skopiowanie). Technikę tę można zastosować także dla pól tekstowych, aby zwracane były wszystkie rekordy — także te o wartości Null.
Tworzenie interaktywnego okna dialogowego na potrzeby filtrowania Problem z kwerendami z parametrami polega na tym, że nadają się one tylko do wprowadzania prostych kryteriów. Użytkownicy muszą dokładnie wiedzieć, co mają wprowadzić w oknie dialogowym na parametry. Jeśli podane parametry będą błędne, użytkownicy nie zobaczą oczekiwanych wyników. Ponadto bardzo trudno wykorzystać kwerendy z parametrami do wprowadzania złożonych kryteriów. Zamiast z kwerendy z parametrami lepiej czasem skorzystać z prostego formularza zawierającego formanty, których wartości będą przekazywane do kwerendy. Kwerenda wykorzystuje wtedy formanty formularza do określenia wartości parametrów. Jest to ważna zaleta dla użytkowników, ponieważ formanty mogą im pomagać w podawaniu kryteriów, na przykład wyświetlając listy lub menu rozwijane z akceptowalnymi wartościami pa-
872
Część VII Zaawansowane techniki programowania w Accessie
rametrów. Ponadto do zdarzenia Po aktualizacji każdego formantu można dodać kod do sprawdzania poprawności danych od użytkowników. Pozwala to zapewnić, że kwerenda zadziała. Zawartość formantów w rodzaju pól kombi i list może zmieniać się dynamicznie oraz obejmować wartości z używanych tabel. Oznacza to, że w formantach służących do określania kryteriów mogą się znajdować na przykład nazwiska klientów, którzy złożyli zamówienia, lub kategorie produktów dostępne obecnie w bazie. Na rysunku 28.10 pokazano formularz frmFilterProducts w widoku projektu. Pole cbo Category jest tu zapełniane danymi z kwerendy qryCategories, która sortuje rekordy z tabeli tblCategories w porządku alfabetycznym. Rysunek 28.10. Tworzenie okna dialogowego do wybierania rekordów
Właściwość Wartość domyślna pola cboCategory ma wartość Osobowe, ponieważ jest to najczęściej używane kryterium dla formularza produktów. Właściwość Ogranicz do listy ustawiono na wartość Tak, gdyż użytkownicy mają wybierać opcje tylko spośród kategorii dostępnych w tabeli tblCategories. Na rysunku 28.11 przedstawiono kwerendę qryProducts_FormParameter. Pobiera ona wszystkie pola z tabeli tblProducts na podstawie kategorii z pola cboCategory formularza frmFilterProducts. Zwróć uwagę na wyrażenie generujące kryteria użyte w kolumnie Category. = [Forms]![frmFilterProducts]![cboCategory]
Rysunek 28.11. Tworzenie kwerend zawierających odwołania do formantów formularza
Rozdział 28. Zaawansowany dostęp do danych z wykorzystaniem kodu VBA
873
Kwerenda po uruchomieniu pobiera automatycznie kryteria z pola cboCategory. Pole kombi zwraca wartość Osobowe, jeśli użytkownik nie wybrał innej kategorii. Standardowo użytkownik wybiera kategorię produktów z formularza frmFilterProducts i klika przycisk OK. Kod tego przycisku otwiera formularz frmProductsExample4 powiązany z kwerendą qryProducts_FormParameter. Jako kryterium dla pola Category w kwerendzie qryProducts_FormParameter używana jest wartość wybrana w polu cboCategory formularza frmFilterProducts. Następnie w niemal magiczny sposób otwiera się formularz frmProductsExample4 wyświetlający produkty z wybranej wcześniej kategorii. Jedyny problem, z którym muszą się zmierzyć programiści używający ściśle zintegrowanych obiektów bazy danych (tu są to obiekty frmFilterProducts, qryProducts_Form Parameter i frmProductsExample4), dotyczy tego, że nie jest oczywiste, iż poszczególne obiekty współdziałają ze sobą. Usunięcie lub zmodyfikowanie obiektów może naruszyć przebieg pracy lub narazić użytkowników na problemy. Możesz zastosować nazwy wskazujące na powiązania między oboma formularzami i kwerendą, np. podać te same nazwy, ale z innymi przedrostkami. Inna możliwość to wykorzystanie niestandardowych grup w okienku nawigacji Accessa i dodanie wszystkich obiektów do jednej grupy. Bardzo często rozwiązania oczywiste dla projektanta i programisty danej aplikacji mogą być mniej zrozumiałe dla innych osób. Dlatego warto wykorzystać proste techniki, które pomagają udokumentować aplikacje. Uruchomienie kwerendy qryProducts_FormParameter w czasie, gdy formularz frmFilterProducts nie jest otwarty, spowoduje, że kwerenda wyświetli użytkownikowi prośbę o wprowadzenie wartości. Gdy formularz frmFilterProducts jest zamknięty, Access nie potrafi ustalić znaczenia kryterium [Forms]![frmFilterProducts] ![cbCategory], ponieważ w programie nie ma wczytanego formularza o nazwie frmFilterProducts. W takiej sytuacji Access przyjmuje, że parametr ma pochodzić z odpowiedzi użytkownika na pytanie, dlatego wyświetla okno na dane wejściowe.
Łączenie okna dialogowego z innym formularzem Okno dialogowe frmFilterProducts (zobacz rysunek 28.10) wykonuje więcej działań niż tylko utworzenie wartości, do której można się odwołać w kwerendzie. Formularz ten zawiera kod, który otwiera formularz frmProductsExample4. Rysunek 28.12 przedstawia procedury obsługi zdarzeń cmdCancel_Click oraz cmdOK_Click odpowiadające przyciskom Anuluj i OK na formularzu frmFilterProducts. Kod procedury obsługi zdarzenia cmdOK_Click otwiera formularz frmProductsExample4, do którego następnie przenoszony jest fokus, po czym Access ponownie wykonuje kwerendę (aby skorzystać z danych ostatnio wprowadzonych przez użytkownika). Wykonanie metody SetFocus jest konieczne po to, by przenieść fokus do otwartego formularza. Wykonanie metody Requery nie jest niezbędne, ponieważ formularz po otwarciu automatycznie wykonuje kwerendę, która jest jego źródłem rekordów. Gdyby jednak formularz otwarto już wcześniej, a potem użyto okna dialogowego w celu wyszukania dodatkowego rekordu, wykonanie polecenia Requery byłoby konieczne.
874
Część VII Zaawansowane techniki programowania w Accessie
Choć w formularzu frmFilterProducts tego nie zrobiono, w procedurze zdarzenia cmdOK_ Click można umieścić instrukcję DoCmd.Close, aby zamknąć okno dialogowe po otwarciu formularza frmProductsExample4. Można też zachować otwarte okno dialogowe, aby ułatwić użytkownikowi wybór innej kategorii produktów. Używanie słowa kluczowego With Słowo kluczowe With pozwala przyspieszyć pracę kodu, ponieważ nie trzeba odwoływać się jawnie (bezpośrednio) do odpowiedniego elementu (np. Forms!frmProductsExample4.SetFocus). Bezpośrednie odwołanie się do formantu wymusza na Accessie przeszukanie przy każdym odwołaniu całej bazy danych (w porządku alfabetycznym) w celu odnalezienia odpowiedniego formularza. Jeśli w aplikacji jest ponad 500 różnych formularzy (a w rozbudowanych aplikacjach może ich być jeszcze więcej), odnalezienie tego, którego nazwa rozpoczyna się na przykład na literę „z” zajmie sporo czasu. Ponieważ wykorzystywanych jest więcej niż jedno odwołanie do formularza, cały proces zachodzi wielokrotnie. Po odnalezieniu właściwego formularza polecenie With ustawia na nim wewnętrzny wskaźnik. Dzięki temu wszystkie kolejne odwołania do formantu lub właściwości formularza, a także wywołania metod formularza (np. Requery lub SetFocus) działają znacznie szybciej. Po poleceniu With można wskazać pożądany element za pomocą kropki (.) lub wykrzyknika (!). Dzięki temu można wskazać formant, właściwość lub metodę w taki sposób, jakby poprzedzał je człon Forms!NazwaFormularza. Przykład pokazano na rysunku 28.12. Każdej instrukcji With musi odpowiadać jej zakończenie End With.
Rozdział 29.
Integrowanie baz SQL Server i Access W tym rozdziale:
Typy danych w bazach SQL Server
Instalowanie serwera SQL Server Express
Dołączanie tabel bazy SQL Server
Dostęp do baz SQL Server za pomocą ADO
Obiekty bazodanowe w bazach SQL Server
Microsoft coraz częściej traktuje Accessa jak interfejs do danych z baz SQL Server. SQL Server jest flagowym silnikiem bazodanowym dla korporacji, używanym do sterowania ważnymi aplikacjami w tysiącach firm z całego świata. Z uwagi na wysoką skalowalność, odporność na błędy, rejestrowanie transakcji i inne funkcje SQL Server często pełni funkcję hurtowni lub magazynu danych dla dużych witryn internetowych i jest wykorzystywany w analityce biznesowej. W zależności od instalacji SQL Server potrafi jednocześnie obsługiwać do wielu tysięcy użytkowników. Dla baz SQL Server aplikacja Accessa żądająca danych to tylko następny użytkownik, traktowany tak samo jak inni klienci. W tym rozdziale wykorzystano bazę danych o nazwie Rozdział29.accdb. Jeżeli nie została ona jeszcze skopiowana na dysk komputera, należy to zrobić teraz. Tabele połączone z bazy Rozdział29.accdb w pierwotnej wersji będą działały tylko wtedy, gdy konfiguracja Twojego komputera będzie taka sama jak opisana w rozdziale. Bazy danych z tabelami połączonymi zwykle nie działają po przeniesieniu na inny komputer. W rozdziale 7. znajdziesz szczegółowe omówienie tabel połączonych i technik zarządzania takimi tabelami. SQL Server Express jest darmową aplikacją Microsoftu (www.microsoft.com/ sqlserver/en/us/editions/2012-editions/express.aspx). Jeśli nie masz dostępu do wersji SQL Server Enterprise, możesz wykorzystać edycję Express jako deweloperski i produkcyjny serwer bazodanowy dla aplikacji Accessa.
876
Część VII Zaawansowane techniki programowania w Accessie
Pobieranie programu SQL Server Express Firma Microsoft jest niezwykle zainteresowana tym, by programiści poznawali bazy danych SQL Server i korzystali z nich. Ale prawda jest taka, że zdobycie i instalowanie „pełnej” wersji serwera SQL Server może być bardzo zniechęcające. Jako aplikacja serwerowa SQL Server jest stosunkowo drogi i ma duże wymagania sprzętowe. Ale nie ma się czym martwić! Microsoft udostępnił dla każdego wspaniały prezent do pobrania z internetu za darmo. SQL Server Express to nieco uproszczona wersja bazy SQL Server, przeznaczona do użytku jako silnik bazodanowy w aplikacjach dla małych grup roboczych i jako platforma testowa dla programistów pracujących nad frontonami dla baz SQL Server. Wersję SQL Server Express można bezpłatnie pobrać i zainstalować, korzystać z niej na własnym komputerze, a nawet dołączać do aplikacji udostępnianych użytkownikom. SQL Server Express działa i zachowuje się dokładnie tak samo jak wersja SQL Server Enterprise, jej większy brat. SQL Server Express obsługuje te same typy danych, procedury składowane, wyzwalacze i inne obiekty bazy danych, które używane są w wersji SQL Server Enterprise. Migracja bazy danych SQL Server Express do SQL Server Enterprise nie wymaga niczego więcej ponad odłączenie jej od bazy danych SQL Server Express i podłączenie do SQL Server Enterprise. Głównymi różnicami pomiędzy wersjami standardowymi SQL Server i wersją SQL Server Express jest to, że ta ostatnia ma ograniczenie wielkości bazy danych do 4 GB (dwa razy tyle, co w Accessie!) i nie obsługuje kilku bardziej zaawansowanych funkcji wersji SQL Server Standard oraz Enterprise Edition. Poza tym silniki baz danych we wszystkich wersjach SQL Server są identyczne. Naprawdę każdy z użytkowników powinien pobrać serwer SQL Server Express i mu się przyjrzeć. W czasie publikacji tej książki oficjalną stroną serwera SQL Server Express była strona pod adresem http://www.microsoft.com/sqlserver/en/us/editions/2012-editions/express.aspx. Możesz też przeszukać internet pod kątem hasła „pobieranie SQL Server Express”.
Przed rozpoczęciem lektury tego rozdziału należy sobie uświadomić, że w architekturze opisanej w dalszych podrozdziałach SQL Server służy do przechowywania danych, a Access — do tworzenia interfejsu użytkownika, raportów aplikacji i logiki zarządzającej działaniem i funkcjami programu. Ten rozdział przedstawia kilka różnych sposobów na uzyskanie przez Access dostępu do danych z serwera SQL Server. Mimo że w pliku .accdb nie ma żadnych obiektów projektowych SQL Server (tabel, procedur składowanych, widoków itp.), można wykorzystać mechanizm ODBC (ang. Open Database Connectivity) do podłączenia obiektów serwera SQL Server.
Wprowadzenie do serwera SQL Server Express SQL Server to główny silnik bazodanowy Microsoftu przeznaczony dla korporacji, internetu i dużych baz danych. SQL Server to tylko silnik z bardzo prostym interfejsem potrzebny do tworzenia baz danych i obiektów bazodanowych oraz do zarządzania nimi. Nie udostępnia mechanizmów do tworzenia interfejsów użytkownika i raportów. Ponieważ SQL Server jest skalowalny (można go używać zarówno do zarządzania małymi listami na pojedynczych komputerach, jak i w wieloterabajtowych bazach obsługujących jednocześnie tysiące użytkowników), jest silnikiem bazodanowym wybieranym
Rozdział 29. Integrowanie baz SQL Server i Access
877
przez wiele małych i dużych firm. W dużych instalacjach opartych na serwerze SQL Server można tworzyć klastry, które umożliwiają pracę wielu serwerów w ramach jednego, dużego systemu komputerowego. W praktyce nie ma ograniczeń liczby tabel, procedur składowanych ani innych obiektów w bazach SQL Server. Ponadto każda tabela może zawierać niemal nieograniczoną liczbę rekordów. SQL Server zapewnia też wysokie bezpieczeństwo baz danych. W systemie zabezpieczeń baz SQL Server bezpośrednio wykorzystuje się narzędzie Windows Active Directory. Oznacza to, że — w zależności od konfiguracji — SQL Server może rozpoznać użytkownika na podstawie loginu z systemu Windows i przynależności do grup Active Directory. Możliwe też, że użytkownicy będą musieli logować się za każdym razem, gdy aplikacja będzie używać bazy SQL Server. Ponieważ fizyczna baza danych SQL Server znajduje się na serwerze aplikacji, jest mało prawdopodobne, że nieuprawniony użytkownik uzyska dostęp do danych z takiej bazy lub wykradnie całą bazę. Dlatego SQL Server jest naturalnym punktem docelowym dla tych baz Accessa, dla których ograniczenia związane z bazami opartymi na plikach są zbyt uciążliwe (i dla baz współużytkowanych przez więcej osób, niż silnik bazodanowy Accessa potrafi obsłużyć). Microsoft udostępnia wersję SQL Server Express jako praktyczny serwerowy system bazodanowy dla baz danych o średniej wielkości. Ponieważ SQL Server Express jest pod względem binarnym zgodny z pełną wersją serwera SQL Server, nie trzeba przeprowadzać konwersji przy przenoszeniu baz między tymi wersjami. Wystarczy odłączyć pliki bazy od wersji Express i dołączyć je do pełnej wersji. Podstawowy kod w SQL Server Express jest dokładnie taki sam jak w pozostałych wersjach serwera. Obsługuje też te same formaty plików baz danych co wersja SQL Server Enterprise. Format plików z danymi, składnia języka Transact-SQL, architektura zabezpieczeń i inne cechy w edycjach SQL Server Express i SQL Server Enterprise też są takie same. Podstawowa różnica między tymi silnikami bazodanowymi polega na tym, że SQL Server Express nie obejmuje kilku zaawansowanych funkcji (takich jak wyszukiwanie pełnotekstowe) dostępnych w edycji SQL Server Enterprise. Ponadto SQL Server Enterprise obsługuje bazy o wielkości do 4 gigabajtów, natomiast w edycji SQL Server Enterprise można używać baz o wielkości przekraczającej 500 000 terabajtów. Serwer SQL Server Express obejmuje narzędzia SQL Server Management Studio i SQL Server Reporting Services. Ponadto (w odróżnieniu od wcześniej używanego narzędzia MSDE — ang. Microsoft Database Engine) w serwerze tym wydajność nie jest sztucznie obniżana. W MSDE z powodu niskiej wydajności nie można było utworzyć więcej niż kilku jednoczesnych połączeń. Więcej informacji znajdziesz na stronach poświęconych wersji SQL Server Express (http://www.microsoft.com/sqlserver/en/us/editions/2012editions/express.aspx) w witrynie Microsoftu. SQL Server Express to idealny silnik bazodanowy dla małych grup roboczych i użytkowników indywidualnych chcących zastosować architekturę klient-serwer. Bez wątpienia atrakcyjna jest też cena tego serwera! SQL Server Express można pobrać bezpłatnie z witryny MSDN Microsoftu.
878
Część VII Zaawansowane techniki programowania w Accessie
Typy danych w bazach SQL Server W bazach SQL Server nazwy typów danych są inne niż w Accessie. Jeśli chcesz korzystać z baz SQL Server, powinieneś poznać dostępne w nich typy danych i wiedzieć, jakie typy danych odpowiadają im w Accessie. W tabeli 29.1 przedstawiamy typy danych z Accessa 2013. Tabela 29.1. Typy danych w bazach Access i SQL Server Typ danych Accessa
— zmienne łańcuchowe ze znakami Unicode (16bitowymi) char — łańcuch znaków Krótki tekst
o stałej długości, zwykle krótki; niezależnie od wartości łańcuch znaków jest uzupełniany do stałego rozmiaru varchar(50-n) — łańcuch
znaków o zmiennej długości; krótkie łańcuchy nie są uzupełniane MAX — używane dla bardzo
długich łańcuchów znaków
Długi tekst
text i ntext — długie łańcuchy znaków przechowywane w postaci binarnej; typ ntext służy do zapisywania łańcuchów znaków Unicode
Do 2 gigabajtów danych (jest to limit wielkości baz danych Accessa), jeśli pole jest zapełniane programowo. Warto pamiętać, że dodanie 2 gigabajtów danych sprawia, że baza działa powoli. Dane alfanumeryczne (tekst i cyfry)
Jeśli wpisujesz dane ręcznie, możesz wprowadzić i wyświetlić maksymalnie 65 535 znaków w polu tabeli i formantach powiązanych z takim polem. Przy tworzeniu baz danych w plikach Accessa pola typu Długi tekst obsługują zaawansowane formatowanie.
Rozdział 29. Integrowanie baz SQL Server i Access
879
Tabela 29.1. Typy danych w bazach Access i SQL Server — ciąg dalszy Typ danych Accessa
Służy do przechowywania
Ograniczenia
Wartości liczbowe
Ustawienie Rozmiar pola określa długość wartości, jaką można zapisać w polu. Rozmiar pola w zależności od wybranej opcji może wynosić 1, 2, 4, 8 lub 16 bajtów.
Daty i godziny
Przechowuje wszystkie daty jako 8-bajtowe liczby całkowite o podwójnej precyzji.
money, smallmoney
Wartości pieniężne
Przechowuje dane jako liczby 8-bajtowe o precyzji do czterech miejsc po przecinku. Ten typ danych używany jest do wyświetlania danych finansowych i gdy Access nie ma zaokrąglać wartości.
Autonumerowanie
int (ze zdefiniowaną właściwością IDENTITY)
Niepowtarzalne wartości generowane przez Accessa przy tworzeniu nowych rekordów
Przechowuje dane jako 4-bajtowe wartości. Zwykle służy do tworzenia kluczy głównych.
Tak/Nie
Bit
Wartości logiczne (prawda lub fałsz)
Liczba -1 odpowiada wartości Tak i podobnym, a liczba 0 — wartości Nie i podobnym.
Typ danych w SQL Server tinyint, smallint, int, bigint — liczby całkowite
(od bardzo małych do bardzo dużych); mniej pojemne typy danych wymagają mniej bajtów i zajmują mniej pamięci fizycznej
Liczba
real, float — liczby rzeczywiste i zmiennoprzecinkowe są tym samym decimal[(18,0)] — liczby
dziesiętne domyślnie mają do dwóch cyfr po przecinku, jednak mogą zajmować nawet do 18 bajtów i nie mieć części ułamkowej numeric[(18,0)] — pozwala
określić długość (działa identycznie jak typ decimal) Data/Godzina
Waluta
datetime, smalldatetime, timestamp
880
Część VII Zaawansowane techniki programowania w Accessie
Tabela 29.1. Typy danych w bazach Access i SQL Server — ciąg dalszy Typ danych Accessa
Typ danych w SQL Server
Służy do przechowywania
Ograniczenia Do 2 gigabajtów danych (jest to limit wielkości baz danych Accessa). Warto pamiętać, że dodanie 2 gigabajtów danych spowalnia pracę bazy. W polu Obiekt OLE tworzona jest bitmapa na podstawie pierwotnego dokumentu lub innego obiektu. Ta bitmapa pojawia się w polach tabeli oraz formantach formularzy i raportów bazy danych.
Image — służy do Obiekt OLE
zapisywania grafiki w postaci binarnej
Obrazy, dokumenty, wykresy i inne obiekty z pakietu Office oraz programów dla systemu Windows
Aby Access wyświetlał takie obrazy, na komputerze z bazą danych musi działać serwer OLE (program obsługujący plik określonego typu). Jeśli w systemie nie ma zarejestrowanego serwera OLE dla plików danego typu, Access wyświetli ikonę niezidentyfikowanej grafiki. Jest to znany problem dotyczący niektórych plików graficznych (zwłaszcza plików JPG). Zwykle w plikach ACCDB należy stosować pola typu Załącznik zamiast pól typu Obiekt OLE. Pola załącznika wydajniej wykorzystują pamięć i nie wymagają zarejestrowanych serwerów OLE.
Hiperłącze
Brak odpowiednika
Adresy WWW
Przechowuje do 1 gigabajta danych. Pozwala zapisać odnośniki do witryn, stron lub plików w intranecie albo sieci LAN, a także miejsc i plików w komputerze.
Rozdział 29. Integrowanie baz SQL Server i Access
881
Tabela 29.1. Typy danych w bazach Access i SQL Server — ciąg dalszy Typ danych Accessa
Typ danych w SQL Server
Służy do przechowywania
Ograniczenia
Załącznik
Brak odpowiednika
Dowolny pliku obsługiwanego typu
Jest to nowość w plikach ACCDB Accessa. Obrazy, arkusze kalkulacyjne, dokumenty, wykresy i inne pliki obsługiwanych typów można dołączyć do rekordów bazy danych w podobny sposób jak pliki do wiadomości e-mail. Ponadto — w zależności od tego, jak programista skonfigurował pole typu Załącznik — można wyświetlać i edytować dołączone pliki. Pola tego typu zapewniają większą swobodę niż pola typu Obiekt OLE i wydajniej wykorzystują pamięć, ponieważ nie tworzą bitmap na podstawie pierwotnego pliku.
przechowywania zawartości i funkcji dokumentów XML sql_variant — zmienny typ
Brak odpowiednika
Brak odpowiednika danych (nie można w nim zapisywać danych typu text, w Accessie ntext, image i timestamp)
Brak odpowiednika w Accessie
Instalowanie serwera SQL Server Express W przykładach z tego rozdziału wykorzystano serwer SQL Server Express 2012 with Tools. Jeśli masz dostęp do serwera SQL Server Enterprise, możesz wykorzystać właśnie jego lub zastosować serwer SQL Server Express, aby przechowywać przykładowy kod poza główną instalacją serwera SQL Server. Jeśli zainstalujesz inną wersję serwera SQL Server Express 2012 (np. Database Only lub Advanced Services), dostępnych będzie mniej lub więcej opcji w porównaniu z przedstawionymi w tym miejscu.
882
Część VII Zaawansowane techniki programowania w Accessie
Instalowanie silnika bazy danych Aby zainstalować serwer SQL Server Express, wykonaj następujące czynności: 1. Pobierz plik instalacyjny z witryny Microsoftu. W zależności od używanej wersji systemu Windows wybierz pakiet x86 lub x64. Aby określić wersję, otwórz menu boczne, kliknij Ustawienia i wybierz opcję Informacje o komputerze. Następnie sprawdź właściwość Typ systemu. Może mieć ona wartość 32-bitowy system operacyjny lub 64-bitowy system operacyjny. 2. Aby rozpocząć instalowanie, kliknij prawym przyciskiem myszy pobrany plik instalacyjny i wybierz opcję Uruchom jako administrator. W zależności od systemu wyodrębnienie plików serwera SQL Server Express i zainstalowanie go może zająć sporo czasu.
3. Wybierz opcję New SQL Server stand-alone installation, jak pokazano na rysunku 29.1.
Rysunek 29.1. Instalowanie niezależnego serwera SQL Server
4. Zaakceptuj warunki umowy licencyjnej i kliknij przycisk Next.
Rozdział 29. Integrowanie baz SQL Server i Access
883
5. Na stronie Feature Selection wybierz opcję Select All, aby zainstalować wszystkie dostępne funkcje (zobacz rysunek 29.2).
Rysunek 29.2. Wybierz funkcje, które chcesz zainstalować
6. Na stronie Instance Configuration wybierz opcję Named Instance i wpisz nazwę danego egzemplarza serwera SQL Server lub zaakceptuj nazwę domyślną (zobacz rysunek 29.3). 7. Na stronie Server Configuration zaakceptuj opcje domyślne, aby serwer SQL Server był uruchamiany automatycznie. W tym celu kliknij przycisk Next. 8. Na stronie Database Engine Configuration (zobacz rysunek 29.4) wybierz opcję Windows Authentication Mode. Upewnij się, czy konto, którego używasz, znajduje się na liście Server Administrators. Jeśli jest inaczej, wybierz opcję Add Current User, aby ustawić używane konto jako konto administratora. 9. Na stronie Error Reporting kliknij przycisk Next. 10. Po zakończeniu procesu instalowania kliknij przycisk Close. Gratulacje! Właśnie zainstalowałeś na komputerze system bazodanowy SQL Server.
884
Część VII Zaawansowane techniki programowania w Accessie
Rysunek 29.3. Nazwij dany egzemplarz serwera SQL Server
Rysunek 29.4. W serwerze SQL Server można wykorzystać uwierzytelnianie systemu Windows
Rozdział 29. Integrowanie baz SQL Server i Access
885
Instalowanie przykładowej bazy danych Microsoft udostępnia przykładową bazę danych AdventureWorks przeznaczoną do użytku z serwerem SQL Server Express. Baza ta jest używana w przykładach z tego rozdziału. Aby zainstalować bazę AdventureWorks, wykonaj następujące czynności: 1. Otwórz stronę http://sqlserversamples.codeplex.com i wybierz bazę dla używanej wersji serwera SQL Server Express (np. AdventureWorks for SQL Server 2012 RTM). 2. Znajdź odnośnik do wersji AdventureWorksLT2012_Data. Baza z oznaczeniem „LT” to uproszczona wersja pliku AdventureWorks2012_Data. Jest ona znacznie mniejsza, a przy tym zawiera wszystkie elementy potrzebne do przedstawienia procesu integrowania serwera SQL Server z Accessem. Kliknij odpowiedni odnośnik, aby pobrać bazę danych. 3. Skopiuj pobrany plik MDF do wybranego katalogu komputera. Nie próbuj bezpośrednio otwierać tego pliku, ponieważ Windows poinformuje Cię, że jest to plik systemowy. 4. Uruchom narzędzie SQL Server Management Studio jako administrator. Otwórz menu Start, znajdź ikonę programu Microsoft SQL Server 2012, kliknij ją prawym przyciskiem myszy i wybierz opcję Uruchom jako administrator. Dzięki temu uzyskasz pewność, że program SQL Server Management Studio będzie miał odpowiednie uprawnienia dostępu do pliku MDF. Rysunek 29.5 przedstawia menu podręczne otwarte prawym przyciskiem myszy. Rysunek 29.5. Uruchom program SQL Server Management Studio jako administrator
886
Część VII Zaawansowane techniki programowania w Accessie
5. Połącz się z serwerem SQL Server, podając nazwę serwera i sposób uwierzytelniania. Jeśli właśnie zainstalowałeś serwer SQL Server w opisany wcześniej sposób, musisz tylko wybrać serwer. Uwierzytelnianie jest ustawione na uwierzytelnianie systemu Windows. Na rysunku 29.6 pokazano okno dialogowe Connect to Server. Rysunek 29.6. Łączenie się z serwerem SQL Server 2012
6. W widocznym po lewej stronie eksploratorze obiektów kliknij prawym przyciskiem myszy katalog Databases i wybierz opcję Attach. Pojawi się ekran Attach Databases. 7. Dodaj plik MDF skopiowany w kroku 3. W tym celu kliknij przycisk Add, przejdź do odpowiedniego pliku MDF i wybierz opcję OK, co pokazano na rysunku 29.7. Rysunek 29.7. Wybierz dołączany plik MDF z bazą AdventureWorks
Rozdział 29. Integrowanie baz SQL Server i Access
887
Ekran Attach Databases powinien wyglądać podobnie jak na rysunku 29.8. Po dołączeniu pliku MDF serwer SQL Server spróbuje dołączyć plik LDF (plik dziennika) o tej samej nazwie. Ponieważ baza danych jest nowa, plik dziennika jeszcze nie istnieje.
Rysunek 29.8. Jeśli dołączasz nową bazę danych, pomiń plik LDF
8. Zaznacz plik LDF w dolnym panelu i kliknij przycisk Remove. Po usunięciu pliku kliknij przycisk OK. 9. Rozwiń katalog Databases w eksploratorze obiektów. Powinieneś zobaczyć pozycję AdventureWorksLT2012.
Wprowadzenie do narzędzia Management Studio Omawianie korzystania z serwera SQL Server znacznie wykracza poza zakres tej książki. Jednak krótkie wprowadzenie do narzędzia SQL Server Management Studio pomoże Ci zrozumieć, jak Access i SQL Server ze sobą współdziałają. W poprzednim punkcie podłączyłeś bazę AdventureWorks do serwera SQL Server. W narzędziu Management Studio dostępny jest eksplorator obiektów, w którym można przeglądać obiekty dostępne na serwerze. Jeśli eksplorator jest niewidoczny, możesz go otworzyć za pomocą opcji View/Object Explorer.
888
Część VII Zaawansowane techniki programowania w Accessie
Obiektem najwyższego poziomu w eksploratorze jest egzemplarz serwera, do którego podłączyłeś się w momencie uruchamiania narzędzia Management Studio. Jeśli pod egzemplarzem serwera nie widać żadnych katalogów, kliknij znak plus obok nazwy tego egzemplarza. Spowoduje to rozwinięcie listy obiektów podrzędnych. Pierwszym katalogiem na liście jest Databases. Znajduje się w nim baza danych AdventureWorks dołączona w poprzednim punkcie. Pod obiektem AdventureWorks znajdują się katalogi z wszystkimi obiektami serwera SQL Server dostępnymi w bazie. Większość tych obiektów została szczegółowo opisana w dalszej części rozdziału. Jednym z nich jest obiekt Tables. Na rysunku 29.9 katalog Tables jest rozwinięty, dzięki czemu widać wszystkie tabele z bazy danych. Rysunek 29.9. Narzędzie SQL Server Management Studio pozwala przejrzeć tabele z bazy danych
Gdy znajdziesz tabelę SalesLT.Product i rozwiniesz ją, klikając znak plus obok jej nazwy, zobaczysz liczne katalogi z właściwościami tej tabeli. Na rysunku 29.10 rozwinięty jest katalog Columns. Zaznaczono w nim pole ProductNumber. Na liście na rysunku 29.10 widać część właściwości pola ProductNumber. Na liście widoczne są nazwa pola, a dalej informacje (nvarchar(25), not null). Człon nvarchar(25) oznacza, że pole ProductNumber przechowuje łańcuchy o maksymalnej długości 25 znaków (nvarchar przypomina typ danych Krótki tekst z Accessa). Człon not null to informacja, że właściwość Allow Nulls pola jest ustawiona na False. Gdy dwukrotnie klikniesz nazwę pola, pojawi się okno dialogowe Column Properties z listą wszystkich właściwości danego pola (zobacz rysunek 29.11).
Rozdział 29. Integrowanie baz SQL Server i Access Rysunek 29.10. Eksplorator obiektów zawiera hierarchiczną listę obiektów z serwera
Rysunek 29.11. Okno dialogowe Column Properties z informacjami o polu ProductNumber
889
890
Część VII Zaawansowane techniki programowania w Accessie
Inny katalog tabeli SalesLT.Product to Constraints (czyli więzy). Więzy odpowiadają w przybliżeniu regułom sprawdzania poprawności w Accessie. Rysunek 29.12 przedstawia okno dialogowe Check Constraints. Rysunek 29.12. Więzy przypominają reguły sprawdzania poprawności z Accessa
W więzach zaznaczone na rysunku 29.12 (CK_Product_ListPrice) wyrażenie to ([List Price]>=(0.00)). Jeśli spróbujesz przypisać do produktu ujemną cenę, naruszy to więzy i SQL Server zgłosi błąd. Ostatni obszar narzędzia Management Studio, któremu warto się przyjrzeć, to okno Query. W serwerze SQL Server nie ma znanego z Accessa widoku arkusza danych, jednak można przeglądać dane, pisząc kwerendy. Aby otworzyć okno Query, kliknij przycisk New Query na pasku narzędzi. Rysunek 29.13 przedstawia uruchomioną kwerendę dla tabeli SalesLT.Product. Rysunek 29.13. Uruchamianie kwerend w serwerze SQL Server
Rozdział 29. Integrowanie baz SQL Server i Access
891
Posługiwanie się wierszem poleceń SQL Server udostępnia uruchamiane z poziomu wiersza poleceń narzędzie SQLCMD pozwalające uzyskać dostęp do danych. Umożliwia ono wykonywanie szybkich kwerend lub wsadowe uruchamianie plików zgodnie z harmonogramem. Aby wyświetlić listę opcji tego narzędzia, wpisz sqlcmd –? w wierszu poleceń. Rysunek 29.14 przedstawia prostą kwerendę uruchamianą z poziomu wiersza poleceń. Rysunek 29.14. Używanie uruchamianego w wierszu poleceń narzędzia SQLCMD
W wierszu poleceń wywołano instrukcję sqlcmd –s SQLEXPRESS, aby otworzyć uruchamiane w wierszu poleceń narzędzie połączone z egzemplarzem SQLEXPRESS serwera SQL Server. Po wyświetlonym symbolu zachęty, >1, można zacząć wpisywać instrukcje SQL-a i narzędzia SQLCMD. Pierwsza instrukcja, use AdventureWorksLT2012, informuje narzędzie SQLCMD, dla jakiej bazy danych należy wykonywać następne polecenia. Polecenie go uruchamia tę instrukcję. SQLCMD w odpowiedzi informuje o zmianie bazy danych na AdventureWorksLT2012 (Changed database context to 'AdventureWorksLT2012') i zgłasza gotowość do wykonywania dalszych operacji. Pojawia się nowy symbol zachęty, >1. Następne polecenie z rysunku 29.14 to kwerenda SELECT dotycząca tabeli SalesLT. Product. SELECT TOP (3) Name, ListPrice FROM SalesLT.Product ORDER BY ListPrice DESC;
Instrukcja ta pobiera kolumny Name i ListPrice z tabeli Product, sortuje tabelę według cen (od najwyższych do najniższych) i zwraca trzy pierwsze rekordy. Opisane narzędzie wiersza poleceń działa dobrze, gdy użytkownik zna wszystkie nazwy serwera, tabel i kolumn potrzebne w kwerendzie. Łatwiejszym rozwiązaniem może się okazać otwarcie narzędzia Management Studio i wykonanie kwerend z jego poziomu.
892
Część VII Zaawansowane techniki programowania w Accessie
Błędy w potokach nazwanych Na niektórych komputerach trzeba odpowiednio zmienić konfigurację, aby móc używać narzędzia SQLCMD. Przy jego uruchamianiu może się pojawić następujący błąd: Sqlcmd: Error: Microsoft SQL Server Native Client 11.0 : Named Pipes Provider: Could not open a connection to SQL Server [2].
Aby go uniknąć, wykonaj następujące czynności: 1. Otwórz okno SQL Server Configuration Manager. 2. Rozwiń węzeł SQL Server Network Configuration i wybierz opcję Protocols for SQLEXPRESS.
3. Kliknij dwukrotnie pozycję Named Pipes, aby otworzyć okno dialogowe Właściwości: Named Pipes. 4. Zmień wartość ustawienia Pipe Name na \\.\pipe\sql\query.
Rozdział 29. Integrowanie baz SQL Server i Access
893
5. Kliknij przycisk OK, aby zamknąć okno dialogowe. Zignoruj komunikaty dotyczące ponownego uruchomienia usługi. 6. Wybierz opcję SQL Server Services w oknie Configuration Manager. 7. Kliknij prawym przyciskiem myszy pozycję SQL Server (SQLEXPRESS) i wybierz opcję Restart, aby ponownie uruchomić system SQL Server.
8. Zamknij okno Sql Server Configuration Manager.
Podłączanie się do serwera SQL Server Istnieją dwa sposoby korzystania z danych z serwera SQL Server w Accessie. Oto one:
Dołączenie tabel bazy SQL Server i korzystanie z nich jak z tabel połączonych z innej bazy Accessa.
Wykorzystanie kodu ADO do programowego otwierania bazy danych SQL Server i pracy z zapisanymi w niej danymi.
Jak się przekonasz, praca z danymi z baz SQL Server za pomocą tabel połączonych przebiega tak samo jak przy użyciu tabel połączonych z innych źródeł danych. Jedną z najważniejszych operacji w każdym dużym wielodostępnym silniku bazodanowym (jakim jest SQL Server) jest łączenie się z bazą. Bezpośrednie łączenie się z bazą SQL Server za pomocą jej frontonowych narzędzi jest stosunkowo proste. Potrzebne jest tylko połączenie z bazą SQL Server, a Access wykonuje wszystkie potrzebne operacje.
Tworzenie źródła danych Tworzenie połączenia pomiędzy Accessem i serwerem SQL Server wymaga nieco więcej zachodu w porównaniu z prostym podłączaniem się do bazy danych, ponieważ zarówno Access, jak i SQL Server są autonomicznymi środowiskami, które muszą ze sobą
894
Część VII Zaawansowane techniki programowania w Accessie
współpracować. Jak w przypadku wielu relacyjnych baz danych działających w systemie Windows do umożliwienia narzędziom takim jak Access i SQL Server komunikowania się ze sobą używane są sterowniki. Podobnie jak w innych popularnych narzędziach firmy Microsoft, tak i tu zostały stworzone specjalne sterowniki obsługujące komunikację pomiędzy różnymi produktami. Sterowniki te można wykorzystać do podłączania narzędzi takich jak Excel i Access do baz danych Oracle lub DB2 albo, jak w tym przypadku, do podłączenia Accessa do bazy danych SQL Server. Omawiane sterowniki dzielą się na wiele kategorii i obejmują mechanizmy ODBC (ang. Open Database Connectivity), OLE (ang. Object Linked Embedding) oraz sterowniki natywne. Sterowniki natywne są często najlepszym i najszybszym sposobem podłączania się do specyficznego produktu lub silnika bazy danych. Są jednak mniej uniwersalne i trudniejsze do dostosowania. Zwykle są przeznaczone dla konkretnych produktów lub baz danych. Wiele z tych sterowników rozwijanych jest przez Microsoft, ponieważ działają w systemie operacyjnym Windows. Niektórzy producenci wypuszczają też własne wersje sterowników ODBC i OLE. Tu najważniejsze są sterowniki ODBC, które umożliwiają komunikowanie się z serwerem SQL Server. W jaki sposób można obsługiwać sterownik ODBC? Należy stworzyć źródło danych ODBC (nazywane też DSN — ang. Data Source Name), a następnie odnośnik do niego w programie Access. Skonfigurowane źródło danych jest zapisywane w lokalnym komputerze. Jest dostępne dla wszystkich aplikacji zgodnych z ODBC, np. dla programu Microsoft Access. Źródło danych obejmuje wystarczająco dużo informacji na temat źródła danych ODBC, by silnik bazodanowy Accessa (Jet lub ACE) mógł wykorzystać sterownik ODBC do komunikowania się z serwerem SQL Server. Aby utworzyć źródło danych, należy wykonać następujące czynności: 1. Kliknij prawym przyciskiem myszy na ekranie startowym systemu Windows i wybierz opcję Wszystkie aplikacje. Następnie kliknij kafelek Panel sterowania, aby otworzyć narzędzie o tej samej nazwie. 2. W Panelu sterowania kliknij dwukrotnie ikonę Narzędzia administracyjne i wybierz opcję Źródła danych (ODBC). Dostępne są trzy opcje konfiguracyjne ODBC:
DSN użytkownika — ma zastosowanie do określonego komputera klienckiego, na którym stworzony jest DSN użytkownika.
Systemowe DSN — podobna do DSN użytkownika, z tym wyjątkiem, że ma zastosowanie do sieci (w pewnym zakresie).
Plikowe DSN — tworzy konfigurację połączenia (łańcuch połączeniowy) dla bazy danych, zapisaną w pliku na komputerze klienckim.
Z tych trzech opcji najbardziej użyteczną w największej liczbie przypadków jest Plikowe DSN. Ze względu na fakt, iż informacje o połączeniu przechowywane są w pliku (lokalizacja domyślna dla plików źródła danych to katalog Dokumenty), łatwo jest dzielić konfigurację źródła danych z innymi użytkownikami.
3. Otwórz zakładkę Plikowe DSN i kliknij przycisk Dodaj, aby utworzyć nowe źródło danych.
Rozdział 29. Integrowanie baz SQL Server i Access
895
4. Na pierwszym ekranie kreatora Tworzenie nowego źródła danych przewiń listę w dół i wybierz sterownik SQL Server, jak pokazano na rysunku 29.15. Kliknij przycisk Dalej, aby kontynuować. Rysunek 29.15. Wybieranie sterownika dla nowego źródła danych
Na Twoim komputerze dostępne mogą być inne sterowniki.
5. W następnym kroku podaj nazwę plikowego źródła danych. Możesz wybrać dowolną nazwę, jednak powinna ona być opisowa, dzięki czemu będziesz później wiedzieć, czego używasz. Tu nazwij źródło danych AdventureWorks, ponieważ zostanie ono powiązane z bazą danych AdventureWorksLT2012. 6. Gdy zakończysz używanie kreatora źródła danych, pojawi się kreator sterowników serwera SQL Server. Na rysunku 29.16 widoczny jest pierwszy ekran tego kreatora. Można tu podać opis i określić używany serwer. Rysunek 29.16. Dla sterowników serwera SQL Server dostępny jest odrębny kreator
896
Część VII Zaawansowane techniki programowania w Accessie
7. W kreatorze należy określić sposób uwierzytelniania. Wybierz uwierzytelnianie systemu Windows i kliknij przycisk Dalej, aby przejść dalej. 8. Na rysunku 29.17 widoczny jest następny ekran kreatora. Tu wybrano domyślną bazę danych — AdventureWorksLT2012. Rysunek 29.17. Wybieranie domyślnej bazy dla źródła danych
9. Zaakceptuj ustawienia domyślne na ostatnim ekranie kreatora i kliknij przycisk Zakończ. Sterownik wyświetli okno komunikatu z listą wybranych opcji i umożliwi przetestowanie połączenia. 10. Kliknij przycisk Testuj źródło danych, aby się upewnić, czy rozwiązanie działa poprawnie. Jeśli konfiguracja jest prawidłowa, pojawi się powiadomienie podobne do tego z rysunku 29.18. Rysunek 29.18. Sterownik serwera SQL Server informuje o udanym nawiązaniu połączenia
Na liście źródeł danych pojawi się nowy plik DSN reprezentujący utworzone właśnie źródło danych. Plik ten posłuży w Accessie do dołączenia tabel z serwera SQL Server.
Rozdział 29. Integrowanie baz SQL Server i Access
897
Udostępnianie pliku źródła danych jest proste. Wystarczy po prostu zlokalizować plik źródła danych na danej maszynie i przesłać go poprzez pocztę elektroniczną lub sieć. Źródło danych użytkownika i systemowe źródło danych są tak naprawdę przechowywane w rejestrze komputera i muszą być ustawione ręcznie na każdym komputerze, który potrzebuje dostępu do źródła danych ODBC. Serwer SQL Server jest bardzo szczegółowy, jeśli chodzi o jego nazwę. W wersjach starszych niż SQL Server 2000 serwer przyjmował nazwę hosta, ponieważ na komputerze można było zainstalować tylko jeden egzemplarz serwera SQL Server. Jednak począwszy od wersji 2000, pojedynczy komputer może obsługiwać wiele egzemplarzy baz danych na jednym serwerze, tak więc nazwy nadawane bazom danych są nieco bardziej skomplikowane. Składnia używana do opisywania egzemplarzy SQL Servera jest następująca: MójKomputer\EgzemplarzSerweraSQL, gdzie MójKomputer to nazwa komputera hosta, a EgzemplarzSerweraSQL to nazwa egzemplarza, którego programista chce używać. Jeżeli na komputerze lokalnym zainstalowany jest tylko jeden egzemplarz serwera SQL Server, można określić (local) jako nazwę serwera. W przeciwnym przypadku trzeba podać pełną nazwę komputera i egzemplarza w sposób opisany w poprzednim akapicie.
Łączenie serwera SQL Server z Accessem Po utworzeniu, skonfigurowaniu i przetestowaniu nowego źródła danych można wykorzystać je do utworzenia połączenia między serwerem SQL Server a bazą danych Accessa. Aby nawiązać połączenie z tabelą SalesLT.Product, wykonaj następujące czynności: 1. W zakładce DANE ZEWNĘTRZNE na wstążce wybierz opcję Baza danych ODBC. 2. Wybierz opcję Połącz ze źródłem danych, tworząc tabelę połączoną, a następnie kliknij przycisk OK. 3. Na ekranie Wybierz źródło danych wskaż utworzony wcześniej plik źródła danych, co pokazano na rysunku 29.19. Pojawi się okno dialogowe Łączenie tabel (zobacz rysunek 29.20), w którym można wskazać tabele z serwera SQL Server łączone z bazą danych Accessa. Widocznych jest tu zaskakująco dużo tabel. Rysunek 29.19. Wybierz plikowe źródło danych AdventureWorks.dsn
898
Część VII Zaawansowane techniki programowania w Accessie
Rysunek 29.20. Wybieranie tabel z bazy danych z serwera SQL Server
Niewidoczne okno dialogowe Łączenie tabel lub błąd w czasie oczekiwania na okno dialogowe mogą oznaczać problemy ze źródłem danych.
4. W oknie dialogowym Łączenie tabel pomiń wszystkie tabele systemowe (z przedrostkiem sys lub INFORMATION_SCHEMA). Znajdź tabelę SalesLT.Product i wybierz ją. 5. Kliknij przycisk OK, aby zamknąć okno dialogowe Łączenie tabel i połączyć wybraną tabelę. W okienku nawigacji (zobacz rysunek 29.21) pojawi się nowo połączona tabela. Kropka w nazwie tabeli zmieniła się w podkreślenie. Rysunek 29.21. Przy tabelach połączonych widoczna jest ikona kuli ziemskiej
Określenie dbo jest skrótem od database owner (właściciel bazy danych) i jest domyślnym przedrostkiem dla wszystkich obiektów w bazie danych serwera SQL Server. Pełne wyjaśnienie uwierzytelniania, bezpieczeństwa i praw własności w serwerze SQL Server to temat wykraczający poza zakres tego rozdziału. Na chwilę obecną wystarczy zrozumieć, że serwer ten obsługuje wielu użytkowników, z których każdy jest indywidualnie identyfikowany na podstawie nazwy. Kiedy użytkownik tworzy
Rozdział 29. Integrowanie baz SQL Server i Access
899
obiekt bazy danych, to tworzy go albo z własnym przedrostkiem nazwy, albo z domyślnym przedrostkiem dbo w zależności od tego, w jaki sposób skonfigurowane są zabezpieczenia serwera SQL Server.
W zależności od tego, czy baza SQL Server obejmuje klucz główny, może (ale nie musi) pojawić się okno dialogowe z rysunku 29.22. W trakcie pracy z tabelami połączonymi Access wymaga niepowtarzalnego identyfikatora z tabeli bazy SQL Server. Dzięki temu aktualizacje z Accessa można poprawnie wprowadzić w bazie SQL Server. W przykładowej tabeli z rysunku 29.22 sensownym wyborem jest pole ContactID. W niektórych sytuacjach trzeba dokładnie przeanalizować dane z tabeli SQL Server, aby ustalić, które pole (lub jaką kombinację pól) można wykorzystać jako niepowtarzalny identyfikator. We wszystkich tabelach przykładowej bazy danych AdventureWorks istnieją klucze główne. Rysunek 29.22. Wybieranie unikatowego identyfikatora z tabeli bazy SQL Server
Jak widać, połączenie Accessa z bazą danych SQL Server jest stosunkowo proste, choć wymaga wykonania wielu kroków. Główna zaleta korzystania ze sterowników ODBC do dołączania tabel z baz SQL Server związana jest z tym, że Access traktuje tabele bazy SQL Server zlokalizowane na zdalnym serwerze bazodanowym i tabele Accessa z bieżącej bazy danych w taki sam sposób. Ponadto bazę danych Accessa można podłączyć jednocześnie do kilku źródeł danych. Możliwość łączenia się z wieloma różnymi źródłami danych jest główną zaletą korzystania z programu Microsoft Access w porównaniu z innymi systemami bazodanowymi na komputery biurkowe. Dobra jest zwłaszcza integracja między Accessem a bazami SQL Server. Użytkownicy odpowiednio zarządzanych aplikacji Accessa rzadko mają świadomość, że korzystają z danych przechowywanych w zdalnej bazie.
Używanie ADO do baz SQL Server Tabele połączone doskonale nadają się do pracy z danymi z baz SQL Server. Jeśli wiesz już, jak korzystać ze zwykłych tabel Accessa, posługiwanie się tabelami połączonymi będzie dla Ciebie bardzo łatwe. Jeżeli jednak w projekcie dane z baz SQL Server są potrzebne tylko od czasu do czasu, wygodniejsze może się okazać pobieranie danych za pomocą interfejsu ADO w kodzie VBA. Dzięki temu nie trzeba umieszczać w okienku nawigacji dużej liczby tabel połączonych, które będą potrzebne tylko kilkakrotnie. Omówienie interfejsu ADO znajdziesz w rozdziałach 27. i 28.
900
Część VII Zaawansowane techniki programowania w Accessie
Tworzenie łańcucha połączeniowego Pierwszą porcją informacji potrzebną w interfejsie ADO jest łańcuch połączeniowy. W rozdziale 27. wykorzystano właściwość CurrentProject.Connection, aby uzyskać łańcuch połączeniowy OLEDB dla bieżącego projektu. Ponieważ dane potrzebne w tym przykładzie znajdują się w bazie SQL Server, potrzebny jest inny łańcuch połączeniowy. Jedną z możliwości jest zastosowanie przedstawionej w rozdziale 27. techniki opartej na pliku UDL. Jeśli jednak masz tabelę połączoną lub możesz ją utworzyć, dostępne są dwie inne metody, które mogą okazać się łatwiejsze. Określanie łańcucha połączeniowego za pomocą właściwości tabeli
Pierwsza możliwość to zbadanie właściwości tabeli połączonej. Jeśli otworzysz taką tabelę w widoku projektu, Access wyświetli ostrzeżenie dotyczące pewnych ograniczeń (np. tego, że nie można zmodyfikować projektu tabeli). Na rysunku 29.23 widoczne jest ostrzeżenie wyświetlane po otwarciu tabeli SalesLT.Product w widoku projektu.
Rysunek 29.23. Access wyświetla ostrzeżenie po otwarciu tabel połączonych w widoku projektu
Wybierz opcję Tak, aby mimo ograniczeń otworzyć tabelę połączoną. Zobaczysz wtedy znane okno projektowe tabeli. Nie można jednak wprowadzać w nim żadnych zmian — tabelę można zmodyfikować tylko w bazie SQL Server. Otwórz arkusz właściwości tabeli (opcja Arkusz właściwości z zakładki NARZĘDZIA TABEL PROJEKTOWANIE na wstążce). We właściwości Opis znajdziesz informacje potrzebne do utworzenia łańcucha połączeniowego (zobacz rysunek 29.24). Poniżej pokazano wartość właściwości Opis tabeli SalesLT.Product dołączonej w poprzednim punkcie: ODBC;Description=Łączy z bazą AdventureWorksLT2012;DRIVER=SQL Server;SERVER=DICKPC; Trusted_Connection=Yes;APP=Microsoft® Windows® Operating System; DATABASE=AdventureWorksLT2012;TABLE=SalesLT.Product
Oczywiście właściwość Opis bazy danych używanej przez Ciebie będzie nieco odmienna. Właściwość ta zawiera więcej informacji niż potrzeba w łańcuchu połączeniowym. Pierwszy człon, ODBC;, to identyfikator informujący Accessa o typie połączenia. Identyfikator ten nie jest potrzebny w łańcuchu połączeniowym. Zbędny jest też ostatni fragment, TABLE=SalesLT.Product, ponieważ połączenie ADO dotyczy bazy danych, a nie konkretnej tabeli. Pozostałe fragmenty tworzą poprawny łańcuch połączeniowy. Większość członów jest oczywista — zwłaszcza jeśli we wcześniejszej części rozdziału wykonałeś kroki prowadzące do utworzenia plikowego źródła danych. Człon Trusted_Connection=Yes określa, że używane będzie uwierzytelnianie systemu Windows.
Rozdział 29. Integrowanie baz SQL Server i Access
901
Rysunek 29.24. Właściwość Opis tabeli
Możesz skopiować właściwość Opis i wkleić ją w kodzie. Po usunięciu niepotrzebnych członów będzie można nawiązać w ADO połączenie z bazą danych SQL Server. W dalszej części rozdziału znajdziesz przykład ilustrujący, jak to zrobić. Określanie łańcucha połączeniowego za pomocą kodu VBA
Inny sposób określania łańcucha połączeniowego polega na wykorzystaniu właściwości Connect obiektu TableDef. Choć SalesLT_Product jest tabelą połączoną, to znajduje się w kolekcji TableDefs. Za pomocą okna Immediate można zbadać właściwości odpowiedniego obiektu TableDef. Na rysunku 29.25 pokazano uruchomione w tym oknie polecenie, które pozwala podejrzeć wartość właściwości Connect. Rysunek 29.25. Używanie okna Immediate do ustalenia łańcucha połączeniowego
W oknie Immediate długie wiersze tekstu nie są zawijane, dlatego na rysunku 29.25 widać tylko pierwszą część łańcucha znaków. Kompletna wartość właściwości Connection widoczna jest poniżej: ODBC;Description=Connects to AdventureWorksLT2012;DRIVER=SQL Server; SERVER=DICKPC;Trusted_Connection=Yes;APP=Microsoft® Windows® Operating System; DATABASE=AdventureWorksLT2012
902
Część VII Zaawansowane techniki programowania w Accessie
Warto zauważyć, że tekst ten jest prawie identyczny z właściwością Opis z właściwości tabeli (różnicą jest brak nazwy tabeli w tym miejscu). Aby wykorzystać ten tekst jako łańcuch połączeniowy, trzeba usunąć człon ODBC; z początku łańcucha. Tworzenie w ADO kwerend dla baz SQL Server Po utworzeniu łańcucha połączeniowego pobieranie danych z baz SQL Server jest proste — wystarczy napisać instrukcję SQL-a. W poniższym przykładzie zwracany jest zbiór rekordów z wszystkimi produktami, dla których pole Color ma wartość Black. Zwrócony zbiór rekordów jest wyświetlany w oknie Immediate. Sub GetSQLServerDataWithADO() Dim Dim Dim Dim
adCn As ADODB.Connection adRs As ADODB.Recordset sConn As String sSql As String
sSql = "SELECT Name, Color, ListPrice FROM SalesLT.Product " sSql = sSql & "WHERE Color = 'Black';" Set adCn = New ADODB.Connection adCn.Open sConn Set adRs = adCn.Execute(sSql) Debug.Print adRs.GetString adRs.Close adCn.Close Set adRs = Nothing Set adCn = Nothing End Sub
Do utworzenia łańcucha połączeniowego i instrukcji SQL-a używane są dwie zmienne — sConn i sSQL. Fragment danych wyjściowych znajdziesz na rysunku 29.26. Rysunek 29.26. Zbiór rekordów ADO wyświetlony w oknie Immediate
Można też napisać funkcję zwracającą dane w języku VBA. W funkcjach zwykle pisze się instrukcje SQL-a w taki sposób, aby zwracały tylko jedną wartość. W poniższym przykładowym kodzie zwracana jest największa wartość z pola ListPrice z tabeli SalesLT. Product. Przedstawioną funkcję można wykorzystać w dowolnym kodzie VBA oraz
Rozdział 29. Integrowanie baz SQL Server i Access
903
w formularzach i raportach. Na rysunku 29.27 pokazano wynik zwrócony przez funkcję w oknie Immediate. Public Function GetMaxListPrice() Dim Dim Dim Dim
adCn As ADODB.Connection adRs As ADODB.Recordset sConn As String sSql As String
sSql = "SELECT TOP (1) ListPrice FROM SalesLT.Product " sSql = sSql & "ORDER BY ListPrice DESC;" Set adCn = New ADODB.Connection adCn.Open sConn Set adRs = adCn.Execute(sSql) GetMaxListPrice = adRs.Fields(0).Value adRs.Close adCn.Close Set adRs = Nothing Set adCn = Nothing End Function
Rysunek 29.27. Funkcja języka VBA wywołana w oknie Immediate
W pokazanej funkcji wykorzystano słowa kluczowe SELECT TOP (1) SQL-a, aby pobrać tylko jeden rekord. Klauzula ORDER BY sortuje rekordy malejąco według wartości z pola ListPrice, co gwarantuje, że rekord o największej wartości w polu ListPrice znajdzie się na początku. Instrukcja SQL-a zwraca tu tylko jeden rekord, dlatego polecenie adRs. Fields(0).Value zwróci jedyną wartość ze zbioru rekordów. Pobieranie danych z serwerów SQL Server za pomocą ADO może prowadzić do spadku wydajności aplikacji (zwłaszcza gdy w kodzie znajduje się kilka wywołań kierowanych do serwera). Jednym ze sposobów przyspieszania pracy programu jest utrzymywanie otwartego połączenia przez cały czas, gdy jest potrzebne, zamiast zamykania go po wykonaniu każdej procedury.
904
Część VII Zaawansowane techniki programowania w Accessie
Zmienną przechowującą obiekt typu ADODB.Connection można utworzyć jako zmienną z poziomu modułu i otwierać połączenie tylko wtedy, gdy nie zostało wcześniej otwarte. Obiekty typu Connection mają właściwość State, która pozwala ustalić, czy połączenie jest otwarte. Wartość 1 tej właściwości oznacza, że połączenie jest otwarte, a wartość 0 informuje, że połączenie jest zamknięte. Na rysunku 29.28 pokazano zmodyfikowaną wersję procedury GetSQLServerDataWithADO z wcześniejszej części tego punktu. Tu zmienna Connection jest zmienną z poziomu modułu. Ponadto nowa wersja wyświetla czas działania procedury obliczony na podstawie prostych pomiarów.
Rysunek 29.28. Używanie zmiennej Connection z poziomu modułu
W oknie Immediate na rysunku 29.28 widać, ile czasu zajmuje pierwsze i drugie wykonanie procedury. Pierwsze wykonanie, gdy połączenie jest zamknięte, zajmuje prawie 2 sekundy. Przy drugim wykonaniu połączenie wciąż jest otwarte. Dzięki temu procedura działa tak szybko, że za pomocą funkcji Timer języka VBA nie da się zmierzyć czasu jej wykonywania. Utrzymywanie otwartego połączenia wymaga jednak więcej pamięci, dlatego w zależności od projektu trzeba znaleźć odpowiednią równowagę między szybkością pracy a zużyciem pamięci. W wersjach Accessa starszych niż 2013 obsługiwane były pliki ADP (ang. Access Data Projects). Pliki te umożliwiały bezpośrednio połączenie się z serwerem SQL Server. Access udostępniał także narzędzie do rozbudowy baz do ich odpowiedników dla serwera SQL Server. Choć istniejące pliki ADP nadal działają w Accessie, w nowej wersji nie można ich tworzyć. Ponadto pliki ADP są obsługiwane tylko do wersji 2008 serwera SQL Server. Microsoft zachęca programistów, aby zamiast plików ADP korzystali z usług SharePointa.
Rozdział 29. Integrowanie baz SQL Server i Access
905
Praca z obiektami serwera SQL Server SQL Server obejmuje wiele typów obiektów, które nie występują w Accessie. SQL Server obsługuje takie obiekty baz danych jak procedury składowane, funkcje i wyzwalacze. Do tego miejsca opisywano tylko korzystanie w Accessie z tabel dołączonych z baz SQL Server, jednak większość takich baz obejmuje nie tylko tabele. Istnieją dwie techniki współużytkowania danych z baz SQL Server na poziomie tabel:
Importowanie tabel z serwera SQL Server do Accessa. Jakakolwiek zmiana wykonana na kopii w Accessie nie będzie miała odbicia na serwerze SQL Server. I jakakolwiek zmiana wprowadzona do tych samych tabel w SQL Serverze będzie wymagała ponownego odświeżenia w Accessie, co w tym przypadku oznacza pełne i kompletne ponowne zaimportowanie całej tabeli. Można wykorzystać kod VBA do utworzenia procesu automatycznej aktualizacji, jednak rozwiązanie to może być niewydajne przy pracy z dużymi zbiorami danych.
Odnośniki do tabel, które pozostają w serwerze SQL Server. Połączone tabele mogą aktualizować dane serwera, ponieważ tabela i dane nadal znajdują się na serwerze SQL Server, a nie w Accessie. W praktyce interakcja pomiędzy tabelą Accessa podłączoną do serwera SQL Server jest tak płynna, że większość użytkowników nawet nie zdaje sobie sprawy z tego, że pracuje na danych zdalnych.
Używanie tabel z serwera SQL Server w Accessie W punkcie „Łączenie serwera SQL Server z Accessem” we wcześniejszej części rozdziału opisaliśmy tworzenie w Accessie tabeli, która jest połączona z serwerem SQL Server. W tym punkcie omawiamy importowanie danych z baz SQL Server i różnice między łączeniem a importowaniem. Aby zaimportować tabelę SalesLT.Customer z bazy danych AdventureWorksLT2012, wykonaj następujące czynności: 1. Wybierz opcję Baza danych ODBC z zakładki DANE ZEWNĘTRZNE na wstążce. Pojawi się okno dialogowe Pobieranie danych zewnętrznych — Baza danych ODBC. 2. Wybierz opcję Importuj…, co pokazano na rysunku 29.29, i kliknij przycisk OK. 3. W oknie dialogowym Wybierz źródło danych zaznacz plik AdventureWorks.dsn utworzony we wcześniejszej części rozdziału i kliknij przycisk OK. Pojawi się okno dialogowe importowania obiektów, w którym zobaczysz wszystkie obiekty z bazy danych AdventureWorks. 4. Wybierz z listy tabelę SalesLT.Customer i kliknij przycisk OK. Na rysunku 29.30 pokazano okno dialogowe importowania obiektów z zaznaczoną odpowiednią tabelą. 5. Kliknij przycisk Zamknij w oknie dialogowym Zapisz kroki importowania, aby zakończyć proces.
906
Część VII Zaawansowane techniki programowania w Accessie
Rysunek 29.29. W oknie dialogowym Pobieranie danych zewnętrznych — Baza danych ODBC wybierz opcję Importuj… Rysunek 29.30. Wybierz obiekt do zaimportowania
Jeśli dołączyłeś tabelę SalesLT.Product na podstawie instrukcji z wcześniejszego punktu i zaimportowałeś tabelę SalesLT.Customer, okienko nawigacji powinno wyglądać tak jak na rysunku 29.31.
Rozdział 29. Integrowanie baz SQL Server i Access
907
Rysunek 29.31. W okienku nawigacji widoczne są połączone i zaimportowane tabele
Na rysunku 29.31 ikona tabeli połączonej to kula ziemska, natomiast ikona zaimportowanej tabeli niczym nie różni się od ikony natywnych tabel Accessa. Ikony są identyczne, ponieważ SalesLT_Customer jest natywną tabelą Accessa. Jedyna różnica między nią a tabelami budowanymi od podstaw dotyczy sposobu ich utworzenia. Jeśli spróbujesz dołączyć tabelę o nazwie identycznej z nazwą istniejącej tabeli, Access doda do nazwy liczbę całkowitą. Gwarantuje to, że nazwa będzie niepowtarzalna. Jeżeli zaimportujesz (lub dołączysz) tabelę SalesLT_Product więcej niż raz, powstanie tabela SalesLT_Product1.
Na rysunku 29.32 pokazano dodawanie nowego rekordu do tabeli SalesLT_Customer. Rysunek 29.32. Dodawanie nowego rekordu do zaimportowanej tabeli
Pole CustomerID w rekordzie nowego klienta dodanym na rysunku 29.32 ma wartość 30119. Gdy wykonasz w narzędziu SQL Server Management Studio kwerendę przedstawioną na rysunku 29.33, przekonasz się, że w bazie SQL Server nie ma nowego rekordu. Na tym polega główna różnica między tabelami połączonymi a zaimportowanymi. Wprowadzenie zmian w zaimportowanej tabeli nie prowadzi do zmian w bazie SQL Server. Podobnie modyfikacje wprowadzone w danych w bazie SQL Server nie są odzwierciedlane w Accessie.
908
Część VII Zaawansowane techniki programowania w Accessie
Rysunek 29.33. Zmiany wprowadzone w zaimportowanych tabelach nie są odzwierciedlane na serwerze SQL Server
Dane z zaimportowanych tabel nie są automatycznie aktualizowane w żadnym miejscu. Natomiast dane z tabel połączonych są bardzo szybko synchronizowane między obiema bazami. Zachowanie synchronizacji danych to kosztowny proces. Silnik bazodanowy Accessa musi wykrywać zmiany na serwerze SQL Server, a gdy użytkownik chce uzyskać dostęp do najnowszych danych, silnik pobiera je z takiego serwera. Na rysunku 29.34 widoczna jest prosta instrukcja SQL-a w narzędziu SQL Server Management Studio. Instrukcja ta dodaje nowy rekord do tabeli SalesLT.Product z bazy AdventureWorks. Pod edytorem SQL-a znajduje się siatka ilustrująca, że nowy rekord został dodany do tabeli SalesLT.Product. Oto skrypt zastosowany na rysunku 29.34: INSERT INTO SalesLT.Product (Name, ProductNumber, StandardCost, ListPrice, SellStartDate) VALUES ('Nowy rower', 'NN-1234', 99, 299, 2012-01-01) SELECT * FROM SalesLT.Product WHERE ProductID > 995;
Rozdział 29. Integrowanie baz SQL Server i Access
909
Rysunek 29.34. Wprowadzanie zmian bezpośrednio w tabelach na serwerze SQL Server
Gdy uruchomisz ten krótki skrypt SQL-a na serwerze SQL Server, a następnie otworzysz połączoną tabelę SalesLT_Product w Accessie (jeśli tabela jest już otwarta, wciśnij klawisz F5, aby ją odświeżyć), zobaczysz, że w tabeli znajduje się teraz rekord dodany chwilę wcześniej na serwerze SQL Server (zobacz rysunek 29.35).
Rysunek 29.35. Zmiany z serwera SQL Server są automatycznie odzwierciedlane w połączonych tabelach Accessa
910
Część VII Zaawansowane techniki programowania w Accessie
Synchronizacja tabel połączonych zachodzi obustronnie. W przykładzie rekord dodany na serwerze SQL Server pojawia się w tabeli połączonej w Accessie. Gdyby dodać rekord w Accessie, pojawiłby się na serwerze SQL Server.
Widoki Kolejnym obiektem używanym w bazach danych SQL Server są widoki. Widok to tak naprawdę zapisana kwerenda, która łączy tabele oraz sortuje i filtruje dane. Gdy w Accessie tworzony jest formularz, w jego tle generowana jest kwerenda. Obiekty widoku serwera SQL Server tworzą podobny do tabeli obiekt oparty na instrukcji SQL-a, który po uruchomieniu może złączać tabele, sortować dane i wykonywać inne podstawowe operacje na danych. Kiedy aplikacja kliencka używa widoku, serwer wykonuje polecenia SQL-a, tworząc w ten sposób zbiór danych przypominający tabelę. W efekcie kwerenda Accessa może być wykonywana w widoku serwera SQL Server, tak jakby widok ten był fizyczną tabelą. Kiedy dostęp do widoku uzyskiwany jest poprzez polecenie SELECT Accessa, SQL Server uruchamia instrukcję SQL-a z widoku na tabelach powiązanych z widokiem i zwraca rekordy do klienta. Rysunek 29.36 pokazuje tworzenie widoku na serwerze SQL Server. Widok ten złącza tabele zamówień i klientów, przy czym uwzględniane są tylko zamówienia, w których pole Status ma wartość 5.
Rysunek 29.36. Tworzenie widoku w bazie SQL Server
Rozdział 29. Integrowanie baz SQL Server i Access
911
W Accessie widok ten to jedna z tabel z bazy SQL Server. Widok można dołączyć tak jak natywną tabelę bazy SQL Server, co pokazano na rysunku 29.37.
Rysunek 29.37. Widok to odpowiednik tabeli lub arkusza danych z Accessa
Tu w procesie dołączania określono, że do identyfikowania wierszy ma służyć pole SalesOrderID. Unikatowy identyfikator potrzebny jest do tego, by po zmianie widoku w Accessie mógł on poinformować bazę danych SQL Server, który z wierszy został zaktualizowany. Bez unikatowego identyfikatora nie byłoby możliwe, by Access poprawnie aktualizował dane serwera SQL Server.
Procedury składowane Choć procedury składowane w bazach SQL Server pozornie przypominają kwerendy Accessa, często wykonują wiele operacji na danych na poziomie silnika bazodanowego. Dialekt SQL-a używany w bazach SQL Server obsługuje pętle, zmienne, tabele tymczasowe, setki różnych wbudowanych funkcji serwera SQL Server (m.in. funkcję zwracającą bieżącą datę i godzinę) oraz wiele innych zadań. Procedury składowane, funkcje i wyzwalacze nie są kwerendami. Procedura składowana jest blokiem poleceń SQL-a, który jest wykonywany jako niezależna jednostka.
Jednym ze sposobów wykorzystania procedur składowanych jest utworzenie podręcznego kontenera przechowującego wszystkie polecenia SQL-a, które używane są w całej aplikacji. Zamiast pisać polecenia SQL-a w kodzie takiej aplikacji, można przechowywać je w bazie danych w formie procedur składowanych, gdyż wywoływanie ich z poziomu kodu aplikacji odbywa się w ten sam sposób, co wywoływanie funkcji VBA. Oto wybrane zalety procedur składowanych:
Mogą one zawierać wiele poleceń języka SQL.
Mogą wywoływać inne procedury składowane.
912
Część VII Zaawansowane techniki programowania w Accessie
Mogą otrzymywać parametry i zwracać wyniki lub grupy wyników.
Są przechowywane we wstępnie skompilowanej, interpretowalnej formie na serwerze bazy danych, tak więc wykonują się szybciej niż w przypadku osadzenia ich w kodzie. Innymi słowy, procedury składowane nie są zazwyczaj wkompilowane w relacyjną bazę danych w formie kodu binarnego, ale są na ogół wstępnie parsowane i częściowo wstępnie wykonywane, co zwiększa ich wydajność.
Przechowywane są we wspólnym kontenerze w aplikacji, tak więc inni mogą nimi łatwo zarządzać, ponieważ zmniejsza to ilość kodu odpowiedzialnego za dostęp do bazy.
Po dodaniu procedury składowanej do bazy danych SQL Server jest ona dostępna dla każdego klienta używającego tej bazy. Oznacza to, że aplikacja bazodanowa Accessa przeznaczona na komputery biurkowe wykona dokładnie te same instrukcje, co aplikacja sieciowa napisana za pomocą środowiska Visual Studio .NET (oczywiście jeśli oba programy wywołają tę samą procedurę składowaną).
Niektóre z wad procedur składowanych to:
Nadużywanie procedur składowanych może powodować umieszczenie zbyt dużej ilości logiki biznesowej w bazie danych. Może to w pewnych sytuacjach spowodować, że logika biznesowa odpowiedzialna za przetwarzanie danych będzie działać bardzo niewydajnie. Niektóre rodzaje przetwarzania danych najlepiej pozostawić kodowi aplikacji, który jest lepiej przystosowany do tego typu działań.
Nadużywanie procedur składowanych do dostępu do danych może w niektórych przypadkach być przyczyną poważnych problemów z wydajnością sieci.
Procedury składowane z baz SQL Server najczęściej uruchamia się za pomocą kodu ADO. Oto krótki przykładowy kod wywołujący procedurę składowaną z bazy SQL Server: Public Sub StoredProcTest() Dim Dim Dim Dim
adCn As ADODB.Connection adCmd As ADODB.Command adRs As ADODB.Recordset sConn As String
Const sPROCNAME = "dbo.uspGetProductModel" sConn = "driver={sql server};" _ & "server=DICK-PC\SQLEXPRESS;" _ & "Database=AdventureWorksLT2012;" _ & "UID=;PWD=;" Set adCn = New ADODB.Connection adCn.Open sConn Set adCmd = New ADODB.Command adCmd.ActiveConnection = adCn adCmd.CommandText = sPROCNAME adCmd.CommandType = adCmdStoredProc adCmd.Parameters.Refresh
Rozdział 29. Integrowanie baz SQL Server i Access
913
adCmd.Parameters(1).Value = 10 Set adRs = adCmd.Execute Debug.Print adRs.GetString adRs.Close adCn.Close Set adRs = Nothing Set adCmd = Nothing Set adCn = Nothing End Sub
Kod ten jest celowo uproszczony. Pokazano w nim, jak wywołać w ADO procedurę składowaną z bazy SQL Server, pobrać wartość zwracaną przez tę procedurę (zbiór rekordów), a następnie wykorzystać uzyskany zbiór rekordów w Accessie. Tu połączenie z bazą SQL Server nawiązywane jest za pomocą dostawcy ADO, a nie sterowników ODBC. Oto używana procedura składowana z bazy SQL Server: CREATE PROCEDURE uspGetProductModel @pm_id int AS BEGIN SELECT * FROM SalesLT.ProductModel WHERE SalesLT.ProductModel.ProductModelID = @pm_id END
Wyzwalacze Wyzwalacz jest fragmentem kodu w SQL-u, który jest wykonywany, gdy nastąpi pewna akcja na tabeli bazy danych. Wyzwalaczy nie używa się bezpośrednio. Wyzwalacz oczekuje na zmiany i po ich wykryciu wykonuje operacje. Standardowe typy wyzwalaczy to przed (FOR w serwerze SQL Server), po (AFTER w serwerze SQL Server) i zamiast (INSTEAD OF w serwerze SQL Server). Jak nazwa wskazuje, wyzwalacz przed wykonuje operacje przed zmianą w tabeli, podczas gdy wyzwalacz po działa po zmianie danych. Największym niebezpieczeństwem związanym z wyzwalaczami jest to, że mogą one rekurencyjnie wywoływać siebie nawzajem raz za razem, co powoduje poważne problemy z wydajnością. Weźmy za przykład wyzwalacz AFTER modyfikujący dane w tabeli: jeśli zmiana powoduje ponowne wywołanie wyzwalacza, może wystąpić pętla nieskończona. Tworzenie wyzwalacza jest bardzo podobne do pisania procedury lub funkcji. Poniższy przykład tworzy wpis w pliku dziennika za każdym razem, gdy dodawany jest produkt: USE test CREATE TRIGGER LogEntries ON Products FOR INSERT INSERT INTO LogFile(id, event) VALUES (, 'Dodano nowy produkt');
914
Część VII Zaawansowane techniki programowania w Accessie
Rozdział 30.
Dostosowywanie wstążek W tym rozdziale:
Praca ze wstążką domyślną
Omówienie architektury wstążki
Zapoznanie się z formantami wstążki
Przedstawienie kodu XML niezbędnego do skonstruowania wstążki
Dodawanie odwołań do kodu VBA
Jeśli korzystałeś z wersji Accessa nowszych niż 2003, prawdopodobnie znasz już wstążki pakietu Office. Wstążki wprowadzono w pakiecie Office 2007 jako zastępnik systemu pasków narzędzi i menu, który przez wiele lat był dominującym rozwiązaniem w świecie komputerów. Paski narzędzi i menu są efektywnym elementem interfejsu użytkownika, gdy użytkownicy potrzebują uzyskać dostęp do różnych zadań i czynności. Jednak model obiektu CommandBar używany w wersjach Accessa starszych niż 2007 był względnie skomplikowany i trudny do programowania. Wstążka oferuje zupełnie nowy sposób pracy z komponentami interfejsu użytkownika. Wstążka nie przypomina tradycyjnych pasków narzędzi i menu oraz obsługuje właściwości, które nie były dostępne dla pasków narzędzi i menu. Jak się wkrótce okaże, dostosowywanie pasków narzędzi w najnowszym Accessie znacznie się różni od używania CommandBar do komponowania menu i pasków narzędzi w poprzednich wersjach Accessa. W bazie danych Rozdział30.accdb nie będzie możliwe obejrzenie tabeli USysRibbons, dopóki nie kliknie się prawym przyciskiem myszy na okienko nawigacyjne, nie wybierze polecenia Opcje nawigacji i nie zaznaczy pola opcji Pokaż obiekty systemowe w oknie dialogowym Opcje nawigacji. W bazie tej znajduje się zbiór plików XML używanych w tym rozdziale.
916
Część VII Zaawansowane techniki programowania w Accessie
Hierarchia wstążki Wstążka sama w sobie jest dość złożoną strukturą i ma naturę hierarchiczną. Na najwyższym poziomie znajdują się zakładki (nazywane też kartami) widoczne na górze wstążki. Każda zakładka zawiera jedną lub więcej grup, z których każda zawiera jeden lub więcej formantów. Wstążkę w dużym stopniu dostosowuje się do wykonywanych zadań, dlatego dalszy opis może nieco odbiegać od tego, co widzisz na ekranie.
Zakładki — najwyższy obiekt hierarchii wstążki. Używa się ich do rozdzielania najważniejszych, podstawowych operacji w logiczne grupy. Na przykład domyślna wstążka programu Access zawiera cztery zakładki: NARZĘDZIA GŁÓWNE, TWORZENIE, DANE ZEWNĘTRZNE oraz NARZĘDZIA BAZY DANYCH. Menu PLIK można otworzyć w taki sam sposób jak zakładki, ale działa zupełnie inaczej. Menu to otwiera obszar zaplecza, gdzie dostępne są standardowe operacje na plikach.
Grupy — drugi najważniejszy poziom w hierarchii wstążki. Grupy zawierają dowolną liczbę różnych typów formantów i są używane do logicznego grupowania operacji obsługiwanych przez wstążkę. Na rysunku 30.1 zakładka NARZĘDZIA GŁÓWNE zawiera siedem grup: Widoki, Schowek, Sortowanie i filtrowanie, Rekordy, Znajdowanie, Okno oraz Formatowanie tekstu.
Rysunek 30.1. Domyślna wstążka
Formanty — na rysunku 30.1 widać różne typy formantów w każdej z grup na zakładce NARZĘDZIA GŁÓWNE. Grupa Widoki zawiera pojedynczy formant, podczas gdy w grupie Formatowanie tekstu jest ich aż 18. Zazwyczaj formanty w jednej grupie są ze sobą powiązane, ale nie musi tak być.
Podczas tworzenia własnych wstążek Accessa należy pamiętać o tych podstawowych zasadach hierarchii. Firma Microsoft spędziła mnóstwo czasu na eksperymentowaniu i testowaniu wstążki pakietu Office, dzięki czemu sprawdza się on dobrze w szerokim zakresie aplikacji. Maksymalna liczba zakładek, które można dodać do niestandardowej wstążki, wynosi 100. To bardzo dużo. Dla innych obiektów obowiązują podobnie wysokie limity. Oczywiście zbyt wiele zakładek lub grup będzie problemem dla użytkowników. Mówiąc ogólnie, należy projektować wstążki w sposób konserwatywny, uwzględniając na każdym z poziomów jedynie elementy, które są naprawdę niezbędne użytkownikom. Microsoft zaleca udostępnianie czterech lub pięciu zakładek (nigdy nie więcej niż siedmiu).
Formanty dla wstążek Wstążka Accessa obsługuje większą liczbę formantów niż starsze paski narzędzi. W poprzednich wersjach Accessa typ i różnorodność formantów, które można było dodawać do menu i pasków narzędzi, były mocno ograniczone. Większość pasków narzędzi składała
Rozdział 30. Dostosowywanie wstążek
917
się z przycisków i była możliwość umieszczania list rozwijanych, ale dodawanie do pasków narzędzi wyrafinowanych lub złożonych formantów było ograniczone. Wstążki Accessa mogą zawierać przyciski, pola tekstowe, etykiety, separatory, pola wyboru, przełączniki, pola edycji, a nawet formanty zagnieżdżone. W niniejszym rozdziale jest miejsce na omówienie tylko kilku formantów. Jednak na stronie Microsoft Office (http://office.microsoft.com) znajdziesz przykłady ilustrującej, jak wykorzystać praktycznie każdy typ formantu wstążki programu Access. Access obsługuje pewne bardzo interesujące formanty, których można używać na własnych wstążkach. Formanty te używane są w domyślnej wstążce programu Access i są dostępne dla użytkowników do wykorzystania w ich własnych aplikacjach. Formanty te nie mają jakichkolwiek odpowiedników w starszych wersjach Accessa — są zupełnie nowe. Przycisk rozdzielenia Przycisk rozdzielenia jest podobny do tradycyjnego przycisku w interfejsie Accessa. Wyróżnia go to, że całkiem dosłownie rozdziela dwa różne formanty (w pionie lub poziomie). Lewa lub górna strona formantu działa jak zwykły przycisk i reaguje na pojedyncze kliknięcie. Prawa lub dolna strona przycisku zawiera strzałkę wskazującą w prawo, która po kliknięciu odsłania listę wyboru opcji. Przykładowy przycisk rozdzielenia widoczny na rysunku 30.2 To przycisk Widok z zakładki NARZĘDZIA GŁÓWNE. Rysunek 30.2. Przycisk rozdzielenia to wartościowy formant wstążki
Można kliknąć górną część przycisku Widok, aby przełączyć się do widoku projektu. Można też kliknąć strzałkę na tym przycisku i rozwinąć listę pozostałych opcji. Na liście wyboru przycisku rozdzielenia można wybrać tylko jedną opcję. Gdy tylko element zostanie wybrany, przycisk rozdzielenia się zamyka, a wybrana akcja jest wykonywana. Część formantu rozdzielenia pełniącą funkcję przycisku można zaprogramować. Rozwinięcie Formant Rozwinięcie pokazany jest na rysunku 30.3. Chociaż wygląda bardzo podobnie do pola kombi lub listy rozwijanej, nie jest to ten sam typ obiektu. Zauważ, że elementy w rozwinięciu z rysunku 30.3 zawierają nie tylko tekst (Wyczyść wszystkie filtry, Filtruj wg formularza itd.), ale również obrazek i etykietkę ekranową (niewidoczną na rysunku 30.3) skojarzoną z każdym elementem listy.
918
Część VII Zaawansowane techniki programowania w Accessie
Można wybrać tylko jeden element, co zapewnia użytkownikom łatwy w zrozumieniu interfejs, jeśli występuje ograniczona liczba opcji. Przycisk rozdzielenia oraz Rozwinięcie są do siebie w wielu aspektach bardzo podobne. Oba obiekty po kliknięciu pokazują listę ze spisem elementów, które można uruchomić jednym kliknięciem. Główna różnica jest taka, że Przycisk rozdzielenia jest dosłownie podzielony na dwie części (poziome lub pionowe), natomiast Rozwinięcie po prostu się rozwija po kliknięciu. Galeria Galeria prezentuje użytkownikowi skrócony podgląd różnych opcji formatowania i innych zadań. Rysunek 30.4 pokazuje galerię motywów dla raportów. Rysunek 30.4. Galeria zapewnia użytkownikowi podgląd opcji
Formant Galeria jest powszechnie używany w Accessie do wyświetlania opcji takich jak kolor tekstu, kolor tła czy krój czcionki.
Rozdział 30. Dostosowywanie wstążek
919
Przycisk Przycisk to znany formant z interfejsu użytkownika ze starszych wersji Accessa, opartego na paskach CommandBar. Przycisk można kliknąć, aby wykonać operację. Nie udostępnia on list (w odróżnieniu od rozwinięcia i galerii), jednak może otwierać okno dialogowe z dodatkowymi opcjami. Przykładowy formant tego rodzaju to przycisk Kopiuj z grupy Schowek zakładki NARZĘDZIA GŁÓWNE. Kliknięcie tego przycisku powoduje skopiowanie bieżącego elementu do schowka, przy czym nie można użyć innych opcji lub wykonać innych operacji. Przełącznik Przełącznik to specjalny rodzaj przycisku używany do ustawiania stanu lub warunku w aplikacji. Przełączniki mają dwa stany — włączony i wyłączony. Gdy przełącznik jest wyłączony, wygląda jak zwykły przycisk na wstążce. Gdy zostanie włączony, zmieni się kolor tła (czasem modyfikowana jest też etykietka ekranowa). Rysunek 30.5 przedstawia włączony przełącznik Przełącz filtr. Zmiana w wyglądzie informuje, że zastosowano filtr. Etykietka ekranowa zmienia się z Zastosuj filtr na Usuń filtr. Rysunek 30.5. Wygląd przełącznika zmienia się w zależności od stanu
Pole kombi Pole kombi na wstążce bardzo przypomina pole kombi z formularza. Jest połączeniem pola tekstowego i pola listy. Użytkownik może wpisać tekst bezpośrednio w polu kombi lub kliknąć skierowaną w dół strzałkę, aby wyświetlić listę opcji. Przykładowym polem kombi jest formant Czcionka z grupy Formatowanie tekstu z zakładki NARZĘDZIA GŁÓWNE. Pole wyboru Pole wyboru to następny formant, który może już znasz. Wygląda i działa jak pola wyboru umieszczane na formularzach. Po kliknięciu pola wyboru w polu pojawia się symbol zaznaczenia. W przeciwnym razie pole jest puste. Polem wyboru jest na przykład formant Wartość wymagana w grupie Sprawdzanie poprawności pola z zakładki NARZĘDZIA TABEL.
Specjalne mechanizmy wstążki Na wstążce działają też dwa inne specjalne mechanizmy, o których warto wspomnieć. Dla niektórych formantów dostępne są superwskazówki pozwalające wyświetlać więcej informacji niż w etykietkach ekranowych. Ponadto wstążkę można ukryć, aby zwiększyć ilość dostępnego miejsca.
920
Część VII Zaawansowane techniki programowania w Accessie
Superwskazówki Superwskazówka jest bardzo podobna do etykietki ekranowej (obiektu ToolTip), która używana była w poprzednich wersjach Accessa. Jest względnie duża i zawiera tekst, który określił programista, co ułatwia zrozumienie zadania formantu. Superwskazówka pokazana na rysunku 30.6 pojawia się po najechaniu przez użytkownika wskaźnikiem myszy na formant wstążki. Rysunek 30.6. Superwskazówka udostępnia użytkownikowi pomocne informacje
Przykładowa superwskazówka z rysunku 30.6 jest wyświetlana po najechaniu kursorem myszy na przycisk Znajdź z zakładki NARZĘDZIA GŁÓWNE. Superwskazówka jest większa od etykietki ekranowej i wyświetla więcej informacji, np. klawisz skrótu i dłuższe wyjaśnienie funkcji. Zwijanie wstążki Domyślnie wstążka jest zawsze otwarta na ekranie. Jednak wstążka razem z wyświetlanymi formantami i zakładkami jest stosunkowo duża i może przeszkadzać w trakcie korzystania z aplikacji. Jest kilka sposobów, by ją ukryć. Najłatwiejszy polega na wciśnięciu kombinacji klawiszy Ctrl+F1 lub dwukrotnym kliknięciu dowolnej zakładki. Ponowne wybranie kombinacji Ctrl+F1 powoduje rozwinięcie wstążki, po czym pozostaje ona widoczna. Pojedyncze kliknięcie dowolnej zakładki prowadzi do tymczasowego rozwinięcia wstążki. Będzie ona ukrywana automatycznie, dopóki użytkownik nie kliknie dwukrotnie dowolnej zakładki w celu przywrócenia domyślnego stanu wstążki. W prawym dolnym rogu wstążki znajduje się przycisk Zwiń/Przypnij wstążkę. Gdy wstążka jest rozwinięta, ma on postać małej strzałki. Jeśli wstążka jest ukryta, przycisk przyjmuje formę pinezki. Na rysunku 30.7 pokazano przycisk Zwiń/Przypnij wstążkę w obu stanach. Formularze i raporty otwarte w momencie zwijania lub rozwijania wstążki są przesuwane w górę lub w dół, tak aby ich pozycja względem wstążki pozostała taka sama. Na przykład formularz otwarty bezpośrednio pod wstążką zostanie przeniesiony w górę, tak by odległość między górną krawędzią formularza a dolną krawędzią wstążki się nie zmieniła.
Rozdział 30. Dostosowywanie wstążek
921
Rysunek 30.7. Wstążkę można ukryć lub rozwinąć
Modyfikowanie domyślnej wstążki W Accessie 2010 pojawiła się możliwość modyfikowania wstążki domyślnej. Wprowadzone zmiany są widoczne na komputerze, na którym je wprowadzono, jednak w edytorze wstążek można wyeksportować zmodyfikowaną wersję. W oknie Dostosowywanie Wstążki (zobacz rysunek 30.8) wykorzystano technikę dwóch list. Na jednej liście znajdują się dostępne, a na drugiej — wybrane polecenia. Modyfikowaną kategorię (Karta Plik, Karty główne, Makra, Wszystkie polecenia, Popularne polecenia itd.) można wybrać z listy rozwijanej widocznej po lewej stronie. Następnie za pomocą strzałek skierowanych w lewo i w prawo (widocznych między listami) można przenosić elementy lub usuwać je ze wstążek. W Accessie istnieje tylko jedna wstążka, na której jednak znajduje się szereg głównych zakładek: PODGLĄD WYDRUKU, NARZĘDZIA GŁÓWNE, TWORZENIE, DANE ZEWNĘTRZNE, NARZĘDZIA BAZY DANYCH, KONTROLA ŹRÓDŁA i DODATKI. Na karcie NARZĘDZIA GŁÓWNE znajduje się kilka grup, np. Widoki, Schowek oraz Sortowanie i filtrowanie. Domyślna wstążka nie umożliwia dodawania lub usuwania zakładek i poleceń, ale można usuwać poszczególne grupy. Można usunąć całe grupy wbudowane, natomiast nie można pozbyć się poszczególnych instrukcji z danej grupy. Można wykorzystać przyciski widoczne pod prawą listą, aby dodać nowe niestandardowe zakładki lub nowe grupy na istniejących zakładkach wstążki. Wykorzystanie nowej niestandardowej zakładki lub grupy to jedyny sposób, by dodać polecenia z lewej listy do widocznej po prawej stronie definicji wstążki. Instrukcji nie można umieszczać bezpośrednio na zakładkach — polecenia muszą się znajdować w grupach. Dodanie polecenia do grupy jest proste: wystarczy wybrać instrukcję na lewej liście, wskazać na prawej liście niestandardową grupę, w której ma się znaleźć dane polecenie, a następnie kliknąć skierowaną w prawo strzałkę między listami. Jeśli chcesz ukryć „niebezpieczne” polecenia przed użytkownikami, musisz usunąć wbudowaną grupę z niepożądaną instrukcją, dodać niestandardową grupę, umieścić ją na odpowiedniej karcie, a następnie dodać do grupy tylko te polecenia, do których użytkownicy mają mieć dostęp. Kliknij nową grupę prawym przyciskiem myszy i wybierz
922
Część VII Zaawansowane techniki programowania w Accessie
Rysunek 30.8. Okno projektowe wstążki umożliwia jej modyfikowanie
opcję Zmień nazwę z menu podręcznego lub zaznacz nową grupę i kliknij przycisk Zmień nazwę pod listą Dostosuj Wstążkę. Pojawi się okno dialogowe Zmienianie nazwy (zobacz rysunek 30.9). W oknie tym przypisz do grupy nową nazwę i wybierz ikonę grupy. Rysunek 30.9. Zmiana nazwy niestandardowej grupy i ustawianie jej ikony
W razie potrzeby można ukryć wbudowane zakładki wstążki. Zwróć uwagę na pola wyboru obok pozycji na prawej liście z rysunku 30.9. Usunięcie zaznaczenia powoduje ukrycie danej zakładki przed użytkownikami. Jeśli zakładka obejmuje polecenia, do których użytkownicy mają mieć dostęp, można dodać niestandardową zakładkę (za pomocą przycisku Nowa karta pod listą Dostosuj Wstążkę widoczną po prawej stronie rysunku 30.8), a następnie w razie potrzeby dodać niestandardowe grupy. W ostatnim kroku należy umieścić w niestandardowych grupach potrzebne polecenia.
Rozdział 30. Dostosowywanie wstążek
923
Często łatwiej jest ukryć zakładki niż usunąć je ze wstążki. Ukryte zakładki można w razie potrzeby łatwo przywrócić. Po prawej stronie okna projektowego wstążki znajdują się strzałki skierowane w górę i w dół. Pozwalają one zmieniać rozmieszczenie zakładek i grup na zakładkach. Można na przykład dodać niestandardową grupę (lub wykorzystać istniejącą) i za pomocą strzałek skierowanych w górę i w dół przenieść na nią najczęściej używane polecenia. Jeśli wprowadzone zmiany są niezgodne z oczekiwaniami, można kliknąć przycisk Resetuj, aby przywrócić pierwotną wersję wbudowanej wstążki. Przycisk ten (zwróć uwagę na strzałkę w dół widoczną na rysunku 30.8) pozwala zresetować całą wstążkę lub tylko wybrane zakładki. Za pomocą przycisku Importuj/Eksportuj widocznego pod listą Dostosuj Wstążkę można wyeksportować wprowadzone we wstążce zmiany do zewnętrznego pliku. Na liście, która pojawia się po kliknięciu przycisku Importuj/Eksportuj, znajduje się też polecenie importowania pliku ze zmianami. Plik ten można zastosować do wstążki. Nie jest zaskoczeniem, że plik ze zmianami ma format XML, który używany jest we wszystkich aplikacjach pakietu Office 2013. Plik ze zmianami pozwala łatwo wprowadzić niestandardowe poprawki we wstążce w komputerach wszystkich użytkowników korzystających z aplikacji Accessa 2013. Jest to także doskonały sposób na zarchiwizowanie zmian (w razie potrzeby można ją później ponownie wprowadzić). Można na przykład skonfigurować wstążkę dokładnie tak, jak mają widzieć ją użytkownicy, wyeksportować zmiany, a następnie ją zresetować, aby przywrócić jej pierwotny stan. Dzięki temu programista będzie miał dostęp do wszystkich funkcji wstążki w trakcie prac nad aplikacją.
Praca z paskiem narzędzi Szybki dostęp Pasek narzędzi Szybki dostęp (ang. Quick Access Toolbar — QAT) znajduje się w górnej lewej części okna Accessa (zobacz rysunek 30.10), bezpośrednio nad przyciskiem PLIK. Pasek ten pozostaje widoczny w Accessie przez cały czas i pozwala zapewnić użytkownikom szybki dostęp do powszechnie wykonywanych zadań, takich jak otwieranie pliku bazy danych lub wysyłanie obiektu do drukarki. Pasek narzędzi Szybki dostęp jest w pełni konfigurowalny. Zawiera listę formantów domyślnych, przy czym niektóre z nich są ukryte. Można je wyświetlić lub schować za pomocą menu paska narzędzi (zobacz rysunek 30.10). W każdej chwili do paska można dodać dowolnie dużą liczbę poleceń. Ponadto formanty dodawane do paska narzędzi Szybki dostęp mają zastosowanie albo do bieżącej bazy danych, albo do wszystkich baz danych Accessa. Najłatwiejszy sposób dodania instrukcji do paska narzędzi Szybki dostęp polega na znalezieniu polecenia na wstążce Accessa, kliknięciu go prawym przyciskiem myszy i wybraniu opcji Dodaj do paska narzędzi Szybki dostęp z menu podręcznego. Access doda wtedy wybraną instrukcję z prawej strony paska.
924
Część VII Zaawansowane techniki programowania w Accessie
Rysunek 30.10. Pasek narzędzi Szybki dostęp widoczny jest przez cały czas
Więcej możliwości w zakresie modyfikowania paska narzędzi Szybki dostęp daje specjalne okno. Aby je otworzyć, kliknij zakładkę PLIK w lewym górnym rogu głównego okna Accessa, a następnie kliknij przycisk Opcje widoczny w dolnej części listy. W oknie Opcje programu Access otwórz zakładkę Pasek narzędzi Szybki dostęp. Pojawi się ekran Dostosowywanie paska narzędzi Szybki dostęp (zobacz rysunek 30.11). Rysunek 30.11. Można łatwo dodawać nowe polecenia do paska narzędzi Szybki dostęp
Rozdział 30. Dostosowywanie wstążek
925
Podobnie jak w oknie do projektowania wstążki, tak i w oknie Dostosowywanie paska narzędzi Szybki dostęp znajdują się listy dostępnych i wybranych poleceń. Lista po lewej stronie zawiera elementy reprezentujące wszystkie polecenia dostępne w programie Microsoft Access. Są one podzielone na kategorie Popularne polecenia, Polecenia, których nie ma na Wstążce, Wszystkie polecenia i Makra. Do wyboru kategorii służy lista rozwijana nad listą opcji. Lista kategorii obejmuje też wiele różnych kategorii poleceń Accessa (PLIK, NARZĘDZIA GŁÓWNE, DANE ZEWNĘTRZNE itp.). Wybranie elementu z tej listy pozwala zobaczyć polecenia dostępne w ramach tej kategorii. Pasek narzędzi Szybki dostęp zapewnia łatwy sposób na kontrolowanie, które polecenia są dostępne dla użytkowników podczas pracy z aplikacjami Accessa. Narzędzia dostępne na pasku Szybki dostęp obejmują polecenia takie jak tworzenie kopii zapasowej bazy danych, konwersja bazy danych na inny format programu Access, przeglądanie właściwości bazy danych i podłączanie tabel. Ponieważ pasek narzędzi Szybki dostęp jest widoczny dla wszystkich użytkowników, trzeba się upewnić, że w aplikacji nie udostępnia się poleceń, które mogą jej zaszkodzić (np. przycisku Widok projektu). Ze względu na to, że pasek narzędzi Szybki dostęp jest łatwy w dostosowywaniu, nie jest trudno dodawać polecenia, kiedy się ich potrzebuje, zamiast pozostawiać je widocznymi dla wszystkich użytkowników przez cały czas. Korzystając z przycisków dodawania i usuwania można przenosić elementy między listami. Okno Dostosowywanie działa w inteligentny sposób. Gdy tylko polecenie zostanie dodane do paska narzędzi Szybki dostęp, nie jest już dostępne, dzięki czemu nie ma możliwości dodania dwa razy tego samego polecenia. Okno dialogowe Dostosowywanie zawiera również strzałki w górę i w dół umieszczone po prawej stronie listy wybranych elementów. Pozwalają one na ustawianie poleceń w kolejności wyświetlania na pasku Szybki dostęp od lewej do prawej. Trzeba pamiętać, że pasek narzędzi Szybki dostęp może pomieścić dowolną liczbę poleceń. Jeśli jest ich więcej, niż może zostać fizycznie wyświetlonych, na samym końcu paska pojawi się przycisk ze strzałką, który pozwala rozwinąć listę z ukrytymi poleceniami. Niemniej jednak ze względu na to, że pasek narzędzi Szybki dostęp ma przede wszystkim ułatwiać dostęp do poleceń, nie ma sensu zapełniać paska narzędzi Szybki dostęp wieloma poleceniami, gdyż tylko utrudni to pracę użytkownikowi.
Tworzenie niestandardowych wstążek Okna do projektowania wstążki i paska Szybki dostęp to wygodne narzędzia do dostosowywania interfejsu użytkownika w Accessie. Jednak zmiany, które można wprowadzić w ten sposób, są ograniczone. Język XML zapewnia znacznie większą swobodę w zakresie dostosowywania wstążki. Wstążki nie są reprezentowane przez obiekt programowalny w programie Access. Każda wstążka określona jest przez polecenia XML-a umieszczone w specjalnej tabeli o nazwie USysRibbons. Access korzysta z odnalezionych danych w formacie XML do stworzenia wstążki i wyświetlenia jej na ekranie.
926
Część VII Zaawansowane techniki programowania w Accessie
Proces tworzenia wstążki W uproszczeniu proces tworzenia własnej wstążki składa się z pięciu kroków: 1. Zaprojektowanie wstążki i napisanie w XML-u kodu, który ją zdefiniuje. 2. Napisanie w języku VBA podprogramów wywołań zwrotnych (opisanych w dalszej części), które obsłużą polecenia wstążki. 3. Stworzenie tabeli USysRibbons. 4. Określenie nazwy wstążki i dodanie kodu w XML-u do tabeli USysRibbons. 5. Określenie nazwy niestandardowej wstążki w oknie konfiguracji programu Access. Żaden z tych kroków nie jest intuicyjny, szczególnie ten dotyczący tworzenia kodu w XML-u i pisania podprogramów wywołań zwrotnych. Najlepszym wyjściem jest znalezienie przykładu, który jest względnie podobny do oczekiwanej wstążki, i dopasowanie jego kodu w XML-u do własnych wymagań.
Korzystanie z wywołań zwrotnych w języku VBA Wywołanie zwrotne jest kodem, który przekazywany jest do innej jednostki w celu przetworzenia. Każda pisana procedura, która ma obsługiwać czynności na wstążce, jest przekazywana do „procesora wstążki” w Accessie. To on wykonuje akcje wstążki. To bardzo niepodobne do kodu opartego na zdarzeniach, z którym pracowałeś wcześniej w Accessie. Kliknięcie przycisku na formularzu bezpośrednio wywołuje kod w procedurze zdarzenia Przy kliknięciu tegoż przycisku. Procedura wywołania zwrotnego jest przypisana do wstążki, ale zostaje wewnętrznie przetworzona przez Access i nie jest bezpośrednio uruchamiana w odpowiedzi na kliknięcie na wstążce. Aby w pełni zrozumieć ten proces, wyobraź sobie, że Access zawiera proces, który ciągle monitoruje aktywność wstążki. Gdy tylko użytkownik kliknie formant wstążki, procesor wstążki przejmuje sterowanie, pobiera procedurę wywołania zwrotnego skojarzoną z formantem i wykonuje operacje określone w procedurze wywołania zwrotnego. Oznacza to, że ze wstążkami programu Access nie są skojarzone żadne zdarzenia Click, DblClick lub GotFocus. Zamiast tego do wstążki przypisuje się za pomocą kodu w XML-u wywołanie zwrotne. Każdy formant wstążki zawiera pewną liczbę atrybutów akcji, które są przypisane do wywołań zwrotnych i które są przejmowane przez procesor wstążki, gdy użytkownik wywoła akcję formantu. Oto przykład. Poniższy kod w XML-u określa przycisk umieszczony na wstążce:
Te wiersze kodu to pojedyncze polecenie w kodzie w XML-u. Wiersze podzielono w celu poprawienia czytelności kodu.
Rozdział 30. Dostosowywanie wstążek
927
Zwróć uwagę na atrybut OnAction w ostatnim wierszu kodu w XML-u. Zauważ, iż atrybut ten ustawiony jest na OpenProductsForm. Atrybut OnAction jest podobny do zdarzeń skojarzonych z formantami formularzy. Każdy interaktywny formant wstążki (przyciski, przyciski rozdzielające itp.) posiada atrybut onAction. Procedura wywołania zwrotnego (w tym przypadku OpenProductsForm) przypisana do atrybutu onAction przekazywana jest do procesora wstążki, gdy wykonywana jest akcja formantu. Atrybuty formantu w kodzie w XML-u mogą występować w dowolnej kolejności, ale trzeba starannie je zapisać. W języku XML wielkość znaków ma znaczenie. Dlatego atrybuty należy zapisać w dokładnie takiej postaci, jak w przykładach z tego rozdziału i w przykładowej bazie danych Rozdział30.accdb. Ponadto wartości atrybutów (np. "FindDialog") muszą znajdować się między cudzysłowami lub apostrofami. Warto zauważyć, że przycisk nie zawiera zdarzenia „kliknięcie”. Zamiast tego każdy interaktywny atrybut onAction obsługuje każdą akcję, jaka jest oczekiwana przez formant. W przypadku przycisku akcją jest kliknięcie, podczas gdy dla pola tekstowego akcją będzie wpisywanie danych przez użytkownika. Oba te formanty zawierają atrybut onAction, przy czym w każdym z nich atrybut ten oznacza coś innego. Warto pamiętać, że onAction to nie zdarzenie. Jest to tylko atrybut XML-a, który określa wywoływaną zwrotnie procedurę powiązaną z formantem wstążki. Procedura ta jest uruchamiana za każdym razem, gdy użytkownik korzysta z formantu. W omawianym przykładzie wywoływana zwrotnie procedura przycisku ViewProducts jest uruchamiana, gdy użytkownik kliknie ten przycisk.
Formanty wstążki mają też kilka innych ważnych atrybutów, takich jak imageMso, screentip i supertip. Omówiono je w dalszej części rozdziału, w punkcie „Dodawanie formantów do wstążki”. Prawdopodobnie każdy chciałby podczas tworzenia niestandardowej wstążki oglądać generowane przez nią błędy. Domyślnie zgłaszanie błędów wstążek jest wyłączone i trzeba je włączyć, zanim będzie można zobaczyć komunikaty o błędach powodowanych przez wstążki. W tym celu należy kliknąć przycisk PLIK w górnym lewym rogu ekranu głównego, kliknąć przycisk Opcje, a następnie wybrać zakładkę Ustawienia klienta w oknie dialogowym Opcje programu Access. Potem należy przewinąć listę na dół aż do sekcji Ogólne, wybrać polecenie Pokaż błędy interfejsu użytkownika dodatku i kliknąć przycisk OK na dole okna. Komunikaty o błędach generowane przez wstążkę są bezcennymi wskazówkami przy diagnozowaniu kodu (zobacz rysunek 30.12). Bez nich nie będziesz wiedział, co zawiodło w tworzonej wstążce. Rysunek 30.12. Komunikat błędu zwrócony przez niestandardową wstążkę
928
Część VII Zaawansowane techniki programowania w Accessie
Tworzenie niestandardowej wstążki Jak już zostało wspomniane, tworzenie i dostosowywanie wstążek jest znacznie bardziej skomplikowane niż pracowanie z obiektem CommandBar znanym z wcześniejszych wersji Accessa. Tworzenie wstążki programu Access jest w najlepszym przypadku pięcioetapową czynnością. Każdy z tych kroków opisany jest w kolejnych punktach. Dalej znajdziesz znacznie więcej przykładów każdego z tych kroków.
Krok 1.: Projektowanie wstążki i rozwijanie kodu w XML-u Podobnie jak w przypadku większości obiektów bazodanowych pierwszym krokiem przy tworzeniu nowej wstążki jest jej dokładne zaprojektowanie na papierze. Jeżeli dokonujesz konwersji istniejącego paska narzędzi lub menu na wstążkę Accessa, prawdopodobnie masz już pojęcie o formantach i innych elementach, które mają znaleźć się na wstążce. Dokument XML, który utworzysz, odzwierciedla projekt papierowy. Prawdopodobnie największym wyzwaniem w procesie tworzenia kodu w XML-u wstążki jest wizualizowanie, jak będzie wyglądać wstążka stworzona na podstawie napisanego kodu. Niestety nie ma żadnych wizualnych podpowiedzi w dokumencie XML wstążki, które ilustrowałyby wygląd wstążki wyświetlonej w programie Access. Najlepszym pomocnikiem będzie w tym momencie doświadczenie, a czasami próby i błędy są jedynym sposobem na osiągnięcie zaplanowanego celu. Trzeba pamiętać, że Access bardzo starannie analizuje XML-owy kod wstążek. Access nie jest wyposażony w żaden parser, który sprawdzałby poprawność kodu XML podczas renderowania wstążki. Jeżeli w dokumencie XML występuje błąd, Access nie wyświetli wstążki lub będzie na niej brakować elementów zdefiniowanych w kodzie w XML-u. Najczęściej jedynym sposobem, by stwierdzić, że w XML-owym kodzie wstążki występują błędy, jest zauważenie, że Access wczytał wstążkę domyślną zamiast niestandardowej. Tak więc tworzenie wstążek w Accessie wymaga pewnej liczby prób, podczas których trzeba modyfikować dokument XML, przenosić go do Accessa i podglądać efekty. Do momentu pojawienia się graficznego narzędzia jest to jedyny sposób na poznanie, na ile poprawny jest XML-owy kod wstążki. Podrozdział „Podstawowy XML-owy kod wstążki” znajdujący się w dalszej części rozdziału opisuje podstawowe polecenia XML-a, które potrzebne są na wstążkach w formacie XML. W tym przykładzie utworzysz nową zakładkę wyświetlaną na domyślnej wstążce. Nowa zakładka będzie nosiła nazwę KOMUNIKATY, a znajdzie się na niej jeden formant wyświetlający formularz. Najpierw zaprojektuj formularz z jedną etykietą, na której znajdzie się wyświetlany komunikat. Rysunek 30.13 przedstawia formularz frmMessage. Znajdziesz go w bazie Rozdział30.accdb.
Aby napisać XML-owy kod z definicjami nowych elementów wstążki, otwórz wybrany edytor XML-a. Przykładowy kod z tego rozdziału został napisany w programie XML Notepad. Można go nieodpłatnie pobrać ze strony Microsoftu (www.microsoft.com/en-us/ download/details.aspx?id=7973). Na rysunku 30.14 pokazano XML-owy kod w tym programie.
Rysunek 30.14. Do pisania kodu w XML-u można wykorzystać program XML Notepad
W programie XML Notepad wybierz View/Source, aby wyświetlić wygenerowany kod w XML-u. Oto kod pliku Message.xml:
930
Część VII Zaawansowane techniki programowania w Accessie
Poszczególne elementy tego pliku XML zostały opisane w dalszej części rozdziału. Tu zwróć uwagę na to, że plik tworzy przycisk Wyświetl komunikaty z grupy Pokaż na zakładce KOMUNIKATY. Atrybut onAction ma nazwę ShowMessage. Będzie ona potrzebna w następnym kroku.
Krok 2.: Pisanie procedur wywołań zwrotnych Przed napisaniem choćby wiersza kodu dla formantów wstążki programu Access należy dodać odwołanie do biblioteki obiektów Microsoft Office 15.0 Object Library poprzez kliknięcie polecenia Tools/References i zaznaczenie w oknie References pola wyboru przy pozycji Microsoft Office 15.0 Object Library. Inaczej interpreter języka VBA nie obsłuży formantów wstążki. Jak opisano we wcześniejszej części rozdziału, procedury wywołań zwrotnych podobne są do procedur zdarzeń, ale nie są uruchomiane bezpośrednio w odpowiedzi na zdarzenia formantu. Każdy typ procedury wywołania zwrotnego posiada określoną „sygnaturę”, którą trzeba zastosować, by procesor wstążki mógł zlokalizować wywołanie zwrotne i go użyć. Na przykład sygnatura wywołania zwrotnego onAction dla przycisku ma postać: Public Sub OnAction(control as IRibbonControl)
To samo wywołanie dla pola wyboru ma postać: Public Sub OnAction(control as IRibbonControl, _ pressed As Boolean)
Chociaż te wywołania zwrotne obsługują ten sam atrybut formantu (onAction), to sygnatury są inne, gdyż formanty się różnią. Klikanie przycisku jest po prostu zwykłym kliknięciem i czynność się kończy. W przypadku pola wyboru kliknięcie albo zaznacza opcję (pressed = true), albo ją wyłącza (pressed = false). Dlatego też dla pól wyboru wymagany jest dodatkowy parametr. Przedstawione wcześniej procedury to tylko prototypy, które nie dotyczą żadnego konkretnego formantu wstążki. W praktyce nazwy wywoływanych zwrotnie procedur tworzy się zwykle na podstawie nazwy danego formantu. Pozwala to odróżnić te procedury od procedur powiązanych z innymi formantami. W tym przykładzie umieść w standardowym module następujący kod:
Rozdział 30. Dostosowywanie wstążek
931
Public Sub ShowMessage(control As IRibbonControl) 'Wywoływana dla przycisku KOMUNIKATY/Pokaż/Wyświetl komunikat DoCmd.OpenForm "frmMessage" End Sub
Warto zauważyć, że deklaracja tej procedury pasuje do prototypu wywoływanej zwrotnie procedury onAction przycisku. Choć nie jest to konieczne, w procedurze znajduje się nawet komentarz, który określa formant wstążki uruchamiający daną procedurę. Wywoływane zwrotnie procedury trzeba deklarować przy użyciu atrybutu Public w module standardowym. W przeciwnym razie będą niewidoczne dla procesu obsługującego wstążkę. Wywoływanej zwrotnie procedurze można nadać dowolną nazwę, ale deklaracja procedury musi pasować do sygnatury onAction formantu. Nazwa procedury musi oczywiście pasować do wartości przypisanej do atrybutu onAction formantu. Ponadto udokumentowanie związku procedury z formantem ze wstążki bardzo pomaga, gdy trzeba zmodyfikować samą wstążkę lub wywoływaną zwrotnie procedurę. Warto zwrócić uwagę, że żadne z wywołań zwrotnych omawianych w tym rozdziale nie wskazywało formantu za pomocą jego nazwy. Oznacza to, że trzeba tworzyć unikalne nazwy wywołań zwrotnych dla każdego z formantów lub używać pojedynczego wywołania zwrotnego dla wielu podobnych formantów.
Krok 3.: Tworzenie tabeli USysRibbons Access szuka tabeli o nazwie USysRibbons, aby sprawdzić, czy nie ma wstążek zdefiniowanych przez użytkownika w bieżącej aplikacji bazy danych. Ta tabela domyślnie nie jest tworzona, a jeśli istnieje, zawiera kod w XML-u określający niestandardową wstążkę w aplikacji. Tabela USysRibbons jest niewidoczna w okienku nawigacji z uwagi na przedrostek USys w nazwie (wszystkie obiekty bazy danych z takim przedrostkiem są automatycznie ukrywane w okienku nawigacji). Jeśli chcesz wyświetlić tę tabelę w okienku nawigacji, musisz zaznaczyć opcję Pokaż obiekty systemowe w oknie dialogowym Opcje nawigacji. W tym celu kliknij nagłówek okienka nawigacji prawym przyciskiem myszy, wybierz opcję Opcje nawigacji, a następnie zaznacz pole Pokaż obiekty systemowe w lewym dolnym rogu okna dialogowego Opcje nawigacji.
Tabela USysRibbons jest bardzo prosta i zawiera jedynie trzy pola, pokazane w tabeli 30.1. Tabela 30.1. Projekt tabeli USysRibbons Pole
Typ danych
ID
Autonumerowanie
RibbonName
Krótki tekst (255 znaków)
RibbonXML
Długi tekst
932
Część VII Zaawansowane techniki programowania w Accessie
Pole ID służy do identyfikowania wstążek w tabeli. RibbonName używane jest do określenia, którą wstążkę Access ma ładować przy starcie (o czym mowa w kroku 5.), podczas gdy RibbonXML jest polem typu Długi tekst zawierającym kod w XML-u definiujący wstążkę. Ponieważ USysRibbons jest tabelą, baza danych Accessa może zawierać definicje wielu różnych wstążek użytkownika. Niemniej jednak tylko jedna z nich może być aktywna w danym momencie. W dalszej części rozdziału, opisane zostanie, w jaki sposób zamknąć istniejącą wstążkę i załadować w to miejsce nową. Istnieją dobre powody dodawania nowych pól do tabeli USysRibbons. Można na przykład dodać pole Uwagi lub Komentarze, aby pomóc innym programistom zrozumieć, jak mają korzystać z danej wstążki. Można też dodać datę modyfikacji lub inne pola ułatwiające śledzenie zmian w niestandardowych wstążkach. Jeśli zmodyfikujesz tabelę USysRibbons, uważaj, żeby nie usunąć lub nie zmienić nazwy któregoś z trzech wymaganych pól (ID, RibbonName i RibbonXML). Aby niestandardowe wstążki działały, te trzy pola muszą znajdować się w tabeli USysRibbons i mieć odpowiednie nazwy.
Krok 4.: Dodawanie kodu w XML-u do tabeli USysRibbons Teraz można zapisać kod w XML-u w tabeli USysRibbons. Otwórz tę tabelę w widoku arkusza danych. W polu RibbonName wpisz nazwę rbnMessages, a następnie przenieś kursor do pola RibbonXml. Skopiuj kod w XML-u utworzony w kroku 1. i wklej go w polu RibbonXml tabeli Usys Ribbons. Jeśli używasz programu XML Notepad, otwórz w nim odpowiedni plik XML i wybierz opcję View/Source, aby wyświetlić kod w XML-u w Notatniku. Następnie skopiuj kod z Notatnika do tabeli USysRibbons. Rysunek 30.15 przedstawia tabelę USysRibbons z uzupełnionymi polami. Rysunek 30.15. Skopiuj kod w XML-u do tabeli USysRibbons
Kod w XML-u wklejony w polu RibbonXml zawiera wiele odstępów. Nie martw się o znaki tabulacji i nowego wiersza w plikach XML. Pamiętaj jednak, że przy zastępowaniu istniejących danych w polu RibbonXml należy usunąć wszystkie istniejące informacje. Gdy używane są znaki tabulacji i nowego wiersza, trudno jest stwierdzić, czy w polu nie pozostały jeszcze dawne dane.
Rozdział 30. Dostosowywanie wstążek
933
Ponieważ w widoku arkusza danych trudno jest czytać długie łańcuchy znaków z XML-owym kodem, można utworzyć formularz z dużym polem tekstowym, w którym zmieści się dłuższy tekst. Na rysunku 30.16 widoczny jest formularz frmRibbons z bazy Rozdział30.accdb. Formularz ten służy do wyświetlania zawartości tabeli USysRibbons.
Rysunek 30.16. Formularz frmRibbons wyświetla informacje przechowywane w tabeli USysRibbons
Krok 5.: Określenie niestandardowych właściwości wstążki użytkownika Ostatnim krokiem przed ponownym uruchomieniem aplikacji jest otwarcie właściwości bieżącej bazy danych (Plik/Opcje/Bieżąca baza danych), przewinięcie w dół do Opcji wstążki i paska narzędzi oraz wprowadzenie nazwy nowej wstążki w polu kombi o nazwie Nazwa wstążki (zobacz rysunek 30.17). Pole kombi zawiera jedynie nazwy wstążek znajdujących się w tabeli USysRibbons, które były tam w momencie uruchomienia Accessa (najwyraźniej Access wczytuje zawartość tej tabeli tylko w momencie otwierania bazy danych), tak więc nie zawiera nazwy nowej wstążki. Dlatego też trzeba nazwę wpisać samodzielnie lub uruchomić ponownie aplikację i pozwolić Accessowi wyszukać nową wstążkę w tabeli USysRibbons. Gdy zamkniesz okno dialogowe Opcje po wybraniu nazwy nowej wstążki, Access wyświetli komunikat z informacją, że należy zamknąć i ponownie otworzyć bazę danych, aby wprowadzić zmiany. Komunikat ten widoczny jest na rysunku 30.18. Po ponownym uruchomieniu Accessa na domyślnej wstążce widoczna będzie nowa zakładka. Na rysunku 30.19 widać nową zakładkę, grupę Pokaż, która się na niej znajduje, jedyny dostępny przycisk Wyświetl komunikat i formularz otwarty po wciśnięciu przycisku.
934
Część VII Zaawansowane techniki programowania w Accessie
Rysunek 30.17. Ustawianie nowej wstążki użytkownika w karcie Bieżąca baza danych Rysunek 30.18. Po zmianie nazwy wstążki trzeba ponownie uruchomić aplikację
Podstawowy XML-owy kod wstążki Przyjrzyjmy się bliżej podstawowemu kodowi w XML-u, który jest potrzebny dla wstążek Accessa. Poniższe polecenia w XML-u reprezentują prototyp wstążki (numery wierszy zostały dodane, by ułatwić późniejsze ich omówienie): 1 2 2 4 5 6 8 ... Miejsce na formanty ... 9
Rozdział 30. Dostosowywanie wstążek
935
Rysunek 30.19. Kod w XML-u generuje nowe elementy wstążki, które pozwalają otworzyć formularz 10 11 13 ... Miejsce na formanty ... 14 15 ... Powtórzenie grup ... 16 17 ... Powtórzenie zakładek ... 18 19 20
Pierwsze polecenie () nie jest konieczne i nie ma wpływu na wstążki programu Access. Tylko od Ciebie zależy, czy w tabeli USysRibbons zachowasz ten wiersz czy nie. W poprawnym składniowo kodzie w XML-u należy umieścić wiersz z numerem wersji. Ponadto pomaga on w wyświetlaniu pliku innym programom, dlatego warto stosować ten wiersz. W wierszu 2. pokazano, jak dodawać komentarze do XML-owego kodu wstążki. Znaki to standardowe znaczniki komentarzy w dokumentach XML. Wiersz 3. (rozpoczynający się od
936
Część VII Zaawansowane techniki programowania w Accessie W pakiecie Office 2010 można też podać inną wartość w znaczniku customUI. Znacznik przedstawiony w przykładowym kodzie dotyczy wstążek dla programów od Access 2007 do Access 2013. Jeśli tworzysz wstążkę i jesteś przekonany, że będzie używana tylko w Accessie 2010 lub 2013 (np. w celu wykorzystania nowych funkcji z tej wersji), możesz zastosować znacznik customUI następującej postaci:
Polecenie 4., które zawiera dyrektywę startFromScratch, jest dość ważne. Informuje ona Access, że tworzona wstążka jest budowana od podstaw, a nie poprzez usunięcie niepotrzebnych lub dodanie nowych elementów domyślnej wstążki Accessa. Większość niestandardowych wstążek jest budowana od postaw, gdyż domyślna wstążka programu Access nic nie wie o używanych w danej bazie formularzach, raportach i innych obiektach. Ponadto domyślna wstążka Accessa obejmuje polecenia, które mogą zagrażać integralności aplikacji. Na przykład użytkownik może otworzyć formularz, raport lub tabelę w widoku projektu i wprowadzić zmiany, a programista nie będzie o tym wiedział. Usunięcie niebezpiecznych instrukcji z interfejsu użytkownika to pierwszy sposób ochrony aplikacji. Jeśli dyrektywa startFromScratch ma wartość false, zdefiniowana niestandardowa wstążka jest dodawana do domyślnej wstążki Accessa na prawo od wbudowanych zakładek. Ponieważ Access domyślnie ma tylko cztery zakładki, dodanie nowych zakładek nie musi oznaczać przeładowania wstążki. Gdy dyrektywa startFromScratch ma wartość true, na wstążce nie pojawiają się żadne domyślne zakładki, grupy ani formanty. Dostępne są tylko elementy dodane przez programistę w kodzie w XML-u. Większość elementów w plikach XML ma znacznik zamykający, który wyznacza koniec sekcji dotyczącej danego elementu. Wszystkie instrukcje między znacznikami otwierającym a zamykającym to elementy podrzędne. W wierszach 19. i 20. znajdują się znaczniki zamykające elementów Ribbon i CustomUI. Znaczniki (wiersz 5.) oraz (wiersz 18.) wskazują na początek i koniec zakładek na wstążce. Wstążki są hierarchiczne, z zakładkami zawierającymi grupy, które z kolei zawierają formanty. Tak więc zakładki są najwyższym poziomem w hierarchii i zawierają wszystkie inne obiekty wstążki. Wiersz 6. określa pierwszą od lewej zakładkę wstążki. W tym przykładzie ma ona nazwę "tab1". Inne atrybuty zakładki nie są pokazane, ale zasugerowane przez wielokropek (...). Znacznik kończący dla zakładki tab1 znajduje się w wierszu 10. Wiersz 7. rozpoczyna definicję pierwszej grupy zakładki tab1, a wiersz 9. kończy tę grupę. Wewnątrz grupy znajdują się formanty przez nią wyświetlane. Reszta tego prototypu wstążki to proste powtórzenie kilku pierwszych elementów. Język XML uwzględnia wielkość znaków. Należy być więc ostrożnym i używać dokładnie takich samych znaków i pisowni dla wszystkich odwołań w kodzie w XML-u oraz w kodzie wywołań zwrotnych, który obsługuje wstążkę.
Rozdział 30. Dostosowywanie wstążek
937
Dodawanie formantów do wstążki W poprzednim punkcie opisano prosty prototyp wstążki. W powyższym przykładzie formanty oznaczane były przez wyrażenie ...Miejsce na formanty... umieszczone w wierszach 8. i 13. W tym podrozdziale zobaczysz kod w XML-u i procedury wywołań zwrotnych dla kilku formantów. Wiele atrybutów XML-a dotyczy różnych formantów. Nie opisaliśmy tu wszystkich atrybutów każdego formantu, natomiast znajdziesz w tym miejscu omówienie najczęściej stosowanych atrybutów.
Określanie atrybutu imageMso Większość formantów wstążki (choć nie wszystkie) ma atrybut imageMso, który określa grafikę powiązaną z formantem. Nie można podawać prostych ścieżek do plików graficznych. Zamiast tego trzeba zastosować identyfikator imageMso. Każdy formant wstążki w aplikacjach z pakietu Office 2013 ma taki atrybut. Jego wartość można wykorzystać w formantach niestandardowych wstążek Accessa i utworzyć etykietę informującą użytkowników o przeznaczeniu formantu. Wartość atrybutu imageMso dla konkretnego formantu wstążki można uzyskać za pomocą okna projektowego wstążek. Należy otworzyć odpowiednią wstążkę na karcie Dostosowywanie wstążki, za pomocą listy rozwijanej w lewym górnym rogu wybrać kategorię obejmującą polecenie wstążki, a następnie umieścić kursor myszy nad poleceniem na liście (zobacz rysunek 30.20).
Rysunek 30.20. Wartość atrybutu imageMso polecenia ze wstążki można ustalić w oknie projektowym wstążek
Atrybut imageMso instrukcji Znajdź (FindDialog) znajduje się w nawiasach w etykietcke ekranowej widocznej obok wybranego polecenia.
938
Część VII Zaawansowane techniki programowania w Accessie
Formant etykiety Jest to najprostszy z opisanych do tej pory formantów i najłatwiej się go dodaje do wstążki. Etykieta wstążki jest analogiczna do etykiety dodawanej do formularza Accessa. Zawiera albo wpisany na stałe tekst, albo tekst generowany przez procedurę wywołania zwrotnego. Oto przykładowa definicja etykiety:
W tym kodzie w XML-u znajdują się dwie etykiety, separator i dwa pola wyboru. Tekst w każdej z tych etykiet jest zakodowany na stałe, a nie zwracany przez procedurę wywołania zwrotnego. Aby ustawić etykietę w czasie wykonywania programu, należy wykorzystać procedurę wywołania zwrotnego i atrybut getLabel.
W tym kodzie w XML-u wykorzystano atrybut getLabel do wskazania procedury wywołania zwrotnego, która określa wyświetlaną etykietę. Poniższa procedura z modułu standardowego wyświetla w etykiecie bieżącą datę. Public Sub lbl3_getLabel(control As IRibbonControl, ByRef label) label = FormatDateTime(Date, vbLongDate) End Sub
Argument label jest przekazywany przez referencję (modyfikator ByRef). Łańcuch znaków przypisany do tego argumentu zostaje wyświetlony w formancie labelControl. Tu za pomocą funkcji FormatDataTime procedura tworzy łańcuch znaków z bieżącą datą. Jedną procedurę wywołania zwrotnego można wykorzystać do ustawienia tekstu w kilku etykietach. W poniższym kodzie trzy etykiety mają tę samą wartość atrybutu getLabel.
Procedura wywołania zwrotnego lbl456_getLabel na podstawie właściwości id formantów określa, który z nich wywołał procedurę. Public Sub lbl456_getLabel(control As IRibbonControl, ByRef label) Select Case control.Id Case "lbl4" label = "To etykieta numer 4"
Rozdział 30. Dostosowywanie wstążek
939
Case "lbl5" label = "To etykieta numer 5" Case "lbl6" label = "To etykieta numer 6" End Select End Sub
Większość atrybutów ma postać statyczną i dynamiczną. Jeśli poprzedzisz nazwę atrybutu przedrostkiem get, przekształcisz atrybut, którego wartość jest ustawiana w kodzie w XML-u, na atrybut o wartości generowanej przez procedurę wywołania zwrotnego. Na przykład format labelControl ma atrybuty label i getLabel. Zastosuj pierwszy z nich, jeśli chcesz ustawić wartość w XML-u, a drugi — jeżeli chcesz określić ją dynamicznie w procedurze wywołania zwrotnego w kodzie VBA. Nie można jednocześnie używać atrybutu i jego odpowiednika z przedrostkiem get — w XML-u można podać tylko jedną z tych form.
Przycisk Przycisk to prawdopodobnie najprzydatniejszy i najbardziej podstawowy formant wstążki. Przyciski są bardzo proste. Mają etykietę, atrybut imageMso pozwalający określić grafikę przycisku, a także atrybut onAction do podawania wywoływanej zwrotnie procedury. Oto przykładowy XML-owy kod przycisku:
W przedstawionej poniżej procedurze wywołania zwrotnego btn1_onAction wykorzystano metodę FollowHyperlink obiektu Application, aby uruchomić przeglądarkę internetową. Przyciski wstążki nie obsługują dwukrotnego kliknięcia, dlatego powiązanie przycisku z procedurą wywołania zwrotnego jest bardzo łatwe. Public Sub btn1_onAction(control As IRibbonControl) Application.FollowHyperlink "http://helion.pl" End Sub
Innym atrybutem, który można zastosować dla przycisku, jest atrybut keytip. Access przypisuje skróty klawiszowe do większości formantów umieszczonych na wstążce. Skróty te są wyświetlane po wciśnięciu klawisza Alt i pozwalają poruszać się po wstążce za pomocą klawiatury. Za pomocą atrybutu keytip można określać własne skróty. XML-owy kod z atrybutem keytip przedstawionego wcześniej przycisku wygląda tak:
Na rysunku 30.21 widoczny jest nowy przycisk z podpowiedzią dotyczącą skrótu klawiszowego (B). Dzięki temu użytkownik może uzyskać dostęp do przycisku za pomocą łatwego do zapamiętania skrótu.
940
Część VII Zaawansowane techniki programowania w Accessie
Rysunek 30.21. Można ustawić niestandardowy skrót klawiszowy dla formantu
Separator Separator to element graficzny, który dzieli elementy w grupie, jak pokazuje to rysunek 30.22. Separatory nie zawierają tekstu i występują w formie pionowych linii wewnątrz grupy. Same w sobie nie są interesujące, ale graficznie oddzielają formanty, które inaczej byłyby zbyt blisko siebie. Rysunek 30.22. Separatory umożliwiają rozdzielenie formantów w grupie
Kod w XML-u tworzący separatory z rysunku 30.22 ma następującą postać:
Jedyne wymaganie dotyczące separatorów jest takie, że każdy musi mieć unikatowy identyfikator.
Pola wyboru Pola wyboru to wygodny sposób zaznaczania dowolnej liczby różnych opcji. Pola wyboru nie wykluczają się wzajemnie, tak więc użytkownik może wybrać dowolną ich liczbę wewnątrz grupy bez wpływu na inne zaznaczenia. Pola wyboru tworzy się tak samo jak inne formanty wstążki:
Rozdział 30. Dostosowywanie wstążek
941
Fragmenty kodu zostały usunięte i zastąpione trzema kropkami, aby poprawić przejrzystość przykładowego kodu w XML-u.
Zakładka powstała na podstawie powyższego kodu XML pokazana jest na rysunku 30.23. Znajduje się ona w pliku ControlExamples.xml w bazie danych Rozdział30.accdb.
Rysunek 30.23. Pola wyboru to dobry pomysł, kiedy użytkownik ma mieć możliwość wyboru wielu różnych opcji
Pola wyboru widoczne na wstążce na rysunku 30.23 działają w oczekiwany sposób. Można zaznaczyć każde z tych pól, a także dowolną ich kombinację. Zaznaczenie jednego pola nie uniemożliwia zaznaczenia innego, a każde pole wyboru ma własny atrybut onAction. Można też powiązać kilka pól wyboru z jedną procedurą wywołania zwrotnego.
Formant Lista rozwijana Formant Lista rozwijana jest nieco bardziej skomplikowany od etykiet, przycisków i pól wyboru. Zawiera listę elementów, z których użytkownik może wybierać. Dlatego obiekt DropDown ma zarówno kilka atrybutów określających jego wygląd, jak również wywołania zwrotne, które zapełniają listę:
Atrybuty id, label, screentip oraz supertip określają wygląd formantu Lista rozwijana. Atrybuty getItemCount oraz getItemLabel zapełniają listę. Atrybut onAction określa wywołanie zwrotne, które obsługuje akcję formantu. Formant utworzony w tym punkcie pokazano na rysunku 30.24. Rysunek 30.24. Formant Lista rozwijana wyświetla nazwy użytkowników
942
Część VII Zaawansowane techniki programowania w Accessie
Kod VBA wywołania zwrotnego z typowego formantu Lista rozwijana pokazany jest poniżej. Tu lista potrzebuje dwóch podstawowych wywołań zwrotnych. Pierwsze ustawia licznik elementów na liście, a drugie zapełnia listę: Public Sub ddLogin_getItemCount( _ control As IRibbonControl, ByRef count) count = Nz(DCount("*", "tblSalesPerson"), 0) End Sub Public Sub ddLogin_getItemLabel( _ control As IRibbonControl, index As Integer, ByRef label) Dim sName As String sName = Nz(DLookup("SalespersonName", _ "tblSalesPerson", "SalesPersonID = " & index + 1), _ vbNullString) label = sName End Sub
Pierwsze wywołanie zwrotne (ddLogin_getItemCount) pobiera liczbę elementów, które mają być umieszczone na liście. Zwróć uwagę na parametr ByRef count. Wskazuje on, ile elementów program ma umieścić na liście. Druga procedura (ddLogin_getItemLabel) pobiera elementy do listy. Tu procedura pobiera wartości z pola SalesPerson z tabeli tblSalesPerson, używając funkcji DLookup. Procedura ddLogin_getItemLabel jest wywoływana przez rozwinięcie wiele razy — dokładnie tyle, ile określa licznik wartości ustawiony przez procedurę ddLogin_getItemCount. Ważne jest, aby dokładnie określić liczbę wartości dodawanych do listy. Formant ten określa liczbę oczekiwanych elementów wyłącznie na podstawie parametru count. Jeśli wartość tego parametru będzie za mała, część elementów nie zmieści się na liście. Jeżeli wartość będzie za duża, na liście pojawią się puste miejsca. Gdy parametr count ma wartość 10, a dostępnych jest pięć elementów, na liście znajduje się pięć elementów i pięć pustych miejsc. Procedura ddLogin_getItemLabel oszukuje nieco, aby dostarczyć informację. Zwróć uwagę na parametr index, który jest przekazywany do tej procedury. Parametr ten informuje procedurę, która pozycja w liście jest wypełniana przy uruchomieniu procedury. Wywołanie DLookup dodaje jeden do tej wartości i pobiera nazwę sprzedawcy o identyfikatorze pasującym do wyniku. Oznacza to, że wartości w polu SalesPersonID muszą zaczynać się od 1 i rosnąć sekwencyjnie. W przeciwnym razie procedura nie będzie działać poprawnie. Pobieranie danych za pomocą niesekwencyjnych wartości identyfikatora lub wówczas, gdy ma on wartość nienumeryczną, wymaga nieco więcej pracy. W poniższym kodzie zmodyfikowano procedurę ddLogin_getItemLabel. W tej wersji procedura wykorzystuje zbiór rekordów ADO zamiast funkcji DLookup. W procedurze ddLogin_onAction zbiór rekordów jest używany w ten sam sposób.
Rozdział 30. Dostosowywanie wstążek
943
Private Const msSQLSALESPERSON As String = _ "SELECT SalespersonName FROM tblSalesPerson ORDER BY SalesPersonName;" Public Sub ddLogin_getItemLabel( _ control As IRibbonControl, index As Integer, ByRef label) Dim adRs As ADODB.Recordset Set adRs = CurrentProject.Connection.Execute(msSQLSALESPERSON) adRs.Move index label = adRs.Fields(0).Value End Sub Public Sub ddLogin_onAction( _ control As IRibbonControl, id As String, index As Integer) Dim adRs As ADODB.Recordset Set adRs = CurrentProject.Connection.Execute(msSQLSALESPERSON) adRs.Move index MsgBox "Zalogowałeś się na konto " & _ adRs.Fields(0).Value & ".", _ vbOKOnly, "Zalogowany" End Sub
W obu procedurach używana jest ta sama stała z poziomu modułu — msSQLSALESPERSON. Daje to gwarancję, że rekordy zostaną posortowane w dokładnie ten sam sposób. Metoda Move przechodzi do rekordu określonego za pomocą parametru index. Jeśli rekordy w poszczególnych procedurach są uporządkowane w odmienny sposób, zwrócone zostanie błędne nazwisko. Do pobierania nazwiska sprzedawcy służy instrukcja adRs.Fields(0).Value. Kontrolowanie instrukcji SQL-a za pomocą zmiennej z poziomu modułu daje pewność, że w pierwszym polu (.Fields(0)) znajdą się poprawne informacje. Na wstążce znajdują się trzy podobne do siebie formanty. Opisany w tym punkcie formant Lista rozwijana wizualnie przypomina formanty Rozwinięcie (zobacz rysunek 30.3) i Pole kombi (np. pole kombi Czcionka z grupy Formatowanie tekstu z zakładki NARZĘDZIA GŁÓWNE). W formantach Lista rozwijana i Pole kombi do zapełniania list służą wywołania zwrotne getItemCount i getItemLabel, natomiast w formancie Rozwinięcie przyciski są określane bezpośrednio w XML-u. Należy poznać różnice między wymienionymi formantami, aby wybrać optymalny dla aplikacji. Formant Lista rozwijana wymaga od użytkowników wybrania elementu z listy i wyświetla wybrany element w formancie. Lista rozwijana przypomina pole kombi, ale użytkownik nie może w niej bezpośrednio edytować wartości. Pole kombi działa podobnie jak lista rozwijana, jednak użytkownik może bezpośrednio zmodyfikować wartość w formancie i nie musi wybierać elementów z listy. Lista rozwijana i pole kombi to odpowiedniki pól listy i pól kombi z formularzy. Najprostszy z tych formantów, Rozwinięcie, to lista przycisków wykonujących operacje. Wartość wybranej opcji nie jest wyświetlana w formancie, a przycisków nie można tworzyć dynamicznie.
944
Część VII Zaawansowane techniki programowania w Accessie
Przycisk rozdzielenia Przycisk rozdzielenia jest bardzo przydatny, gdy użytkownik może wybierać spośród różnych opcji, przy czym jedna z nich jest używana częściej od pozostałych. Załóżmy, że istnieje szereg raportów, z których jeden jest drukowany regularnie, a inne — tylko od czasu do czasu. Przykładowym przyciskiem rozdzielenia jest przycisk Widok z zakładki NARZĘDZIA GŁÓWNE widoczny w czasie projektowania tabeli (zobacz rysunek 30.2). Zawartość tego przycisku zmienia się w zależności od kontekstu. Jeśli użytkownik otworzył widok arkusza danych, na przycisku pojawia się ikona widoku projektowania i na odwrót. Pozycje z listy opcji przycisku rozdzielenia znajdują się między znacznikami . Wszelkie (sensowne) formanty podane między tymi znacznikami pojawiają się na liście opcji przycisku rozdzielenia. Definicja domyślnego przycisku znajduje się poza tymi znacznikami. W poniższym fragmencie kodu domyślnym przyciskiem jest spbtn1_btn1. Pozostałe przyciski (spbtn1_btn2, spbtn1_btn3 itd.) znajdują się na liście opcji.
Ten przykładowy kod w XML-u wstążki generuje przycisk rozdzielenia widoczny na rysunku 30.25. Przycisk ten znajdziesz na przykładowej wstążce rbnControls w bazie danych Rozdział30.accdb. Rysunek 30.25. Przycisk rozdzielenia to bardzo przydatny formant wstążki
Rozdział 30. Dostosowywanie wstążek
945
Wiązanie wstążek z formularzami i raportami Utworzone wcześniej elementy wstążek zawsze są widoczne. Często przyciski, listy rozwijane i rozwinięcia umieszczone na wstążce powinny być dostępne przez cały czas. Jednak niektóre elementy wstążki powinny pojawiać się tylko w niektórych sytuacjach. Na szczęście Access zapewnia prosty mechanizm wyświetlania wstążek, gdy aktywny jest określony formularz lub raport. Formularze i raporty mają właściwość Nazwa wstążki, którą można ustawić w arkuszu właściwości lub w kodzie VBA (tu należy użyć właściwości o nazwie RibbonName). Właściwość Nazwa wstążki w arkuszu właściwości wyświetla listę rozwijaną z wszystkimi wstążkami z tabeli USysRibbons. Na rysunku 30.26 pokazano, jak powiązać wstążkę z formularzem. Rysunek 30.26. Ustawianie właściwości Nazwa wstążki formularza
XML-owy kod wstążki rbnAttach znajduje się w pliku FormAttach.xml wśród przykładowych plików dołączonych do rozdziału, a także w tabeli USysRibbons przykładowej bazy danych Rozdział30.accdb. Oto ten kod:
Dla przycisku nie ustawiono atrybutu onAction, dlatego pokazana wstążka nie wykonuje żadnych operacji. Pokazano ją tylko jako przykład ilustrujący, jak wstążka zmienia
946
Część VII Zaawansowane techniki programowania w Accessie
się po powiązaniu innej wstążki z formularzem. Atrybut startFromScratch ma wartość false, dlatego nowa zakładka nie zastępuje wstążki domyślnej, a jest do niej dodawana. Na rysunku 30.27 widać nową zakładkę wyświetlaną po otwarciu powiązanego formularza.
Rysunek 30.27. Otwarcie formularza powoduje wyświetlenie powiązanej wstążki
Zakładka Formularz z umieszczonymi na niej formantami jest dostępna, gdy powiązany formularz jest otwarty. Zamknięcie formularza prowadzi do ukrycia tej zakładki. Lista wstążek w arkuszu właściwości działa jak lista w oknie opcji — nie jest automatycznie aktualizowana po dodaniu nowej wstążki do tabeli USysRibbons. Aby zaktualizować listę, trzeba zamknąć i ponownie otworzyć aplikację. Gdy wybierzesz opcję Kompaktuj i napraw z menu PLIK/Informacje, Access automatycznie zamknie i ponownie otworzy bazę danych. Jest to technika, która pozwala jednym kliknięciem zaktualizować listę dostępnych wstążek. Dodatkowo metoda ta powoduje skompaktowanie bazy danych.
Całkowite usuwanie wstążek Załóżmy na chwilę, że istnieją uzasadnione powody ku temu, by całkowicie zaprzestać korzystania ze wstążek we własnych aplikacjach. Być może ktoś opracował zestaw efektywnych formularzy paneli przełączania lub naśladuje stary styl pasków narzędzi i menu z formularzami bez obramowania. Możliwe też, że czyjaś aplikacja obsługiwana jest tylko z poziomu formularzy i nie ma potrzeby korzystania z elastycznych pasków narzędzi i wstążek.
Rozdział 30. Dostosowywanie wstążek
947
Oto jak należy postępować, by całkowicie usunąć wstążki z interfejsu bazy danych Access: 1. Utwórz nową tabelę o nazwie USysRibbons, jeśli jeszcze tego nie zrobiłeś. 2. Jeśli tworzysz tabelę USysRibbons po raz pierwszy, dodaj trzy pola: ID (autonumerowanie), RibbonName (krótki tekst) oraz RibbonXML (długi tekst). 3. Utwórz nowy rekord z polem RibbonName ustawionym na przykład na Blank. Wpisywana tu nazwa nie ma znaczenia. 4. Dodaj do kolumny RibbonXML następujący kod w XML-u:
5. Uruchom ponownie bazę danych. 6. Kliknij przycisk Plik i wybierz polecenie Opcje. 7. Kliknij zakładkę Bieżąca baza danych i przewiń w dół do obszaru Opcje wstążki i paska narzędzi. 8. W obszarze Opcje wstążki i paska narzędzi ustaw pole Nazwa wstążki na Blank (to pole, które ustawiłeś w punkcie 3.). 9. Ponownie uruchom bazę danych. Czynności te ustawiają przykładową wstążkę o nazwie Blank, która nie zawiera żadnych zakładek, grup czy formantów. W efekcie nakazuje się, by Access uruchomił pustą wstążkę, co po prostu usuwa wstążkę z interfejsu użytkownika Accessa.
948
Część VII Zaawansowane techniki programowania w Accessie
Rozdział 31.
Dystrybucja aplikacji Accessa W tym rozdziale:
Definiowanie opcji bieżącej bazy danych
Rozwijanie aplikacji
Dopracowywanie aplikacji
Dodatkowa ochrona aplikacji
Zabezpieczanie środowiska Accessa
Tylko naprawdę wielcy szczęśliwcy mogą cieszyć się z luksusu tworzenia aplikacji dla jednego użytkownika wykorzystywanych w jednym miejscu i nigdy nie muszą się martwić rozprowadzaniem aplikacji w firmie lub w wielu miejscach kraju. Większość programistów wcześniej czy później będzie musiała zadbać o dystrybucję swoich aplikacji. Aby zajmować się dystrybucją, nie trzeba być twórcą oprogramowania komercyjnego. O dystrybucję należy zadbać, na przykład, w przypadku tworzenia aplikacji, która ma działać na kilkunastu stacjach roboczych w firmie. W tym rozdziale do pewnego stopnia opisano wszystkie poprzednio poruszone zagadnienia. Ponieważ jednak niektóre z wymienionych zagadnień, jak na przykład dzielenie tabel oraz obsługa błędów, zostały szczegółowo opisane w innych rozdziałach, w tym skoncentrowaliśmy się głównie na ustawianiu opcji bazy danych podczas przygotowywania aplikacji do dystrybucji. Przygotowując aplikację programu Access do dystrybucji, należy zadbać o wiele spraw. Właściwa dystrybucja nie tylko ułatwia użytkownikowi instalację i korzystanie z aplikacji, ale także ułatwia programiście jej aktualizowanie i konserwację. Dodatkowo właściwe przygotowanie aplikacji i pakietu bazy danych oraz powiązanych plików do dystrybucji wpływa na zmniejszenie liczby koniecznych interwencji pomocy technicznej. W tym rozdziale wykorzystano bazę danych Rozdział31.accdb. Jeśli jeszcze nie skopiowałeś jej na swój komputer, powinieneś zrobić to teraz.
950
Część VII Zaawansowane techniki programowania w Accessie Większość technik opisanych w tym rozdziale zastosowaliśmy do przykładowej bazy danych. Aby otworzyć ją w taki sposób, żeby widoczne były odpowiednie opcje, najpierw otwórz Accessa, a następnie przytrzymaj klawisz Shift w momencie kliknięcia nazwy otwieranej bazy danych. Nie zwalniaj klawisza Shift do czasu otwarcia bazy. Przykładowa baza danych z tego rozdziału ma niestandardową ikonę. Na Twoim komputerze plik ikony może znajdować się w innym miejscu niż określono w bazie, dlatego odpowiednio dostosuj ustawienia, aby zobaczyć ikonę.
Definiowanie opcji bieżącej bazy danych W bazie danych Access istnieje wiele opcji, za pomocą których można znacznie uprościć proces dystrybucji bazy danych. Dostęp do tych opcji można uzyskać poprzez kliknięcie przycisku PLIK, wybranie opcji Opcje i kliknięcie zakładki Bieżąca baza danych (zobacz rysunek 31.1). Do wykonania kodu inicjującego można wykorzystać makro Autoexec, ale opcje zakładki Bieżąca baza danych pozwalają na ustawienie opcji dotyczących różnych części aplikacji, a tym samym zmniejszają ilość kodu startowego, który trzeba by było napisać. Właściwe ustawienie tych opcji przed dystrybucją aplikacji programu Access ma bardzo istotne znaczenie.
Rysunek 31.1. Opcje bieżącej bazy danych umożliwiają kontrolę nad aplikacją od momentu, kiedy użytkownik ją uruchomi Opcje bieżącej bazy danych zastąpiły okno dialogowe Uruchamianie ze starszych wersji Accessa.
Rozdział 31. Dystrybucja aplikacji Accessa
951
Ustawienie opcji bieżącej bazy danych pozwala uniknąć pisania wielu wierszy kodu, które byłyby potrzebne do wykonania tych samych operacji. Umożliwia też kontrolowanie interfejsu aplikacji od momentu uruchomienia jej przez użytkownika. Przed udostępnieniem aplikacji zawsze sprawdzaj opcje bieżącej bazy danych.
Opcje aplikacji Ustawienia w sekcji Opcje aplikacji pozwalają na zdefiniowanie parametrów dotyczących aplikacji bazy danych. Tytuł aplikacji Tekst wprowadzony w polu Tytuł aplikacji wyświetla się w pasku tytułu głównego okna Accessa. Opcja Tytuł aplikacji definiuje również tekst, który wyświetla się na pasku zadań systemu Windows w czasie, kiedy aplikacja działa. Należy pamiętać, aby zawsze określić tytuł rozprowadzanych aplikacji. Jeżeli się tego nie zrobi, na pasku tytułu wyświetli się nazwa bazy danych wraz z napisem Access.
Ikona aplikacji Ikona, którą wprowadzisz w polu Ikona aplikacji, wyświetli się na pasku tytułu aplikacji, a także na panelu przełączania zadań systemu Windows (dostępnym po wciśnięciu klawiszy Alt+Tab). Zaznaczenie pola wyboru Użyj jako ikony formularza i raportu spowoduje, że ikona ta będzie wyświetlona także po zminimalizowaniu formularza lub raportu. Jeżeli nie zdefiniujesz własnej ikony, zostanie użyta domyślna ikona programu Access. Z tego powodu należy pamiętać, aby zawsze wprowadzać ikonę specyficzną dla aplikacji. Używanie specyficznych ikon programów ułatwia użytkownikom rozróżnianie pomiędzy różnymi aplikacjami Accessa. Do tworzenia ikon można wykorzystać program Paint. Należy utworzyć za jego pomocą niewielkie bitmapy, a następnie użyć dostępnych narzędzi konwersji w celu przekształcenia plików .bmp na format .ico. Ikony można także tworzyć za pomocą innych programów graficznych. Można też poszukać ikon aplikacji za pomocą wyszukiwarek.
Wyświetl formularz Formularz, który wprowadzi się w tym polu, wyświetla się automatycznie w momencie uruchamiania aplikacji w Accessie. W czasie ładowania formularza, jeśli zdefiniowano kod dla zdarzenia Przy załadowaniu formularza, następuje jego wykonanie, co eliminuje konieczność zastosowania makra Autoexec. Jako formularz startowy można zastosować ekran powitalny (który zostanie omówiony w dalszej części tego rozdziału, w punkcie „Ekran powitalny”).
952
Część VII Zaawansowane techniki programowania w Accessie
Wyświetl pasek stanu Anulowanie zaznaczenia opcji Wyświetl pasek stanu spowoduje całkowite usunięcie paska stanu z ekranu (opcja jest domyślnie zaznaczona). Pasek stanu jest cennym elementem informacyjnym i bardzo wygodnym narzędziem — jego działanie polega na automatycznym wyświetlaniu różnych informacji dotyczących stanu klawiszy (np. Caps Lock i Scroll Lock) oraz właściwości Tekst paska stanu aktywnych formantów. Zamiast ukrywania paska stanu lepiej wykorzystać go w pełni. Zablokować warto go tylko wtedy, kiedy są ku temu ważne powody.
Opcje okna dokumentu W sekcji Opcje okna dokumentu można określić wygląd formularzy i raportów w rozpowszechnianej aplikacji. Dostępne opcje to:
Nakładające się okna — powoduje wyświetlanie aplikacji w sposób zgodny z poprzednimi wersjami Accessa — umożliwia wyświetlanie wielu okien naraz.
Dokumenty kartotekowe — powoduje wykorzystanie interfejsu wyświetlającego pojedynczy dokument (zobacz rysunek 31.2). Podobnie działają nowe wersje przeglądarki Internet Explorer.
Rysunek 31.2. Baza danych z włączoną opcją dokumentów kartotekowych. Karty dokumentów umożliwiają wybór obiektu Accessa, z którym będziemy pracować
Aby wprowadzone zmiany były widoczne, trzeba zamknąć i ponownie otworzyć bieżącą bazę danych. Opcja Wyświetl karty dokumentów jest dostępna tylko wtedy, gdy wybierze się opcję Dokumenty kartotekowe. Opcja włącza bądź wyłącza karty wyświetlające się w górnej części każdego otwartego obiektu bazy danych. Opcja ta wyłącza tylko karty i nie powoduje zamknięcia samych obiektów kartotekowych.
Rozdział 31. Dystrybucja aplikacji Accessa
953
Użyj specjalnych klawiszy programu Access Jeżeli zaznaczy się tę opcję, użytkownicy aplikacji będą mogli używać klawiszy specyficznych dla środowiska Accessa umożliwiających obejście niektórych zabezpieczeń — na przykład odkrywanie okienka nawigacji. Anulowanie zaznaczenia tej opcji powoduje zablokowanie następujących klawiszy:
F11 — klawisz ten służy do wyświetlania okienka nawigacji (jeżeli jest ukryte).
Ctrl+G — kombinacja służąca do wyświetlania okna Immediate w edytorze Visual Basica.
Ctrl+Break — w projektach Accessa kombinacja ta służy do zatrzymania pobierania rekordów z serwera bazy danych.
Alt+F11 — ta kombinacja klawiszy służy do uruchamiania edytora VBA. Podczas dystrybucji aplikacji należy anulować zaznaczenie opcji Użyj specjalnych klawiszy programu Access, aby uniemożliwić użytkownikom obchodzenie wybranych opcji. Jeśli opcja pozostanie zaznaczona, użytkownicy będą mogli uaktywniać okienko nawigacji i włączać edycję kodu VBA, co może wprowadzać w błąd oraz być przyczyną innych problemów. Jeśli za pomocą opcji Użyj specjalnych klawiszy programu Access wyłączysz skróty klawiaturowe Accessa, nadal będziesz mógł używać makr AutoKeys do ustawiania własnych skrótów dla aplikacji.
Kompaktuj przy zamknięciu Zaznaczenie opcji Kompaktuj przy zamknięciu powoduje, że w momencie zamykania aplikacji Access automatycznie wykonuje operację kompaktowania i naprawy bazy danych. Wielu programistów Accessa korzysta z tej opcji, aby program wykonywał potrzebną konserwację za każdym razem, gdy użytkownik korzysta z bazy danych. Aby zmiany zostały uwzględnione, należy zamknąć bieżącą bazę danych, a następnie ponownie ją otworzyć. Więcej informacji na temat korzyści wynikających z kompaktowania i naprawy bazy danych można znaleźć w dodatku B. Należy pamiętać, że kompaktowanie dużej bazy danych może zająć znaczącą ilość czasu. Co więcej, opcja Kompaktuj przy zamknięciu dotyczy tylko bazy danych frontonu. Jeśli aplikacja nie wykorzystuje bazy danych frontonu do przechowywania tymczasowych tabel i nie wykonuje innych operacji, które mogłyby powodować rozrastanie się bazy danych frontonu, stosowanie opcji Kompaktuj przy zamknięciu przyniesie niewielkie korzyści dla użytkowników.
Usuń informacje osobiste z właściwości pliku przy zapisywaniu Zaznaczenie tej opcji powoduje automatyczne usunięcie informacji osobistych z właściwości pliku podczas jego zapisywania. Aby zmiany zostały uwzględnione, należy zamknąć bieżącą bazę danych, a następnie ponownie ją otworzyć. Użyj formantów z motywów systemu Windows w formularzach Zaznaczenie tej opcji powoduje wykorzystywanie motywów systemu Windows dla formantów formularzy i raportów. Opcja ta ma znaczenie tylko wtedy, gdy wykorzystujemy motyw systemu Windows inny od standardowego.
954
Część VII Zaawansowane techniki programowania w Accessie
Włącz widok układu dla tej bazy danych Opcja ta wyświetla bądź ukrywa przycisk Widok układu na pasku stanu Accessa oraz w menu podręcznych wyświetlanych po kliknięciu zakładki obiektu prawym przyciskiem myszy. Należy pamiętać, że opcję Widok układu można wyłączać dla indywidualnych obiektów, zatem nawet jeśli włączy się tę opcję, nie zawsze będzie aktywna dla poszczególnych formularzy i raportów.
Włącz zmiany projektu w tabelach w widoku arkusza danych Pole wyboru Włącz zmiany projektu w tabelach w widoku arkusza danych pozwala wprowadzać zmiany w tabelach w widoku arkusza danych, a nie tylko w widoku projektu. W większości dobrze zaprojektowanych aplikacji Accessa użytkownicy nie mają dostępu do tabel w widoku projektu lub arkusza danych, a zamiast tego operują danymi za pomocą formularzy. Jeśli aplikacja umożliwia przeglądanie tabel w widoku arkusza danych, warto usunąć zaznaczenie tej opcji, aby zapobiec wprowadzaniu niepożądanych zmian w projekcie tabeli. Wyszukuj obcięte pola liczbowe Zaznaczenie tej opcji powoduje, że liczby wyświetlają się jako ciąg kratek (#####) w przypadku, gdy kolumna jest zbyt wąska, by mogła wyświetlić całą wartość. W Excelu mechanizm ten działa od długiego czasu. Anulowanie zaznaczenia tej opcji powoduje obcięcie wartości, które są zbyt szerokie, by mogły się zmieścić na arkuszu danych. Oznacza to, że jeśli kolumna będzie zbyt wąska, użytkownicy zobaczą tylko część liczby. Format przechowywania właściwości obrazów Opcja umożliwia wybór sposobu przechowywania plików graficznych w bazie danych. Oto dostępne opcje:
Zachowaj format obrazu źródłowego (mniejszy rozmiar pliku) — pozwala zapisywać obrazy w oryginalnym formacie, co równocześnie zmniejsza rozmiar bazy danych.
Konwertuj wszystkie dane obrazu na mapy bitowe (zgodne z programem Access 2003 i wcześniejszymi wersjami) — wybierz tę opcję, jeśli chcesz przechowywać wszystkie obrazy jako bitmapy. Powoduje to zwiększenie rozmiaru bazy danych, ale pozwala zachować zgodność bazy z wcześniejszymi wersjami Accessa (2003 i wcześniejsze).
We wcześniejszych wersjach Accessa obrazy zawsze były zapisywane w bazie danych dwukrotnie. Pierwsza kopia miała format zgodny ze źródłowym (np. .jpg), natomiast druga kopia była bitmapą wykorzystywaną do wyświetlania obrazu w formularzach i raportach Accessa. Ze względu na to, że obrazy były zapisywane dwukrotnie, bazy danych wcześniejszych wersji Accessa miały tendencję do rozrastania się w przypadku, gdy w pliku .mdb było zapisanych dużo plików graficznych. Dostępna jest też opcja Zachowaj format obrazu źródłowego, która pozwala na zaoszczędzenie miejsca na dysku dzięki zmniejszeniu rozmiaru pliku bazy danych (opcja ta jest dostępna wyłącznie dla formatu pliku .accdb). W przypadku użycia tej opcji Access za-
Rozdział 31. Dystrybucja aplikacji Accessa
955
pisuje tylko jedną kopię obrazu (w formacie źródłowym) i dynamicznie generuje bitmapę w przypadku wyświetlania obrazu w formularzu lub raporcie.
Opcje nawigacji Ustawienia w sekcji Nawigacja pozwalają na zdefiniowanie parametrów dotyczących poruszania się po aplikacji bazy danych. Wyświetl okienko nawigacji W większości aplikacji, które udostępnia się użytkownikom, projektanci nie życzą sobie, by użytkownicy mieli dostęp do tabel, kwerend, formularzy lub innych obiektów bazy danych. Użytkownicy bardzo lubią „usprawniać” formularze lub raporty oraz wprowadzać pewne modyfikacje w tabelach i kwerendach. Bardzo rzadko się zdarza, że użytkownicy mają odpowiednie umiejętności do wprowadzania takich zmian w bazach danych Accessa. Anulowanie zaznaczenia opcji Wyświetl okienko nawigacji powoduje ukrycie okienka nawigacji (jest ono niedostępne dla użytkowników po uruchomieniu aplikacji). Jeśli jednak jednocześnie nie anuluje się zaznaczenia opcji Użyj specjalnych klawiszy programu Access (opisanej we wcześniejszej części tego rozdziału), użytkownicy będą mogli wcisnąć klawisz F11 i odkryć okienko nawigacji.
Aby zmiany zostały uwzględnione, należy zamknąć bieżącą bazę danych, a następnie ponownie ją otworzyć. Przycisk Opcje nawigacji Interesującym dodatkiem do nowych wersji Accessa jest możliwość wyboru opcji bazy danych dostępnych dla użytkowników w momencie, kiedy po uruchomieniu aplikacji okienko nawigacji jest widoczne. Kliknięcie przycisku Opcje nawigacji powoduje wyświetlenie okna dialogowego Opcje nawigacji (zobacz rysunek 31.3). Można z niego skorzystać w celu zmiany kategorii i grup wyświetlanych w okienku nawigacji. Rysunek 31.3. Okno dialogowe Opcje nawigacji
956
Część VII Zaawansowane techniki programowania w Accessie
W obszarze Opcje grupowania po lewej stronie okna dialogowego należy kliknąć kategorię, aby zmienić kategorię wyświetlania lub dodawać grupy z prawej strony okna. Aby wyłączyć wyświetlanie wybranych obiektów Accessa (Tabele, Kwerendy, Formularze, Raporty, Makra i Moduły), należy kliknąć kategorię Typ obiektu. W Opcjach wyświetlania dostępne są opcje Pokaż ukryte obiekty, Pokaż obiekty systemowe oraz Pokaż pasek wyszukiwania. Zazwyczaj dobrym pomysłem jest ukrycie obiektów ukrytych i systemowych, ponieważ zwykle się ich nie modyfikuje (są ukryte celowo). Pasek wyszukiwania (zobacz rysunek 31.4) przydaje się w okienku nawigacji, jeśli wyświetla się w nim duża liczba obiektów i jeśli chcemy uniknąć niewygodnego przewijania. Dlatego warto zaznaczyć pole Pokaż pasek wyszukiwania. Na przykład aby wyświetlić formularze zawierające słowo Product w nazwie, wystarczy wpisać Prod w pasku wyszukiwania, aby ograniczyć tabele wyświetlane w okienku nawigacji. Rysunek 31.4. Pasek wyszukiwania wyświetla się w górnej części okienka nawigacji
W sekcji Otwieranie obiektów można wybrać opcję Pojedyncze kliknięcie lub Dwukrotne kliknięcie, aby określić sposób otwierania obiektów bazy danych. Opcja Dwukrotne kliknięcie jest domyślna — większość użytkowników jest przyzwyczajona do jej używania.
Opcje wstążki i paska narzędzi Ustawienia w sekcji Opcje wstążki i paska narzędzi pozwalają na zdefiniowanie własnej wstążki i pasków narzędzi używanych w aplikacji bazy danych. Aby zmiany ustawień z tej sekcji zostały wprowadzone, trzeba zamknąć i ponownie uruchomić bazę danych. Sposób tworzenia własnych wstążek opisano w rozdziale 30.
Nazwa wstążki Opcja Nazwa wstążki umożliwia określenie własnej (zazwyczaj okrojonej) wersji wstążki Accessa. Jeśli nie wprowadzi się nazwy własnej wstążki, Access użyje wstążki wbudowanej, która może być nieodpowiednia dla danej aplikacji. Domyślna wstążka zawiera wiele formantów, które mogą sprawiać problemy użytkownikom, ponieważ pozwalają na modyfikowanie obiektów bazy danych. Pasek menu skrótów Ustawienie opcji Pasek menu skrótów umożliwia zmianę domyślnej zawartości menu podręcznych (dostępnych po kliknięciu prawym przyciskiem myszy) na pasek menu podany przez użytkownika. Użycie własnych menu podręcznych zawierających elementy specyficzne dla aplikacji jest zawsze lepsze od używania menu domyślnych.
Rozdział 31. Dystrybucja aplikacji Accessa
957
Zezwalaj na pełne menu Zaznaczenie opcji Zezwalaj na pełne menu decyduje o tym, czy w menu Accessa będą wyświetlały się wszystkie polecenia, czy tylko najczęściej wykorzystywane. Jeśli zdefiniujesz własne menu we wszystkich formularzach i raportach oraz ustawisz właściwość Pasek menu na niestandardowy pasek menu, ustawienie to nie będzie miało znaczenia. Zezwalaj na domyślne menu skrótów Opcja Zezwalaj na domyślne menu skrótów decyduje o tym, czy Access będzie wyświetlał domyślne menu podręczne w przypadku, gdy użytkownik kliknie prawym przyciskiem myszy w okienku nawigacji bądź formancie na formularzu lub raporcie.
Opcje autokorekty nazw W kilku rozdziałach w tej książce opisywano problemy związane ze zmianą nazw w podstawowych obiektach bazy danych, na przykład tabelach i polach. Jeśli na przykład zmieni się nazwę tabeli, to wszystkie odwołania do tej tabeli (w kwerendach, właściwości Źródło formantu, kodzie VBA i makrach), stają się nieprawidłowe i powodują, że aplikacja działa niewłaściwie. Firma Microsoft wprowadziła w Accessie 2000 własność autokorekty nazw jako sposób złagodzenia problemów występujących w przypadku zmiany nazw obiektów bazy danych. Niestety mechanizm ten nigdy nie działał tak dobrze, jak planowano w firmie Microsoft. Przede wszystkim włączenie opcji autokorekty nazw powoduje znaczne obniżenie wydajności. Ponieważ Access musi bez przerwy monitorować wszystkie działania wykonywane podczas korzystania z bazy danych, aplikacje z włączoną opcją autokorekty nazw działają znacznie wolniej w porównaniu z aplikacjami, w których tę opcję wyłączono. Po drugie, nazwa obiektu może pojawić się w tak wielu miejscach, że mechanizm autokorekty nie ma możliwości skutecznego znalezienia jej wszystkich wystąpień w przypadku zmiany nazwy obiektu. Szczególnie trudne jest znalezienie wszystkich odwołań do obiektów w kodzie VBA. Niektóre aplikacje zawierają nawet kilkaset tysięcy wierszy kodu VBA. Znalezienie i uaktualnienie wszystkich odwołań do obiektu w kodzie o takiej objętości jest praktycznie niemożliwe. W aplikacjach Accessa opcja autokorekty nazw jest domyślnie włączona. W przypadku braku szczególnych powodów, dla których warto by włączyć tę opcję, należy ją wyłączyć. Tak właśnie postąpiono w przypadku bazy danych Rozdział31.accdb towarzyszącej temu rozdziałowi.
Tworzenie aplikacji Tworzenie aplikacji zwykle obejmuje definiowanie wymagań, tworzenie obiektów bazodanowych, pisanie kodu, tworzenie dokumentacji i testowanie programu. Jeśli tworzysz aplikację na własny użytek, wymagania prawdopodobnie masz już w głowie. Możliwe też, że tak dobrze znasz rozwiązywany problem, że nie czujesz potrzeby formalnego zapisywania wymagań. Rozważ jednak ich zapisanie, ponieważ pomaga to uporządkować myśli i wykryć problemy na wczesnych etapach pracy.
958
Część VII Zaawansowane techniki programowania w Accessie
Budowanie aplikacji zgodnie ze specyfikacją Wszystkie bazy danych mają za zadanie rozwiązać jakieś problemy użytkowników. Problemem może być niska wydajność bieżących metod albo niemożliwość przeglądania lub pobierania danych w wymaganym formacie. Można też po prostu konwertować przestarzałą bazę danych na bardziej nowoczesną wersję. Skuteczność tworzonego rozwiązania będzie oceniana na podstawie tego, jak skutecznie rozwiąże ono problemy użytkowników. Najlepszą gwarancją sukcesu jest dokładne zaplanowanie aplikacji przed zbudowaniem jakiejkolwiek tabeli, kwerendy lub formularza. Jedynie pracując zgodnie z planem, będziesz wiedzieć, jak dobrze aplikacja rozwiąże problem użytkowników. Większość projektów programistycznych w Accessie odbywa się zgodnie z poniższą ogólną procedurą: 1. Zdefiniowanie problemu. Stosowane obecnie metody są w jakiś sposób niepoprawne lub niewystarczające — potrzebny jest lepszy system, a Access wygląda na dobre narzędzie do zbudowania takiego systemu. 2. Ustalenie wymogów. Rozmowy z klientem dadzą opis podstawowych funkcji oczekiwanych od programu. Efektem tych rozmów jest specyfikacja projektowa — pisemny dokument, który określa zarys i detale aplikacji. 3. Dopracowywanie specyfikacji. Należy sprawdzić specyfikację projektową wraz z klientem, aby się upewnić, że jest precyzyjna i kompletna. 4. Projektowanie aplikacji. Programista wykorzystuje wstępną specyfikację projektową, na jej podstawie projektując podstawową strukturę bazy danych i interfejsu użytkownika. 5. Budowanie aplikacji. Ten etap większości programistów zajmuje najwięcej czasu. Poświęcany jest na budowanie tabel, kwerend, formularzy i innych obiektów bazy danych, niezbędnych do spełnienia wymogów specyfikacji z kroku 2. 6. Testy. Programista i klient testują aplikację, by się upewnić, czy działa zgodnie z oczekiwaniami. Aplikacja jest testowana na podstawie specyfikacji projektowej, a niezgodności zostają zanotowane i poprawione przed wykonaniem kroku 7. 7. Dystrybucja i wdrożenie. Po pomyślnym zweryfikowaniu działania aplikacja zostaje udostępniona użytkownikom. W razie konieczności użytkownicy zostają przeszkoleni w korzystaniu z aplikacji i poinstruowani, jak zgłaszać problemy oraz sugestie dla przyszłych wersji. Wielu niedoświadczonych programistów Accessa zabiera się od razu do budowania aplikacji, bez wystarczającego zdefiniowania jej celów lub zaprojektowania struktury bazy danych. O ile aplikacja nie jest bardzo prosta, programista, który nie będzie pracował zgodnie ze specyfikacją, z pewnością wyprodukuje bazę danych pełną błędów, zawodną i sprawiającą problemy. Kolejnym poważnym błędem jest pozwolić na zbytnie odejście bazy danych od początkowej specyfikacji projektowej. Dodawanie mnóstwa ozdobników i niepotrzebnych funkcji do prostej i przejrzystej bazy danych jest niezwykle kuszące. Jeśli implementacja oddali się zbytnio od specyfikacji projektowej, projekt może się nie powieść, ponieważ zbyt
Rozdział 31. Dystrybucja aplikacji Accessa
959
dużo czasu poświęcisz funkcjom, które nie są bezpośrednio związane z problemem użytkowników. Jest to jeden z powodów przeprowadzania trzeciego etapu (dopracowywania specyfikacji). W tym momencie programista i użytkownik zawierają kontrakt. Można opracować przy tym proces wprowadzania zmian przez poszczególne strony po uzgodnieniu specyfikacji. Przed rozpoczęciem pracy większość profesjonalnych twórców aplikacji wymaga od klienta pisemnego dokumentu, który opisuje zamierzone przeznaczenie aplikacji i oczekiwania względem działania programu. Dobrze napisana specyfikacja projektowa powinna obejmować następujące informacje:
Oczekiwane dane wejściowe. Jakiego typu dane (tekstowe, liczbowe, binarne) ma zawierać baza danych? Czy mają one być udostępniane innym aplikacjom (takim jak Excel) lub innemu systemowi bazodanowemu? Czy dane istnieją w formacie, który umożliwia łatwe zaimportowanie do bazy danych Accessa, czy też będą musiały zostać skonwertowane podczas pracy aplikacji? Czy dane zawsze będą dostępne? Czy ich typ może się zmieniać? Na przykład data urodzenia zawsze jest datą, co się jednak stanie, jeśli użytkownik będzie znał rok urodzenia, ale nie będzie pamiętał miesiąca lub dnia?
Interfejs użytkownika. Czy użytkownikom wystarczą proste formularze, czy też będą oni potrzebować niestandardowych menu, wstążek i innych składników interfejsu? Czy jest wymagana dostępność kontekstowej pomocy online?
Oczekiwane dane wyjściowe. Jakiego typu raportów potrzebują użytkownicy? Czy do wygenerowania pożądanych wyników wystarczą proste kwerendy typu SELECT, czy też będą niezbędne również tabele krzyżowe, sumowanie i inne zaawansowane kwerendy?
Podstawowym zadaniem specyfikacji projektowej jest uniknięcie dodawania niezaplanowanych funkcji, które mogłyby pogorszyć niezawodność bazy danych, jednocześnie nie zwiększając jej przydatności. Napisanie specyfikacji projektowej przed rozpoczęciem implementacji zawsze przynosi następujące korzyści:
Wytyczne do przebiegu projektu. Skąd bez jakiejś specyfikacji projektowej można wiedzieć, czy tworzona aplikacja naprawdę spełni oczekiwania klienta? Podczas fazy konstruowania aplikacji dokument ten pozwoli uniknąć dodawania funkcji, które nie pomagają w wykonywaniu zadań stawianych aplikacji, i skupić się na tych elementach, które klient zidentyfikował jako najważniejsze.
Weryfikacja, czy aplikacja spełniła oczekiwania. Wszystkie aspekty aplikacji muszą zostać przetestowane, by zweryfikować poprawność jej działania. Najlepszą metodą testowania jest sprawdzenie, czy zostały spełnione wszystkie założenia projektowe i czy podczas testów nie wystąpiły żadne nieoczekiwane zachowania.
Minimalizacja zmian projektu podczas implementacji. Wielu problemów można uniknąć, trzymając się ściśle specyfikacji. Jedną z najłatwiejszych metod popsucia aplikacji jest dodawanie nowych funkcji, które nie były wymienione w pierwotnym projekcie. Jeśli aplikacja została poprawnie zaplanowana, wymagane funkcje powinny zostać zaprojektowane tak, by dobrze wspólnie działały. Dodanie nowych funkcji już po rozpoczęciu pisania kodu najprawdopodobniej pogorszy niezawodność systemu.
960
Część VII Zaawansowane techniki programowania w Accessie
Ogólnie można powiedzieć, że dobrze napisana specyfikacja projektowa jest podstawą do stworzenia solidnej, niezawodnej aplikacji, która spełni wymagania użytkowników. Podczas finalizacji projektu ukończoną bazę danych można porównać ze specyfikacją i obiektywnie ocenić skuteczność, z jaką rozwiązuje pierwotny problem. Bez specyfikacji projektowej napisanej na początku projektu programista nie ma do dyspozycji żadnej obiektywnej miary, jak skutecznie aplikacja rozwiązała problem, który w ogóle zainspirował jej powstanie.
Dokumentacja aplikacji Nawet najlepiej napisana aplikacja Accessa będzie sprawiała problemy, jeśli użytkownicy nie będą wiedzieli, jak z niej korzystać. Zrozumiały musi być nie tylko interfejs użytkownika. Oprócz tego zarówno użytkownicy, jak i pracownicy pomocy technicznej obsługujący aplikację muszą wiedzieć, co się dzieje po kliknięciu określonych przycisków. Wielu programistów nie lubi pisać dokumentacji i pozostawia to zadanie na koniec z nadzieją, że nie będzie na nie czasu z uwagi na rozpoczęcie następnego projektu. Jednak przygotowanie dokumentacji jest złem koniecznym. Dokumentowanie pisanego kodu Z czasem w aplikacji mogą się pojawić zmiany i dodatkowe elementy. Nawet jeśli sam je wprowadzasz, upływ czasu od momentu napisania kodu może sprawić, że także Ty nie będziesz dokładnie wiedział, jak działa kod. Wyobraź sobie, o ile trudniejsze będzie to dla innych osób! Warto pisać samodokumentujący się kod, stosując spójne konwencje nazewnicze dla zmiennych, stałych i procedur. Dla procedur twórz logiczne nazwy, które w prosty i jednoznaczny sposób opisują działanie kodu. Jeśli nie potrafisz wymyślić sensownej nazwy dla procedury, możliwe, że wykonuje ona zbyt wiele operacji i warto ją podzielić. W razie potrzeby stosuj komentarze, jednak ich nie nadużywaj. Jeśli będzie ich za dużo, nikt nie będzie ich czytał i szybko staną się nieaktualne. Komentarze powinny dotyczyć ważnych decyzji projektowych, które programista chce udokumentować, a także nieintuicyjnych technik programowania trudnych do zrozumienia bez dodatkowego wyjaśnienia. Rysunek 31.5 przedstawia krótką procedurę, która w dużej części sama jest swoją dokumentacją. Procedura, zmienne i stałe mają odpowiednie nazwy, a komentarz wyjaśnia działanie nietypowego wiersza kodu. Sam twórz nazwy obiektów i formantów bazy danych. Nie akceptuj domyślnych nazw, które Access nadaje obiektom baz danych, np. formularzom i formantom. Nazwy domyślne są jedynie udogodnieniem dla prostych aplikacji i nie powinny być stosowane w kodzie na profesjonalnym poziomie. Dokumentowanie aplikacji Aplikacji dostarczanej użytkownikom końcowym powinna towarzyszyć dokumentacja objaśniająca, jak należy korzystać z programu. Dokumentacja dla użytkowników nie musi zawierać opisu struktury wewnętrznej ani logiki, na której opiera się interfejs użytkownika. Powinna jednak wyjaśniać, jak działają formularze i raporty, opisywać rzeczy,
Rozdział 31. Dystrybucja aplikacji Accessa
961
Rysunek 31.5. Jeśli to możliwe, twórz kod, który sam jest swoją dokumentacją
na które użytkownicy powinni uważać (np. modyfikowanie istniejących danych), i obejmować wydruki przykładowych raportów. Do zilustrowania dokumentacji należy posłużyć się zrzutami ekranu. Dokumentacja powinna też zawierać w tytule lub stopce dokładny numer wersji aplikacji, aby użytkownicy mieli pewność, że jest przeznaczona dla stosowanego przez nich oprogramowanie.
Użytkownikom aplikacji przyda się pomoc online wbudowana w bazę danych. Pomoc online obejmuje oczywiście szereg elementów, od wskazówek ekranowych dołączanych do formularzy, przez tekst w pasku stanu aż po wyrafinowaną pomoc kontekstową i pomoc „Co to jest?”, którą można spotkać w wielu produktach Microsoftu. Często korzystne jest, jeśli to użytkownik pisze dokumentację użytkownika (oczywiście we współpracy z programistą). Pozwala to zagwarantować, że aplikacja będzie napisana w języku zrozumiałym dla użytkowników.
Testowanie aplikacji przed dystrybucją W trakcie projektowania aplikacji myśl o tym, jak przetestować jej różne aspekty. Planowanie testów na etapie projektowania to najlepsze rozwiązanie, ponieważ dobrze znasz wtedy funkcje formularzy i raportów. Nie odkładaj pracy nad testami do momentu zakończenia pisania kodu, ponieważ możesz mieć trudności z przypomnieniem sobie wszystkich ważnych elementów, które trzeba przetestować. Napisz plan testów w trakcie projektowania obiektu aplikacji (np. tabeli lub formularza) albo niedługo potem. Nie przejmuj się tym, że plan testów nie jest doskonały. Przed udostępnieniem aplikacji będziesz mógł go zmienić.
962
Część VII Zaawansowane techniki programowania w Accessie
Plany testów postaraj się zrealizować tak szybko jak to możliwe. Następnie ponownie przeprowadź testy, gdy cały projekt będzie ukończony i będziesz gotowy do dystrybucji aplikacji. Pierwsze testy dają gwarancję, że obiekt jest zaprojektowany zgodnie z planem. Wykonanie testów po zakończeniu prac daje pewność, że późniejsze zmiany nie spowodowały pojawienia się błędów. Może się okazać, że z uwagi na zmiany w projekcie testy nie są już przydatne. Takie zmiany wprowadzane są nieustannie, a jeśli testy nie są już poprawne, można je usunąć lub zmodyfikować tak, aby sprawdzały nowe funkcje. Dystrybucja aplikacji, która jest w stu procentach wolna od błędów, jest niemal niemożliwa. Natura tworzenia oprogramowania jest taka, że jeśli ktoś pisze program, to ktoś inny może go złamać i na pewno kiedyś znajdzie na to sposób. Niektórzy są nawet wyspecjalizowani i bardzo utalentowani w tym kierunku i zazwyczaj potrafią złamać aplikację (inaczej mówiąc, odkryć krytyczny błąd) w ciągu kilku minut korzystania z niej. Jeżeli znasz takich ludzi — zatrudnij ich do testowania! Ich pomoc może okazać się nieoceniona.
Podczas procesu usuwania błędów w aplikacji należy przyporządkować błędy do jednej z trzech kategorii:
Kategoria 1: błędy krytyczne — takie błędy są absolutnie nie do przyjęcia, na przykład funkcje numeryczne w aplikacjach księgowych, które zwracają niepoprawne wyniki, albo procedury, które powodują, że aplikacja nieoczekiwanie kończy swoje działanie. Jeżeli ktoś udostępni aplikację ze znanymi błędami kategorii 1., może przygotować się na lincz ze strony swoich klientów!
Kategoria 2: poważne błędy, dla których istnieje obejście — są to poważne usterki, ale użytkownicy w dalszym ciągu mogą wykonywać swoje zadania, ponieważ w aplikacji istnieją pewne obejścia. Na przykład przycisk na pasku narzędzi, który nie powoduje wywołania procedury, to błąd. Jeżeli ten przycisk stanowi jedyny sposób wywołania procedury, to taki błąd należy zaliczyć do kategorii 1. Jeżeli jednak daną procedurę można z powodzeniem wywołać za pomocą polecenia menu, błąd ten należy zaliczyć do kategorii 2. Udostępnianie aplikacji z błędem kategorii 2. jest czasami koniecznością. Chociaż rozpowszechnianie aplikacji z błędem jest z reguły niedopuszczalne, to, na przykład z powodu konieczności dotrzymania terminów, czasami trzeba zrobić wyjątek. Błędy kategorii 2. będą denerwowały klientów, ale nie powinny doprowadzać ich do furii. W przypadku rozpowszechniania aplikacji ze znanymi błędami kategorii 2., należy je opisać! Niektórzy programiści wobec błędów kategorii 2. przyjmują postawę, którą można opisać jako „nic nikomu nie mów i udawaj zaskoczenie”. Takie podejście może doprowadzić do frustracji użytkowników oraz spowodować, że niepotrzebnie stracą mnóstwo czasu, próbując nie tylko odkryć problem, ale także znaleźć rozwiązanie. Na przykład w przypadku konieczności dystrybucji aplikacji z błędem kategorii 2. opisanym w przykładzie należy w pliku Czytaj.to dla tej aplikacji umieścić zdanie: Przycisk formularza XYZ nie wywołuje poprawnie procedury takaitaka. W celu wywołania procedury użyj polecenia takaitaka na wstążce. Odpowiednia poprawka będzie udostępniona wkrótce.
Kategoria 3: niewielkie błędy i niedociągnięcia — są to niewielkie usterki, które nie wpływają na działanie aplikacji. Mogą to być literówki w tytułach okien lub niewłaściwe kolory pól tekstowych. Błędy kategorii 3. należy poprawić niezwłocznie, ale poprawianiu ich nigdy nie należy nadawać wyższego priorytetu od rozwiązywania błędów kategorii 1. Należy poprawić je przed błędami
Rozdział 31. Dystrybucja aplikacji Accessa
963
kategorii 2. tylko wtedy, kiedy wygląd aplikacji jest całkowicie nie do przyjęcia lub kiedy sprawiają tak wiele kłopotów użytkownikom, że szybka poprawka jest niezbędna. Podzielenie błędów na kategorie i systematyczne ich poprawianie pozwala na stworzenie programu, który wygląda i działa zgodnie z oczekiwaniami użytkowników. Czasami może się wydawać, że poprawienie wszystkich błędów kategorii 1. jest niemożliwe, ale z pewnością kiedyś to się uda. Pewnego dnia programista może z zadowoleniem stwierdzić, że na liście błędów pozostało tylko kilka błędów kategorii 2. i zaledwie kilkanaście kategorii 3. Chociaż programistów często kusi, aby pominąć fazę testowania wersji beta, nie należy tego robić. W dłuższej perspektywie zaniechanie testowania spowoduje jeszcze większe koszty. Kiedy aplikacja działa w środowisku runtime, nie wszystkie właściwości programu Access są dostępne. Aby przetestować działanie aplikacji w środowisku runtime, posługując się pełną wersją programu Access, można wykorzystać opcję wiersza polecenia /Runtime podczas uruchamiania aplikacji programu Access. Należy kliknąć opcję Wyszukiwanie z menu bocznego systemu Windows, a następnie otworzyć aplikację Uruchom. Można też utworzyć odpowiedni skrót.
Dopracowywanie aplikacji Po dokładnym przetestowaniu aplikacji, kiedy wydaje się, że jest ona gotowa do dystrybucji, warto poświęcić trochę czasu, aby ja dopracować.
Nadanie aplikacji spójnego wyglądu i wrażenia W pierwszej kolejności należy wybrać określone standardy projektowe i zastosować je w aplikacji. Jest to niezwykle ważne, jeśli aplikacja ma wyglądać profesjonalnie. Formularz z przykładami różnych stylów formantów zaprezentowano na rysunku 31.6. Rysunek 31.6. Można wybrać dowolny styl interfejsu aplikacji. Jednak po wyborze określonego stylu należy stosować go konsekwentnie
Przykładowe decyzje projektowe, które należy podjąć, są następujące:
Czy pola tekstowe mają być wklęsłe, płaskie z ramką, płaskie bez ramki, uwypuklone czy wzniesione?
Jaki ma być kolor tła pól tekstowych?
964
Część VII Zaawansowane techniki programowania w Accessie
Jaki ma być kolor formularzy?
Czy do oddzielania powiązanych ze sobą elementów będą wykorzystane ramki uwypuklone czy też wgłębione lub wzniesione?
Jaki ma być rozmiar przycisków w formularzu?
W przypadku formularzy zawierających podobne przyciski (np. Zamknij i Pomoc), w jakiej kolejności będą wyświetlane te przyciski?
Jakie klawisze skrótów zastosujesz dla powszechnie używanych przycisków, takich jak Zamknij lub Pomoc?
Który formant ma być aktywny po otwarciu formularza?
W jakiej kolejności można będzie przechodzić między formantami za pomocą klawisza tabulacji?
Jak mają działać pola tekstowe po uzyskaniu fokusu?
Czy chcesz dodać wizualne wskazówki, aby odróżnić listy umożliwiające zaznaczenie wielu elementów i tylko jednej pozycji?
Czy chcesz dodać wizualne wskazówki dla pól kombi z ustawioną właściwością Ogranicz do listy? Dbanie o spójny wygląd i działanie aplikacji jest najważniejszym aspektem tworzenia profesjonalnych aplikacji. Aby znaleźć inspiracje związane z tym, jakie standardy projektowe można zastosować w aplikacjach, warto poświęcić trochę czasu, przeglądając ulubione programy po to, aby zaobserwować rozwiązania, jakie w nich zastosowano. W dziedzinie wyglądu aplikacji i ogólnego wrażenia wzorowanie się na innym programiście zazwyczaj nie jest odbierane jako plagiat, a znacznie częściej jako wyraz uznania. Wzorowanie się nie powinno jednak polegać na wykorzystaniu ikon innej aplikacji lub dokładnym kopiowaniu wyglądu i działania produktów konkurencji — jest to bardzo zła praktyka.
Dodawanie popularnych, profesjonalnych komponentów W większości profesjonalnych aplikacji występuje kilka podobnych komponentów. Do najpopularniejszych należą ekran powitalny, okno O programie oraz panel przełączania. Elementy te mogą się wydawać nieistotne, jednak czasem znacznie zwiększają atrakcyjność aplikacji. Ich dodanie nie wymaga wiele czasu, dlatego należy stosować je we wszystkich udostępnianych aplikacjach. Ekran powitalny Ekran powitalny (jego przykład pokazano na rysunku 31.7) nie tylko daje wrażenie szybkiego działania aplikacji, ale także nadaje jej profesjonalny wygląd już od chwili rozpoczęcia jej działania. Na rysunku 31.7 pokazano widok projektu szablonu ekranu powitalnego, który można zastosować w trakcie tworzenia własnych aplikacji. Ten formularz znajduje się w bazie danych Rozdział31.accdb. Jego nazwa to frmSplashScreen. Wystarczy zaimportować go do własnej aplikacji i wykorzystać jako szablon do utworzenia własnego ekranu powitalnego.
Rozdział 31. Dystrybucja aplikacji Accessa
965
Rysunek 31.7. Ekran powitalny nie tylko daje złudzenie, że aplikacja szybko się uruchamia, ale także nadaje jej profesjonalny wygląd
Ekran powitalny powinien zawierać następujące elementy:
Dodatkowo na ekranie powitalnym można umieścić informacje dotyczące licencji i (lub) ilustrację. W przypadku umieszczenia ilustracji należy zadbać o to, aby była ona zgodna z funkcjami wykonywanymi przez aplikację. Na przykład dla aplikacji do wypisywania czeków można użyć ilustracji, na której będzie kilka monet oraz rysunek czeku. Na ekranie powitalnym można także użyć clipartu. Należy tylko się upewnić, czy ilustracja jest czytelna i spójna i nie koliduje z umieszczonymi na niej informacjami tekstowymi. Aby zastosować ekran powitalny, należy go załadować przed wykonaniem jakichkolwiek czynności (ekran powitalny można ustawić za pomocą opcji Wyświetl formularz w grupie Opcje aplikacji opisanej we wcześniejszej części tego rozdziału). Kiedy w aplikacji zakończy się wykonywanie procedur inicjalizacji, można zamknąć ekran powitalny. Na formularzu spełniającym rolę ekranu powitalnego nie należy umieszczać zbyt wielu informacji, a wszystkie mapy bitowe należy przekształcić na ilustracje, co wpłynie na skrócenie czasu ładowania ekranu. Panel przełączania Panel przełączania (ang. switchboard) stanowi drogowskaz dla użytkowników, którzy dzięki niemu mogą odnaleźć funkcje i formularze dostępne w aplikacji. Panel przełączania można wykorzystać jako formularz wejściowy i zastosować przyciski do wyświetlania innych formularzy (tak jak w przykładowym panelu przełączania pokazanym na rysunku 31.8). Widoczny na rysunku panel przełączania frmSwitchboard pochodzi z przykładowej bazy danych MiniAuta dla Kolekcjonerów dołączonej do tej książki.
966
Część VII Zaawansowane techniki programowania w Accessie
Rysunek 31.8. Panel przełączania to poręczny sposób poruszania się w aplikacji
Panel przełączania to znane miejsce, które zapewnia, że użytkownicy nie pogubią się w aplikacji. Każdorazowo, kiedy użytkownik zamknie formularz, należy ponownie wyświetlić panel przełączania.
Pole O programie Okno O programie (zobacz rysunek 31.9) powinno zawierać informacje o firmie oraz o prawie autorskim, a także nazwę i numer wersji aplikacji. Umieszczenie w oknie O programie informacji dotyczących licencji (jeżeli mamy takie informacje) także jest dobrym pomysłem. Rysunek 31.9. Okno O programie dostarcza użytkownikom przydatnych informacji oraz zabezpiecza interesy prawne autora
Okno O programie spełnia rolę informacji prawnej o tym, kto jest właścicielem aplikacji, oraz ułatwia pomoc techniczną, dając użytkownikom łatwy dostęp do informacji o wersji. W niektórych bardziej zaawansowanych oknach O programie wywołuje się inne formularze, które wyświetlają informacje systemowe. Okno O programie można dowolnie komplikować, ale proste formularze zwykle doskonale spełniają swoje zadanie.
Rozdział 31. Dystrybucja aplikacji Accessa
967
Optymalne wykorzystanie grafiki Wielu użytkowników uwielbia ilustracje, a większość programistów uwielbia umieszczać ilustracje na przyciskach. Badania wykazały, że jasne i spójne ilustracje są bardziej intuicyjne, dzięki czemu łatwiej je rozpoznać niż napisy tekstowe. Programiści w większości nie są jednak artystami i zazwyczaj do tworzenia przycisków wykorzystują cliparty, które akurat mają pod ręką. Takie brzydkie przyciski nadają aplikacji niezgrabny i nieprofesjonalny wygląd. Dodatkowo zastosowanie ilustracji, które nie przedstawiają dokładnie przeznaczenia przycisku, powoduje, że używanie aplikacji staje się trudniejsze. Należy utworzyć lub wybrać takie przyciski, które użytkownicy z łatwością rozpoznają. Należy unikać ilustracji abstrakcyjnych lub takich, których rozpoznanie wymaga specyficznej wiedzy. Jeżeli budżet na to pozwala, warto zastanowić się nad wynajęciem profesjonalnej firmy, która zajmie się utworzeniem ilustracji na przyciskach. Na rynku dostępnych jest wiele profesjonalnych galerii ilustracji oraz narzędzi do tworzenia i edycji przycisków. Właściwie dobrane ilustracje na przyciskach nie tylko poprawiają wygląd aplikacji, ale także ułatwiają jej wykorzystywanie. Na rysunku 31.9 pokazano szablon formularza O programie, który można wykorzystać do tworzenia własnych aplikacji. Ten formularz znajduje się w bazie danych Rozdział31.accdb. Jego nazwa to frmAbout. Wystarczy zaimportować go do własnej aplikacji i wykorzystać jako szablon do tworzenia własnego formularza O programie.
Okno O programie powinno być dostępne z menu Pomoc lub za pośrednictwem przycisku na panelu przełączania. Pasek stanu Informowanie użytkowników o tym, co dzieje się w aplikacji, jest ważnym aspektem zapewniania komfortu posługiwania się programem. Access udostępnia funkcję SysmCmd, która umożliwia wyświetlanie komunikatów na pasku stanu (wąskim kolorowym pasku w dolnej części ekranu). Domyślnie pasek stanu zawiera informacje na temat stanu używanego obiektu. Na przykład gdy formularz jest otwarty w widoku projektu, po lewej stronie paska stanu widoczny jest napis Widok projektu. Pasek stanu informuje też, czy wciśnięty jest klawisz Num Lock. W zależności od typu otwartego obiektu po prawej stronie paska stanu mogą znajdować się ikony umożliwiające szybką zmianę widoku. Za pomocą funkcji SysCmd można w lewej części paska stanu wyświetlać własne komunikaty. Pasek stanu to doskonałe miejsce na wyświetlanie mniej istotnych informacji, ponieważ nie wymaga żadnej interwencji ze strony użytkownika (oprócz, oczywiście, przeczytania komunikatu). Aby wyświetlić komunikat na pasku stanu, zastosuj parametr acSysCmdSetStatus w sposób pokazany w poniższym kodzie: Private Sub cmdHelpText_Click() Const sMSG As String = "Witaj, świecie!" SysCmd acSysCmdSetStatus, sMSG End Sub
968
Część VII Zaawansowane techniki programowania w Accessie
Ten kod wyświetla tekst Witaj, świecie! na pasku stanu. Można wyświetlić w tym miejscu także dowolny inny tekst. Jeśli jednak łańcuch znaków jest dłuższy niż miejsce przeznaczone na niego przez Accessa, nic się nie pojawi. Za pomocą paska stanu można też informować użytkownika o tym, co się dzieje w długich procesach. W poniższym kodzie pasek stanu jest aktualizowany w trakcie przechodzenia programu w pętli przez duży zbiór rekordów. Private Sub cmdLoop_Click() Dim rs As ADODB.Recordset Dim sSql As String Dim lCnt As Long sSql = "SELECT * FROM tblLarge;" Set rs = New ADODB.Recordset rs.Open sSql, CurrentProject.Connection, _ adOpenKeyset, adLockReadOnly Do While Not rs.EOF lCnt = lCnt + 1 If lCnt Mod 10 = 0 Then SysCmd acSysCmdSetStatus, _ "Przetwarzanie rekordu numer " & lCnt & " z " & rs.RecordCount DoEvents End If rs.MoveNext Loop SysCmd acSysCmdClearStatus rs.Close Set rs = Nothing End Sub
Gdy przetwarzanych jest wiele rekordów, warto wyświetlać licznik — tak jak w powyższym kodzie. Kod ten co dziesiąty rekord aktualizuje pasek stanu. Gdyby informacje aktualizowane były po każdym rekordzie, zmiany byłyby tak szybkie, że użytkownik nie zdążyłby ich zauważyć. Ponadto nadużywanie paska stanu może prowadzić do spadku wydajności, dlatego warto aktualizować go tylko wtedy, gdy jest to potrzebne. Funkcja Mod zwraca resztę z dzielenia pierwszej wartości przez drugą. Gdy reszta to zero, wartość licznika jest wielokrotnością liczby 10 i procedura aktualizuje pasek stanu. Należy ustalić wielokrotność odpowiednią dla używanych danych. Pasek stanu powinien być aktualizowany na tyle często, że użytkownik nie pomyśli, iż program się zatrzymał, a jednocześnie na tyle rzadko, aby tekst nie zmieniał się zbyt szybko i by nie spadała wydajność programu. Warto zwrócić uwagę na kilka aspektów tego kodu. Zbiór rekordów jest otwierany za pomocą kursora typu adOpenKeyset. Otwarcie zbioru rekordów przy użyciu takiego kursora pozwala zastosować właściwość RecordCount, aby pobrać łączną liczbę rekordów. W pętli używane jest słowo kluczowe DoEvents. W czasie działania kodu można korzystać z wszystkich zasobów systemu Windows. Niektóre operacje, np. odświeżanie ekranu, są odraczane do momentu zakończenia pracy kodu. Nie jest to pomocne, gdy progra-
Rozdział 31. Dystrybucja aplikacji Accessa
969
mista chce wyświetlać tekst na pasku stanu. Polecenie DoEvents powoduje krótkotrwałe przekazanie sterowania do systemu Windows, dzięki czemu system może wykonać zadania z kolejki zdarzeń. Na rysunku 31.10 pokazano aktualizowany pasek stanu. Rysunek 31.10. Pasek stanu pozwala wyświetlać informacje zwrotne przy wykonywaniu długich procesów
Pod koniec procedury używany jest parametr acSysCmdClearStatus, który powoduje przekazanie kontroli nad paskiem stanu z powrotem do Accessa. Jeśli nie zamierzasz wyświetlać komunikatów na pasku stanu, a jednocześnie nie chcesz, aby Access je wyświetlał, możesz za pomocą polecenia SysCmd umieścić na pasku jedną spację. Instrukcja SysCmd acSysCmdSetStatus, Space(1) spowoduje, że pasek stanu będzie pusty dopóty, dopóki nie zechcesz go użyć.
Wskaźnik postępu Access udostępnia wbudowany wskaźnik postępu na pasku stanu w dolnej części głównego okna Accessa. Wskaźnik ten to prostokąt, który wydłuża się w trakcie wykonywania przez Accessa długiego procesu. Utworzenie i korzystanie ze wskaźnika postępu wymaga inicjalizacji, a następnie inkrementowania wskaźnika do następnej wartości. Podczas inkrementowania nie można po prostu zwiększać wartości licznika zarządzanego przez SysCmd. Trzeba bezpośrednio ustawić w liczniku wartość pomiędzy 0 i wartością maksymalną określoną podczas inicjalizacji. Poniższy kod i demonstracja jego działania znajdują się w formularzu frmSysCmdDemo w bazie danych Rozdział31.accdb.
Do inicjalizacji wskaźnika użyj stałej acSysCmdInitMeter. Należy przekazać tekst opisu oraz maksymalną wartość wskaźnika: Private Sub cmdInitMeter_Click() Const sSTATUSTEXT As String = "ODCZYT DANYCH" mlMeterMax = 100 mlMeterIncrement = 0 SysCmd acSysCmdInitMeter, sSTATUSTEXT, mlMeterMax End Sub
Ta procedura ustawia wartość maksymalną na 100 i inicjuje zmienną mlMeterIncrement wartością zero. Po uruchomieniu tej procedury wskaźnik pojawi się na pasku stanu Accessa, co pokazano na rysunku 31.11.
970
Część VII Zaawansowane techniki programowania w Accessie
Rysunek 31.11. Wskaźnik postępu po zainicjowaniu
Inkrementacja wskaźnika jest nieco kłopotliwa. W poniższej podprocedurze zmienna mlMeterIncrement z poziomu modułu jest inkrementowana o 10 i na podstawie jej wartości określany jest wygląd wskaźnika. Private Sub cmdIncrementMeter_Click() mlMeterIncrement = mlMeterIncrement + 10 If mlMeterIncrement > mlMeterMax Then mlMeterIncrement = 0 End If SysCmd acSysCmdUpdateMeter, mlMeterIncrement End Sub
Procedura ta sprawdza, czy wartość zmiennej mlMeterIncrement nie przekracza wartości maksymalnej ustawionej w procedurze inicjującej. Jeśli wartość przekracza limit, jest ponownie ustawiana na zero. Jest to ciekawe w przykładowym kodzie, jednak w praktyce najlepiej jest ustawić maksimum na odpowiednią wartość, która nie zostanie przekroczona. Rysunek 31.12 ilustruje wskaźnik postępu po pięciu inkrementacjach. Łatwo zauważyć, że pasek przesunął się o wartość proporcjonalną do wartości mlMeterIncrement. Rysunek 31.12. Wskaźnik postępu w połowie zakresu
W aplikacji trzeba ustalić wartość maksymalną wskaźnika postępu i wartość inkrementacji. Ponadto należy aktualizować wskaźnik w odpowiednich odstępach czasu, np. co 1/10 procesu (oczywiście jeśli od początku wiadomo, ile elementów jest przetwarzanych lub jak długo potrwa wykonywanie operacji). Wskaźnik jest cenną metodą informowania użytkownika o postępach długotrwałego procesu. Dzięki temu, że programista kontroluje jego wartość początkową i szybkość inkrementacji, może dość dokładnie informować o postępie działania aplikacji. Jedynym problemem z domyślnym wskaźnikiem postępu w Accessie jest to, że pojawia się na samym dole ekranu i użytkownicy mogą go łatwo przeoczyć. Ponadto jeśli programista ukryje pasek stanu za pomocą opcji Wyświetl pasek stanu z zakładki Bieżąca baza danych w oknie Opcje programu Access (zobacz rysunek 31.1), wskaźnik postępu w ogóle nie będzie widoczny. Jeśli chcesz ukryć pasek stanu, ale wyświetlać wskaźnik postępu, który użytkownicy z pewnością zobaczą, możesz utworzyć własny wskaźnik za pomocą formularza i kilku etykiet. Rysunek 31.13 przedstawia wskaźnik postępu tego typu. Na początku utwórz niezwiązany formularz z dwoma etykietami. Jedna powinna znajdować się nad drugą
Rozdział 31. Dystrybucja aplikacji Accessa
971
Rysunek 31.13. Samodzielnie utworzony wskaźnik postępu
(właściwości Szerokość, Wysokość, Górny i Lewy obu powinny mieć te same wartości). Etykieta umieszczona pod spodem powinna mieć ustawiony we właściwości Kolor tła jaśniejszy kolor niż etykieta górna. W trakcie działania programu wartość właściwości Szerokość górnej etykiety należy zwiększać, co daje złudzenie, że ciemniejszy kolor wypełnia pole. Formularz udostępnia kilka właściwości, które pozwalają uzyskać wygląd i styl upodabniający formularz do wskaźnika postępu. Te właściwości formularza przedstawia tabela 31.1. Tabela 31.1. Właściwości formularza używanego jako wskaźnik postępu Właściwość
Wartość
Opis
Podręczny
Tak
Wraz z właściwością Modalny określa, że formularz zawsze będzie znajdował się na wierzchu i nie będzie można wybrać innych formularzy.
Modalny
Tak
Wraz z właściwością Podręczny określa, że formularz zawsze będzie znajdował się na wierzchu i nie będzie można wybrać innych formularzy.
Tytuł
Postęp
Można zmienić wartość tej właściwości, aby dostosować wskaźnik postępu do własnych potrzeb.
Allow Datasheet View
Nie
Wskaźnik postępu należy wyświetlać tylko w widoku formularza.
Zezwalaj na widok układu
Nie
Wskaźnik postępu należy wyświetlać tylko w widoku formularza.
Autośrodkowanie
Tak
Powoduje umieszczenie wskaźnika postępu na środku ekranu.
Selektory rekordów
Nie
Ukrywa selektory rekordów.
Przyciski nawigacyjne
Nie
Ukrywa przyciski nawigacyjne.
Pole menu sterowania
Nie
Ukrywa menu sterowania.
Przycisk Zamknij
Nie
Ukrywa przycisk Zamknij.
Przyciski Min Maks
Nie
Ukrywa przyciski minimalizacji i maksymalizacji.
Styl obramowania
Dialog
Powoduje, że wskaźnik postępu wygląda jak okno dialogowe.
W bazie danych Rozdział31.accdb formularz frmSysCmdDemo wywołuje formularz frmProgress i cały kod przedstawiony w tym punkcie.
972
Część VII Zaawansowane techniki programowania w Accessie
Aby utworzyć wskaźnik postępu z rysunku 31.13, najpierw dodaj dwie niestandardowe właściwości do formularza frmProgress. Obok wbudowanych właściwości formularzy Accessa można stosować także dodane właściwości charakterystyczne dla rozwijanej aplikacji. Dodaj właściwość Max, aby określić maksymalną długość paska postępu, oraz właściwość Progress, która odpowiada aktualnemu postępowi procesu. Private mlMax As Long Private mdProgress As Double Public Property Get Max() As Long Max = mlMax End Property Public Property Let Max(lMax As Long) mlMax = lMax End Property Public Property Get Progress() As Double Progress = mdProgress End Property Public Property Let Progress(dProgress As Double) mdProgress = dProgress End Property
Do definiowania niestandardowych właściwości w języku VBA służy słowo kluczowe Property. Zadeklaruj na poziomie modułu zmienną mlMax. Posłuży ona do przechowywania wartości właściwości. Następnie dodaj procedury Property Get i Property Let przeznaczone do wczytywania oraz zapisywania wartości właściwości. Można też pominąć instrukcję Get lub Let, aby utworzyć właściwość przeznaczoną tylko do odczytu lub tylko do zapisu. Zdarzenie Form_Load umożliwia zainicjowanie szerokości górnej etykiety lblPmFront. Szerokość dolnej etykiety, lblPmBack, zawsze pozostaje taka sama. Private Sub Form_Load() Me.lblPmFront.Width = 0 End Sub
Ostatni fragment kodu formularza frmProgress to niestandardowa metoda do aktualizowania paska postępu. Metoda ta to podprogram zadeklarowany za pomocą słowa kluczowego Public. Public Sub UpdateProgress(lProgress As Long) If lProgress >= Me.Max Then Me.Progress = 1 Else Me.Progress = lProgress / Me.Max End If Me.lblPmFront.Width = Me.lblPmBack.Width * Me.Progress End Sub
Rozdział 31. Dystrybucja aplikacji Accessa
973
Pierwsza część tej metody określa, czy wartość argumentu lProgress nie jest większa od limitu. Jeśli jest, właściwość Progress zostaje ustawiona na 1 (to odpowiednik 100%). Dzięki temu poziom wskaźnika postępu nigdy nie przekracza 100%. Jeżeli wartość argumentu lProgress jest mniejsza od limitu, procedura ustawia właściwość Progress na wynik dzielenia wartości lProgress przez limit. W ostatnim kroku na podstawie tego wyniku ustawiana jest szerokość formantu lblPmFront. Poniżej znajdziesz procedurę z formularza frmSysCmdDemo, w którym używany jest omawiany wskaźnik postępu. Procedura ta bardzo przypomina kod zastosowany we wcześniejszej części rozdziału do aktualizowania paska stanu w trakcie przechodzenia programu przez duży zbiór danych. Private Sub cmdLoopProgress_Click() Dim rs As ADODB.Recordset Dim sSql As String Dim lCnt As Long Const sFORMPROGRESS As String = "frmProgress" sSql = "SELECT * FROM tblLarge;" Set rs = New ADODB.Recordset rs.Open sSql, CurrentProject.Connection, _ adOpenKeyset, adLockReadOnly DoCmd.OpenForm sFORMPROGRESS Set frmProgress = Forms(sFORMPROGRESS) frmProgress.Max = rs.RecordCount Do While Not rs.EOF lCnt = lCnt + 1 If lCnt Mod 10 = 0 Then frmProgress.UpdateProgress lCnt DoEvents End If rs.MoveNext Loop DoCmd.Close acForm, sFORMPROGRESS End Sub
Ta procedura otwiera formularz frmProgress i przypisuje go do zmiennej, co umożliwia dostęp do właściwości Max i metody UpdateProgress. Właściwość Max jest ustawiana na wartość rs.RecordCount, a w pętli wywoływana jest metoda UpdateProgress, do której przekazywana jest zmienna lCnt. W ostatnim fragmencie procedura zamyka formularz z paskiem dostępu.
Ułatwienie uruchamiania aplikacji Nie należy oczekiwać, że użytkownicy będą szukać pliku danych Accessa (.accdb lub .mdb) albo uruchamiać aplikację za pomocą okna PLIK/Otwórz w Accessie. Dodanie pozycji do menu Start systemu Windows nie jest trudne. Poprawnie zastosowana ikona programu stworzy wrażenie, że aplikacja jest zupełnie niezależna od Accessa, i nada jej status równoważny programom takim jak Word, Excel lub inne programy użytkowe.
974
Część VII Zaawansowane techniki programowania w Accessie
Utworzenie ikony programu jest łatwe. W internecie można znaleźć wiele edytorów ikon, freeware i shareware. Przy ich użyciu możesz tworzyć zupełnie nowe ikony. Przykładowej bazie danych Rozdział31.accdb towarzyszy własna ikona programu (Earth.ico), z którą będziesz mógł poeksperymentować. Ikonę można przypisać w opcjach startowych programu Access (zobacz podrozdział „Opcje aplikacji” we wcześniejszej części rozdziału) lub w Eksploratorze Windows. Wykonaj opisane poniżej czynności, aby utworzyć skrót systemu Windows do aplikacji bazodanowej Accessa: 1. W katalogu pakietu Microsoft Office (zwykle jest to C:\Program Files\ Microsoft Office\Office15) znajdź plik MSACCESS.EXE. 2. Kliknij plik MSACCESS.EXE prawym przyciskiem myszy i wybierz opcję Utwórz skrót z menu kontekstowego. 3. Wciśnij klawisz F2, gdy skrót jest zaznaczony, i wprowadź nową nazwę ikony. 4. Kliknij ikonę prawym przyciskiem myszy i wybierz opcję Właściwości z menu. Pojawi się okno dialogowe Właściwości skrótu. 5. W oknie dialogowym wybierz kartę Skrót i wpisz pełną ścieżkę do pliku .accdb lub .mdb aplikacji w polu tekstowym Element docelowy. Uważaj, aby nie usunąć ani nie zmienić ścieżki do pliku wykonywalnego Accessa.
Na rysunku 31.14 ścieżka do bazy danych to C:\Access13\Rozdział31.accdb. Zauważ, że pole tekstowe Element docelowy zawiera ścieżkę do programu wykonywalnego Accessa, po której następuje ścieżka do pliku .accdb. Rysunek 31.14. Można łatwo skonfigurować Accessa tak, by baza danych była automatycznie otwierana po kliknięciu ikonę programu
Rozdział 31. Dystrybucja aplikacji Accessa
975
Jeśli ścieżka do bazy danych obejmuje odstępy, koniecznie trzeba całą ścieżkę ująć w cudzysłów.
6. Kliknij przycisk Zmień ikonę. Pojawi się okno dialogowe Zmienianie ikony. 7. Kliknij przycisk Przeglądaj i przejdź do pliku ikony (rozszerzenie .ico), który chcesz zastosować (zobacz rysunek 31.15). Rysunek 31.15. Kolorowa ikona może ułatwić znalezienie aplikacji w zatłoczonym folderze lub na pulpicie
8. Przeciągnij skrót na pulpit lub na pasek szybkiego uruchamiania, aby umożliwić wygodne włączanie aplikacji Accessa. W systemie Windows 7 można przyczepić aplikację do paska zadań w dolnej części okna. W tym celu kliknij ikonę aplikacji prawym przyciskiem myszy i wybierz opcję Przypnij ten program do paska zadań z menu podręcznego. Przyczepienie ikony aplikacji do paska zadań to wygodny sposób na to, aby aplikacja była zawsze pod ręką.
Dodatkowa ochrona aplikacji Proces ten polega na zabezpieczeniu aplikacji przed skutkami nierozsądnej obsługi. Obejmuje to śledzenie błędów, których przyczyną może być działanie użytkowników — na przykład wprowadzanie niepoprawnych danych, próba uruchomienia funkcji w czasie, kiedy aplikacja nie jest na to gotowa, lub umożliwienie użytkownikowi wciśnięcia przycisku Oblicz, zanim zostaną wprowadzone wszystkie niezbędne dane. Dodatkowa ochrona aplikacji jest fazą tworzenia oprogramowania, którą należy wykonać równolegle z testowaniem i usuwaniem błędów oraz powtórzyć, gdy aplikacja działa i usunięto z niej błędy. Przechwytywanie błędów w języku VBA zostało opisane w rozdziale 26.
Przechwytywanie błędów wszystkich procedur języka Visual Basic Procedury obsługi błędów umożliwiają wyświetlanie użytkownikom przyjaznych komunikatów o błędzie zamiast nieintuicyjnych komunikatów domyślnych. Na rysunku 31.16 zaprezentowano komunikat Run-Time error '2102', który nie jest intuicyjny, jednak oprócz tego komunikatu dodatkowo wyświetla się bardziej szczegółowy komunikat o tym, że formularz nie istnieje lub popełniono pomyłkę w nazwie. Użytkownik nie zna nazwy formularza, zatem nie wie, czy popełniono błąd w nazwie formularza czy też formularz nie istnieje. Z tego powodu potrzebna jest procedura przechwytywania błędów, która dostarczy użytkownikom bardziej opisowych komunikatów o błędach niż ten, który pokazano na rysunku 31.16.
976
Część VII Zaawansowane techniki programowania w Accessie
Rysunek 31.16. Komunikat o błędzie powstały w wyniku wykonania procedury bez funkcji obsługi błędów
Jednym z ważniejszych aspektów wzmacniania odporności aplikacji na występujące błędy jest zapewnienie ciągłości jej działania — tzn. wyeliminowanie możliwości całkowitego i niespodziewanego zakończenia jej działania. Chociaż w programie Access istnieje wbudowana obsługa błędów dla większości błędów wprowadzania danych (np. wprowadzania znaków w polach typu Walutowy), nie ma automatycznej obsługi błędów powstałych w kodzie VBA. W każdej procedurze zapisanej w tym języku należy umieścić kod obsługi błędów, co opisano w rozdziale 26. W aplikacji działającej w środowisku runtime wszystkie błędy w kodzie, które nie zostaną przechwycone, powodują całkowite zakończenie działania programu. Użytkownicy nie mają możliwości obsługi takich sytuacji, a w ich wyniku może dojść do utraty dużych ilości danych. Po takim błędzie jedyną możliwością jest ponowne uruchomienie aplikacji. Prowadzenie dzienników użycia Dzienniki użycia rejestrują takie informacje, jak nazwa lub ID użytkownika, data i godzina. Dostarczają cennych informacji, zwłaszcza jeśli wystąpi jakiś błąd. Wprawdzie łatwo przedobrzyć z ilością rejestrowanych informacji, lecz poprawnie zaprojektowany dziennik użycia pozwoli precyzyjnie ustalić, czy dany błąd występuje tylko wtedy, gdy określony użytkownik korzysta z systemu lub jest wykonywana konkretna kwerenda. Rejestrowane informacje dodawane do bazy danych mogą obejmować znaczniki czasowe rekordów zapisywane podczas zmian w tabeli. Trzeba jednak pamiętać, że im więcej informacji będziesz rejestrować, tym wolniej aplikacja będzie działać. Rejestrowane zdarzenia zwiększają też objętość bazy danych, o ile dziennik nie jest przechowywany w innym miejscu. Można nawet dostosować poziom rejestrowania zdarzeń do potrzeb wybranych użytkowników lub grup użytkowników. Na podstawie informacji wprowadzonych do formularza logowania aplikacja może przy uruchamianiu ustalić, jaki poziom rejestrowania ma być stosowany podczas sesji. Aby znacznie ułatwić przeglądanie dzienników, można nawet rejestrować zdarzenia w tabeli mieszczącej się w zewnętrznej bazie danych w innym systemie w sieci. Dziennik błędów jest też doskonałym narzędziem do przeprowadzenia poawaryjnej analizy aplikacji, która nie działa poprawnie. Dodając rejestrowanie błędów do każdej podprocedury i funkcji, która może zawieść podczas wykonywania programu, ustalisz, co wydarzyło się w chwili wystąpienia błędu, zamiast polegać na opisie podanym przez użytkownika.
Rozdział 31. Dystrybucja aplikacji Accessa
977
Rejestrowanie błędów czasem może dawać niepożądane rezultaty. Na przykład błąd powodujący pętlę nieskończoną może z łatwością doprowadzić do zużycia całego miejsca na dysku w komputerze użytkownika, jeśli każda iteracja pętli doda kolejny komunikat do dziennika błędów. Z rejestrowania błędów należy korzystać z rozwagą. Można dodać tę funkcję do wszystkich procedur aplikacji podczas testów beta, a bezpośrednio przed udostępnieniem aplikacji użytkownikom zmniejszyć liczbę wywołań procedury rejestrującej błędy. Można nawet przygotować mechanizm, który pozwoli użytkownikowi włączyć rejestrowanie błędów, jeśli napotka na powtarzalny problem w aplikacji bazodanowej. Funkcja przedstawiona w następnym listingu zapewnia podstawowy mechanizm rejestrowania błędów. Funkcja LogError() zapisuje do pliku tekstowego w katalogu, w którym znajduje się baza danych, następujące informacje:
bieżącą datę i godzinę;
nazwę procedury, która wywołała błąd;
numer błędu;
opis błędu;
formularz, który był aktywny w chwili wystąpienia błędu (jeśli nie był otwarty żaden formularz, zostanie zarejestrowana wartość pusta);
nazwa formantu, który był aktywny w chwili wystąpienia błędu (jeśli nie był wybrany żaden formant, zostanie zarejestrowana wartość pusta).
Zapisywanie dziennika w pliku tekstowym zamiast w bazie danych sprawia, że baza danych jest mniejsza i wydajniejsza. Public Sub LogError(ProcName As String, _ ErrNum As Integer, ErrDescription As String) Dim sFile As String, lFile As Long Dim aLogEntry(1 To 6) As String Const sLOGFILE = "Error.log" Const sLOGDELIM = "|" On Error Resume Next sFile = CurrentProject.Path & "\" & sLOGFILE lFile = FreeFile aLogEntry(1) = Format(Now, "yyyy-mm-dd hh:mm:ss") ' Znacznik czasu aLogEntry(2) = ErrNum aLogEntry(3) = ErrDescription aLogEntry(4) = ProcName ' Mogą mieć wartość NULL aLogEntry(5) = Screen.ActiveForm.Name aLogEntry(6) = Screen.ActiveControl.Name Open sFile For Append As lFile Print #lFile, Join(aLogEntry, sLOGDELIM) Close lFile End Sub
978
Część VII Zaawansowane techniki programowania w Accessie
Ta prosta podprocedura dodaje informacje do istniejącego pliku Error.log lub tworzy taki plik w katalogu z bazą danych. Każdemu napotkanemu błędowi odpowiada jeden wiersz w tym pliku tekstowym, a poszczególne informacje są rozdzielone pionową kreską. Najważniejszymi elementami dziennika błędów są data i godzina, numer błędu i opis błędu. Może przydać się nazwa procedury, lecz trzeba ją zakodować na sztywno dla każdej procedury (podprocedury lub funkcji) obsługiwanej przez procedurę LogError(). Poniższa procedura celowo generuje błąd. Pozwala to przetestować procedurę LogError. Procedurę tę można uruchomić za pomocą przycisku z formularza frmError. Po kilkakrotnym kliknięciu tego przycisku zawartość pliku Error.log może wyglądać tak jak na rysunku 31.17. Private Sub cmdError_Click() Dim x As Long On Error GoTo ErrHandler x = 1 / 0 ErrExit: Exit Sub ErrHandler: LogError "cmdError_Click", Err.Number, Err.Description Resume ErrExit End Sub
Rysunek 31.17. Błędy można zapisywać w pliku tekstowym
Gdy nadejdzie pora na przyjrzenie się błędom, można otworzyć plik tekstowy, aby sprawdzić, co się stało. Można też zaimportować plik do tabeli Accessa, co pozwoli na sortowanie i filtrowanie danych. Rysunek 31.18 przedstawia plik Error.log zaimportowany do tabeli. Po przeanalizowaniu danych tabelę Error można usunąć, aby baza danych nadmiernie się nie rozrosła. Warto zapisać proces importowania dziennika błędów. Dzięki temu będziesz mógł łatwo zaimportować dane, gdy następnym razem zechcesz się im przyjrzeć. Więcej informacji o importowaniu plików tekstowych znajdziesz w rozdziale 6.
Rozdział 31. Dystrybucja aplikacji Accessa
979
Rysunek 31.18. Dziennik błędów można zaimportować do tabeli
Oddzielanie tabel od pozostałej części aplikacji W aplikacjach należy oddzielić obiekty kodu (formularze, raporty, kwerendy, moduły i makra) od tabel. Umieszczenie tych obiektów w osobnych plikach .accdb przynosi wiele korzyści:
Użytkownicy korzystający z bazy danych za pośrednictwem sieci odnoszą korzyść w postaci szybszego działania aplikacji, jeżeli plik .accdb z kodem (baza danych zawierająca kwerendy, formularze, makra, raporty i moduły) jest uruchamiany lokalnie, a sieć jest wykorzystywana tylko po to, aby uzyskać dostęp do wspólnych danych.
Można z łatwością udostępniać uaktualnienia.
Można wydajniej archiwizować dane, ponieważ nie trzeba marnować miejsca na dysku i czasu na ciągłe archiwizowanie obiektów kodu.
Wszystkie profesjonalne aplikacje — zwłaszcza te, które mają być wykorzystywane w sieci, powinny składać się z osobnych plików .accdb przeznaczonych dla kodu i danych. W rozdziale 7. znajdziesz więcej informacji na temat oddzielania tabel od pozostałych elementów bazy danych (powstaje w ten sposób podzielona baza danych).
Tworzenie formularzy odpornych na błędy Aby zahartować aplikację, można w każdym formularzu wykonać kilka czynności:
Usunąć przyciski Min, Maks i Zamknij z formularza podczas projektowania. Aby zamknąć formularz, użytkownicy będą zmuszeni do korzystania z narzędzi nawigacyjnych wbudowanych w aplikację, co pozwoli aplikacji na przetestowanie i zweryfikowanie wprowadzonych danych. Przy korzystaniu z interfejsu z dokumentami kartotekowymi przyciski Min i Maks są niedostępne, a przycisk Zamknij jest reprezentowany przez symbol X po prawej stronie paska nad głównym oknem formularza. Usunięcie przycisku Zamknij z formularza w takim interfejsie powoduje dezaktywację symbolu X, który jednak wciąż jest widoczny.
W każdym formularzu zawrzeć przycisk Zamknij lub Cofnij, powodujący przejście do poprzedniego lub następnego formularza aplikacji. Przyciski te powinny we wszystkich formularzach znajdować się mniej więcej w tym samym
980
Część VII Zaawansowane techniki programowania w Accessie
miejscu i być jednakowo opisane. Nie należy w jednym formularzu używać przycisku Zamknij, w innym Wróć, a jeszcze w innym Cofnij.
Podczas projektowania ustawić we właściwości ViewsAllowed formularza wartość Form. Uniemożliwi to użytkownikom wyświetlenie formularza jako arkusza danych.
We wszystkich odpowiednich miejscach stosować formularze modalne. Należy pamiętać, że formularze modalne zmuszają użytkownika do używania formantów danego formularza — użytkownik nie ma dostępu do żadnej innej części aplikacji, gdy formularz modalny jest otwarty.
Stosować własne przyciski nawigacyjne, które sprawdzają warunki EOF (znak końca pliku) i BOF (początek pliku). Za pomocą zdarzenia OnCurrent można weryfikować informacje i konfigurować formularz, gdy użytkownik przechodzi z jednego formantu do drugiego.
Używać właściwości Tekst paska stanu w każdym formancie, by informować użytkownika, jak korzystać z danego formantu. We wszystkich formantach, w których jest to przydatne, powinna też być ustawiona właściwość Tekst etykietki formantu. Jeśli chcesz używać właściwości Tekst paska stanu, musisz wyświetlać sam pasek stanu (zobacz rysunek 31.1).
Sprawdzanie poprawności danych wprowadzanych przez użytkownika Jedną z najważniejszych technik hartowania aplikacji jest kontrola poprawności wszystkich danych, które użytkownik wprowadza do bazy. Wychwytywanie błędnych danych już w trakcie ich wprowadzania to jedno z najważniejszych zabezpieczeń, jakie można wbudować w aplikację. W wielu przypadkach możesz sprawdzać poprawność na poziomie tabel (używając właściwości Reguła poprawności i Tekst reguły spr. poprawności każdego pola), lecz w wielu przypadkach przydaje się większa kontrola nad komunikatami, które otrzymuje użytkownik, lub nad akcjami, które baza danych podejmie w odpowiedzi na błędne dane. Jeden z głównych problemów z właściwością Reguła poprawności polega na tym, że reguła nie jest sprawdzana, dopóki użytkownik nie przejdzie do następnego formantu, przez co nie można przechwytywać niepoprawnych wartości. Znacznie lepiej jest kontrolować poprawność wpisów w kodzie. Często przydaje się kontrola poprawności wszystkich formantów formularza przed zdarzeniem BeforeUpdate, zamiast sprawdzania każdego formantu z osobna.
Korzystanie z opcji /runtime Jeśli ochrona aplikacji nie jest ważna i chcesz tylko uniemożliwić przypadkowe jej uszkodzenie przez użytkowników w wyniku modyfikacji lub usunięcia obiektów, możesz wymusić uruchamianie Accessa w trybie runtime. Gdy baza danych działa w tym trybie,
Rozdział 31. Dystrybucja aplikacji Accessa
981
wszystkie elementy interfejsu, które umożliwiają modyfikowanie obiektów, są ukryte przed użytkownikami. W trybie tym użytkownicy nie mogą też uzyskać dostępu do okienka nawigacji. Przy korzystaniu z opcji /runtime trzeba się upewnić, że aplikacja obejmuje formularz startowy, który zapewnia użytkownikom dostęp do potrzebnych obiektów. Standardowo służy do tego główne menu lub główny panel przełączania w aplikacji. Aby ustawić formularz jako startowy, otwórz bazę danych, wybierz opcję PLIK/Opcje i otwórz zakładkę Bieżąca baza danych. W sekcji Opcje aplikacji wybierz na liście rozwijanej Wyświetl formularz, aby wyświetlić formularz, który ma być używany jako startowy. Formularze startowe zostały opisane dokładnie w podrozdziale „Dopracowywanie aplikacji” we wcześniejszej części rozdziału.
Z lektury wcześniejszej części rozdziału, punktu „Ułatwienie uruchamiania aplikacji”, dowiedziałeś się, jak w systemie Windows utworzyć skrót do uruchamiania aplikacji Accessa. Wymuszanie trybu runtime w Accessie jest proste. Wystarczy we właściwościach skrótu dodać opcję /runtime po ścieżce do pliku z bazą. Pokazano to na rysunku 31.19. Rysunek 31.19. Dodawanie opcji /runtime do skrótu
Jeśli dla bazy danych ustawiono hasło, użytkownik będzie musiał je wprowadzić przed otwarciem bazy. Access obsługuje pliki z nowym rozszerzeniem, .accdr, które są automatycznie otwierane w trybie runtime. Aby utworzyć zablokowaną wersję bazy danych Accessa, zmień rozszerzenie pliku bazy danych z .accdb na .accdr. W celu odzyskania wszystkich możliwości przywróć rozszerzenie .accdb.
982
Część VII Zaawansowane techniki programowania w Accessie
Szyfrowanie i kodowanie bazy danych Jeśli bezpieczeństwo ma duże znaczenie, w ostatnim kroku należy zaszyfrować lub zakodować bazę. W programie Microsoft Access używane jest silne szyfrowanie oparte na algorytmie RC4 i długich kluczach. W ten sposób można zabezpieczyć dane i inną zawartość baz Accessa. Aby zaszyfrować bazę .accdb Accessa, wykonaj następujące czynności: 1. Otwórz istniejącą bazę .accdb (np. Rozdział31.accdb) w trybie wyłączności. 2. Kliknij przycisk PLIK w lewym górnym rogu ekranu i wybierz opcję Szyfruj przy użyciu hasła na zakładce Informacje (zobacz rysunek 31.20).
Rysunek 31.20. Szyfrowanie bazy danych Accessa
3. W polu Hasło wprowadź hasło, które chcesz wykorzystać do zabezpieczenia bazy danych (zobacz rysunek 31.21). Access nie wyświetla hasła. Zamiast tego pokazuje gwiazdkę (*) dla każdej litery. Rysunek 31.21. Podawanie hasła używanego do zaszyfrowania bazy danych Accessa
4. Ponownie wprowadź to samo hasło w polu Weryfikuj i kliknij przycisk OK.
Rozdział 31. Dystrybucja aplikacji Accessa
983
Zaszyfrowana baza danych dla użytkowników wygląda tak samo jak każda inna aplikacja Accessa. Po szyfrowaniu nie występują widoczne różnice w wyglądzie formularzy i raportów aplikacji. Jedyną różnicą jest to, że użytkownik musi podać hasło przy każdym otwarciu bazy. Przy szyfrowaniu bazy danych warto wiedzieć o następujących wadach tej techniki:
Wielkość zaszyfrowanych baz danych nie zmienia się przy korzystaniu z programów archiwizujących (takich jak WinZip) lub wysyłaniu bazy do skompresowanego katalogu. Proces szyfrowania zmienia sposób przechowywania danych na dysku twardym, dlatego skutki zastosowania narzędzi archiwizujących są niewielkie lub nawet zerowe.
Wydajność zaszyfrowanych baz danych spada (do 15%). W zależności od rozmiaru bazy danych i szybkości komputera spadek wydajności może okazać się niedostrzegalny.
Warto też pamiętać, że po zaszyfrowaniu bazy nie można uzyskać dostępu do danych lub obiektów bazy bez odpowiedniego hasła. Zawsze przechowuj w bezpiecznym miejscu niezaszyfrowaną kopię zapasową bazy danych na wypadek utraty lub przypadkowej zmiany hasła. Nie istnieje uniwersalne hasło do odszyfrowywania zaszyfrowanych baz Accessa. Ponieważ w Accessie stosowane jest silne szyfrowanie, nie ma sposobu na odszyfrowanie bazy danych bez poprawnego hasła. Usuwanie hasła bazy danych Aby usunąć hasło z zaszyfrowanej bazy danych i przywrócić ją do pierwotnego, niezaszyfrowanego stanu, wykonaj następujące czynności: 1. Otwórz zaszyfrowaną bazę danych .accdb (np. Rozdział31.accdb) w trybie wyłączności. 2. Kliknij przycisk PLIK w lewym górnym rogu ekranu i wybierz opcję Odszyfruj bazę danych w zakładce Informacje (zobacz rysunek 31.22). Pojawi się okno dialogowe Cofanie ustawienia hasła bazy danych (zobacz rysunek 31.23). 3. Wprowadź hasło do bazy danych i kliknij przycisk OK.
Zabezpieczanie kodu Visual Basica Dostęp do kodu VBA aplikacji można kontrolować za pomocą hasła dla chronionego projektu Visual Basica. Jeśli ustawisz hasło dla projektu, użytkownicy będą musieli wprowadzić je za każdym razem, gdy zechcą podejrzeć kod Visual Basica z danej bazy. Projekt Visual Basica to w tym kontekście zestaw modułów standardowych i modułów klas (kodu powiązanego z formularzami i raportami), który jest częścią bazy danych Accessa.
1. Za pomocą kombinacji klawiszy Alt+F11 otwórz edytor VBE. 2. W edytorze kodu VBA wybierz opcję Tools/Rozdział31 Properties. Pojawi się okno dialogowe Project properties.
984
Część VII Zaawansowane techniki programowania w Accessie
Rysunek 31.22. Usuwanie hasła z zaszyfrowanej bazy danych Accessa Rysunek 31.23. Podawanie hasła w celu usunięcia go z zaszyfrowanej bazy danych Accessa
3. Otwórz zakładkę Protection (zobacz rysunek 31.24). Rysunek 31.24. Utworzenie hasła dla projektu uniemożliwia użytkownikom podejrzenie kodu VBA aplikacji
Rozdział 31. Dystrybucja aplikacji Accessa
985
4. Zaznacz pole wyboru Lock project for viewing. 5. Wprowadź hasło w polu tekstowym Password. Access nie pokazuje hasła. Zamiast tego wyświetla gwiazdkę (*) dla każdej litery. 6. Ponownie wprowadź hasło w polu tekstowym Confirm password i kliknij przycisk OK. Ten mechanizm gwarantuje, że nie popełnisz literówki w trakcie wprowadzania hasła (takie zagrożenie istnieje, ponieważ nie widać wpisywanych znaków). Błąd w haśle mógłby uniemożliwić wszystkim, także Tobie, dostęp do bazy. Gdy zapiszesz i zamkniesz projekt, użytkownicy próbujący wyświetlić kod aplikacji będą musieli wprowadzić hasło. Access prosi o podanie hasła projektu tylko raz w trakcie sesji. Lepszą metodą zabezpieczania kodu, formularzy i raportów aplikacji jest udostępnianie bazy danych w pliku .accde. Jeśli zapisujesz bazę w takim pliku, Access kompiluje wszystkie moduły z kodem (w tym moduły formularzy), usuwa edytowalny kod źródłowy i kompaktuje bazę. Nowy plik .accde nie zawiera kodu źródłowego, ale działa poprawnie, ponieważ obejmuje skompilowaną wersję całego kodu. Jest to nie tylko doskonały sposób na zabezpieczenie kodu źródłowego, ale też metoda na udostępnianie mniejszych baz danych (bo nie zawierają kodu), w których moduły zawsze są skompilowane. Aby utworzyć plik .accde, wybierz opcję PLIK/Zapisz jako/Zapisz bazę danych jako i kliknij Utwórz plik ACCDE, jak pokazano na rysunku 31.25.
Rysunek 31.25. Aby chronić bazę danych, utwórz plik ACCDE
986
Część VII Zaawansowane techniki programowania w Accessie
Zabezpieczanie środowiska Profesjonalna aplikacja w Accessie musi oczywiście być zabezpieczona przed dostępem nieupoważnionych użytkowników. Wbudowany system zabezpieczeń (egzekwowanych przez silnik bazy danych ACE, nie przez Accessa) udostępnia kilka poziomów ochrony. Można na przykład zabezpieczyć pojedynczy obiekt bazy danych (formularz, tabelę, raport) przed dostępem poszczególnych osób, grup lub członków grupy. Nawet dla pojedynczego użytkownika może obowiązywać kilka poziomów zabezpieczeń, pod warunkiem, że dysponuje kilkoma nazwami użytkownika. Wszystkie obiekty zabezpieczeń Accessa, ich właściwości i metody są dostępne poprzez kod accessowego języka Visual Basic. Zabezpieczenia na poziomie użytkownika są dostępne tylko dla baz danych w formacie .mdb. Format .accdb zapewnia ochronę innego rodzaju, np. niedostępne w formacie .mdb silne szyfrowanie z wykorzystaniem hasła. Programista musi ustalić, czy do ochrony danych w aplikacjach Accessa potrzebuje zabezpieczeń na poziomie użytkownika czy silnych mechanizmów szyfrowania.
Ustawianie opcji startowych w kodzie Opcje, które ustawiasz w zakładce Bieżąca baza danych w oknie dialogowym Opcje programu Access (zobacz rysunek 31.1), stosują się globalnie do wszystkich użytkowników logujących się do bazy danych. Zdarzają się sytuacje, gdy przydaje się kontrola nad tymi opcjami poprzez kod startowy zamiast sterowania globalnie całą aplikacją. Na przykład administrator bazy danych powinien mieć większą kontrolę nad bazą danych (dostęp do menu, panelu nawigacji itp.) niż pracownik wprowadzający dane. Prawie wszystkie opcje dostępne w oknie dialogowym Opcje programu Access można zmieniać. Z punktu „Ustawianie wartości właściwości” dowiesz się, jak w Accessie wykorzystać kod VBA do kontrolowania wymienionych w tabeli 31.2 ustawień obiektu Application. Tabela 31.2. Właściwości obiektu Application związane z opcjami startowymi Opcja
Właściwość do ustawienia Typ danych
Tytuł aplikacji
AppTitle
dbText
Ikona aplikacji
AppIcon
dbText
Wyświetl formularz
StartupForm
dbText
Wyświetl okno bazy danych
StartupShowDBWindow
dbBoolean
Wyświetl pasek stanu
StartupShowStatusBar
dbBoolean
Wyświetl pasek menu
StartupMenuBar
dbText
Pasek menu skrótów
StartupShortcutMenuBar
dbText
Zezwalaj na pełne menu
AllowFullMenus
dbBoolean
Zezwalaj na domyślne menu skrótów
AllowShortcutMenus
dbBoolean
Zezwalaj na wbudowane paski narzędzi
AllowBuiltInToolbars
dbBoolean
Zezwalaj na zmiany w paskach narzędzi
AllowToolbarChanges
dbBoolean
Zezwalaj na wyświetlenie kodu po wystąpieniu błędu
AllowBreakIntoCode
dbBoolean
Użyj specjalnych klawiszy programu Access
AllowSpecialKeys
dbBoolean
Rozdział 31. Dystrybucja aplikacji Accessa
987
W zależności od nazwy użytkownika (i hasła) podanego w formularzu logowania można użyć kodu VBA dla ekranu powitalnego lub formularza panelu przełączania, aby ustawić lub zresetować dowolną z tych właściwości. Jasno widać, że właściwości te mają duży związek z kontrolowaniem środowiska Accessa podczas uruchamiania aplikacji. Warto wiedzieć, że liczne opcje z tabeli 31.2 (np. Ikona aplikacji) po zmodyfikowaniu wymagają ponownego uruchomienia bazy Accessa, aby zmiany zostały wprowadzone.
Blokada omijania opcji startowych W starszych wersjach Accessa programiści wykorzystywali makro AutoExec do różnych celów, np. do otwierania kontenera bazy danych, otwierania formularza startowego lub wykonywania jakiegoś kodu startowego. Problem w tym, że każdy użytkownik może z łatwością ominąć makro AutoExec przez przytrzymanie klawisza Shift podczas otwierania bazy danych. Właściwości startowe Accessa zmniejszają nieco uzależnienie od makr startowych i innych procedur. Niestety użytkownik nadal może ominąć pieczołowicie zaprojektowane opcje startowe, przytrzymując klawisz Shift podczas uruchamiania aplikacji. Ta czynność ujawnia oczywiście budowę aplikacji i obiekty, które ukryto za interfejsem użytkownika. Na szczęście projektanci Accessa przewidzieli potrzebę zabezpieczenia startu aplikacji, udostępniając właściwość bazy danych o nazwie AllowBypassKey. Właściwość ta, która przyjmuje wartości True lub False, włącza (lub wyłącza) wykorzystujące klawisz Shift ominięcie opcji przy starcie aplikacji. AllowBypassKey jest właściwością stosowaną jedynie przez programistów, więc nie jest wbudowana do baz danych Accessa. Trzeba ją utworzyć, dołączyć i ustawić podczas procesu budowania aplikacji. Po dołączeniu do zbioru Properties bazy danych można z niej korzystać w zależności od potrzeb.
Oto kod niezbędny do zaimplementowania właściwości AllowBypassKey: Public Sub SetBypass(bFlag As Boolean) Dim db As DAO.Database Dim pBypass As DAO.Property Const sKEYNAME As String = "AllowBypassKey" Set db = CurrentDb On Error Resume Next Set pBypass = db.Properties(sKEYNAME) On Error GoTo 0 If pBypass Is Nothing Then Set pBypass = db.CreateProperty(sKEYNAME, dbBoolean, bFlag) db.Properties.Append pBypass Else pBypass.Value = bFlag End If End Sub
988
Część VII Zaawansowane techniki programowania w Accessie
Procedura ta najpierw próbuje powiązać zmienną pBypass z właściwością AllowBypassKey. Jeśli wartość zmiennej po tej operacji to Nothing, oznacza to, że właściwość Allow BypassKey nie istnieje. Wtedy procedura tworzy tę właściwość i dołącza ją do bazy danych. Jeżeli właściwość już istnieje, wówczas właściwość Value ustawiana jest na wartość bFlag (jest to parametr przekazywany do procedury).
Ustawianie wartości właściwości Do dodawania właściwości służą metody CreateProperty i Properties.Append obiektu CurrentDb. W większości przypadków, o ile właściwość nie została już ustawiona w oknie dialogowym Opcje programu Access, nie jest ona dołączona do zbioru Properties bazy danych. Zanim spróbujesz ustawić wartość właściwości w kodzie, musisz się upewnić, czy właściwość ta już istnieje. Poniższa funkcja ustawia wartość właściwości startowej, tworząc i dołączając właściwość do zbioru Properties, jeśli właściwość jeszcze nie istnieje: Public Function SetStartupProperty(sPropName As String, _ ePropType As DAO.DataTypeEnum, vPropValue As Variant) As Boolean Dim db As DAO.Database Dim prp As DAO.Property Dim bReturn As Boolean Set db = CurrentDb On Error Resume Next Set prp = db.Properties(sPropName) If prp Is Nothing Then Set prp = db.CreateProperty(sPropName, ePropType, vPropValue) If prp Is Nothing Then bReturn = False Else db.Properties.Append prp bReturn = True End If Else prp.Value = vPropValue bReturn = True End If SetStartupProperty = bReturn End Function
Korzystanie z funkcji SetStartupProperty() jest proste. Trzeba tylko przed jej wywołaniem znać dokładną nazwę właściwości i jej typ danych. Poniższa podprocedura demonstruje, jak ustawić właściwość startową za pomocą tej funkcji: Sub ChangeAppTitle() Dim bSuccess As Boolean bSuccess = SetStartupProperty("AppTitle", dbText, "Aplikacja") If bSuccess Then MsgBox "Tytuł aplikacji został zmieniony."
Rozdział 31. Dystrybucja aplikacji Accessa
989
Else MsgBox "Tytuł aplikacji nie został zmieniony." End If End Sub
Zwróć uwagę, że właściwość AppTitle to dane typu łańcuchowego (dbText). Aby zobaczyć zmiany dokonane przez ustawienie właściwości AppTitle lub AppIcon, można posłużyć się metodą RefreshTitleBar. Jej składnia jest prosta: Application.RefreshTitleBar
Pobieranie wartości właściwości Pobranie wartości właściwości jest znacznie łatwiejsze niż jej ustawienie. Kolekcja Properties zwraca właściwość, a właściwość Value zwraca wartość pobranej właściwości. Oto kod potrzebny do pobrania wartości właściwości AppTitle: On Error Resume Next GetAppTitle = CurrentDb.Properties("AppTitle").Value
GetAppTitle jest tu zmienną typu String. Instrukcja On Error Resume Next jest potrzebna w sytuacji, gdy wartość właściwości nie jest jeszcze ustawiona.
990
Część VII Zaawansowane techniki programowania w Accessie
Część VIII
Access i Windows SharePoint Services W tej części:
Rozdział 32. Wprowadzenie do programu Windows SharePoint Services
Rozdział 33. Integrowanie Accessa z SharePointem
Rozdział 34. Wprowadzenie do usług Access Services
Rozdział 35. Instalowanie aplikacji Accessa w SharePoincie
Rozdział 36. Makra danych
Access wciąż jest rozwijany jako ważna część korporacyjnego środowiska zarządzania danymi. W każdej nowej wersji programu Microsoft Access dodawane są ważne funkcje. Choć Access nie jest dobrym narzędziem do tworzenia stron internetowych lub zarządzania nimi, Access 2013 udostępnia bardzo wartościowe mechanizmy do publikowania danych i obiektów aplikacji na serwerach SharePoint. W rozdziałach części VIII SharePoint traktowany jest jak korporacyjna platforma do obsługi współpracy. Wyjaśniono tu proces integrowania Accessa z SharePointem. Na początku zapoznasz się z prostym współużytkowaniem danych, a dojdziesz do publikowania aplikacji Accessa w SharePoincie. Część ta kończy się omówieniem makr danych. Umożliwiają one wykonywanie na poziomie tabeli ważnych zadań z zakresu zarządzania danymi. Oznacza to, że pewne mechanizmy (bardzo często są to reguły biznesowe) działają nawet wtedy, gdy dane z tabeli są używane w aplikacji sieciowej opartej na Accessie.
992
Część VIII Access i Windows SharePoint Services
Rozdział 32.
Wprowadzenie do programu Windows SharePoint Services W tym rozdziale:
Wprowadzenie do programu SharePoint
Korzystanie z list SharePointa
Omówienie podstaw integrowania Accessa z SharePointem
W książce tej opisano wiele nowych funkcji, które Microsoft wprowadził w Accessie 2013. Choć rozwiązania te są ciekawe i ekscytujące, okazują się drobiazgami w porównaniu z możliwością przenoszenia aplikacji Accessa na serwer WSS (ang. Windows SharePoint Services). W każdej nowej wersji Access udostępniał coraz większe możliwości w zakresie integracji z programem SharePoint. W wersji 2010 można przenieść aplikację Accessa w taki sposób, aby uruchamiać ją jako witrynę na serwerze SharePoint. Najciekawszym aspektem tego nowego modelu jest to, że możliwe stało się uruchamianie aplikacji Accessa w witrynach SharePointa. W kilku kolejnych rozdziałach omawiamy różne techniki, które pozwolą Ci przenieść bazy danych Accessa na serwer SharePoint. Najpierw jednak z tego rozdziału dowiesz się, czym jest SharePoint i w jaki sposób pomaga firmom we współużytkowaniu danych i we współpracy.
Wprowadzenie do SharePointa SharePoint to serwerowe środowisko współpracy rozwijane przez Microsoft. Obejmuje narzędzia do współużytkowania w firmowej sieci dokumentów i danych. SharePoint zwykle działa w firmowych sieciach jako zbiór witryn SharePointa. Witryna SharePointa jest witryną intranetową umożliwiającą różnym działom zarządzanie zabezpieczeniami, grupami roboczymi, dokumentami i danymi. Witryny te można zagnieżdżać w sobie w hierarchiczny sposób.
994
Część VIII Access i Windows SharePoint Services
Witryny SharePointa i ich strony dostępne są (podobnie jak inne witryny) za pomocą adresu URL, który użytkownik może wprowadzić w standardowej przeglądarce internetowej. SharePointa często używa się do tworzenia aplikacji intranetowych działających w sieciach LAN, a nie w internecie. SharePoint udostępnia wiele mechanizmów (np. sortowanie list i wyszukiwanie słów kluczowych), które nie są potrzebne w sieci WWW. Ponadto strony SharePointa mają zbyt wiele ograniczeń, aby serwer ten można było stosować jako ogólne narzędzie do rozwijania witryn internetowych. Domyślnie strony SharePointa mają po lewej stronie panel nawigacyjny, w górnej części pasek menu, a na prawo od panelu nawigacyjnego duży obszar na główną zawartość strony. Choć układ stron SharePointa można dowolnie zmieniać, ilość pracy potrzebnej na dostosowanie takich stron do potrzeb jest znacznie większa niż przy korzystaniu z tradycyjnych stron ASP.NET.
Przegląd typów witryn SharePointa Wprawdzie SharePoint najczęściej służy do współużytkowania dokumentów i tabel z danymi oraz wykonywania innych zadań z obszaru zarządzania treścią, nieraz stosowany jest też w innych celach. Microsoft udostępnia różnorodne szablony aplikacji, które można zmodyfikować pod kątem określonych wymagań. Oto niepełna lista dostępnych szablonów SharePointa:
raporty na temat wyników firmy,
zarządzanie salą zajęć,
rozpoczynanie prób klinicznych i zarządzanie nimi,
witryna do analiz konkurencji,
baza danych dyskusji,
zarządzanie spornymi fakturami,
witryna aktywności pracowników,
dodatkowe korzyści dla pracowników,
plan szkoleń i materiały dla pracowników,
śledzenie zintegrowanych kampanii marketingowych,
zarządzanie procesem produkcji,
otwarcie nowego sklepu,
planowanie zbierania wymagań produktowych i marketingowych,
zapytanie ofertowe,
liga sportowa,
witryna do pracy zespołowej,
zarządzanie czasem pracy.
Rozdział 32. Wprowadzenie do programu Windows SharePoint Services
995
SharePoint często służy na przykład do zarządzania dokumentacją potrzebną w pracy nad produktem. Witryna SharePointa poświęcona projektowi programistycznemu umożliwia wygodne rozpoczęcie prac, ich monitorowanie i informowanie o postępach. Ponieważ SharePoint umożliwia obsługę dokumentów niemal dowolnego typu, do witryny projektu można dodawać rysunki, filmy, schematy, zdjęcia itd., aby uczestnicy projektu mogli je przejrzeć i ocenić. Firmy korzystają z SharePointa do dystrybucji dokumentów kadrowych i dokumentów dotyczących polityki firmy. Ponieważ SharePoint zapewnia bezpieczeństwo na poziomie użytkowników i grup, można stosunkowo łatwo udostępnić stronę SharePointa konkretnemu działowi, a jednocześnie zablokować dostęp innym użytkownikom. SharePoint rejestruje też zmiany w dokumentach i obsługuje mechanizm pobierania i odsyłania plików, który pozwala kontrolować, kto ma prawo wprowadzać poprawki, a kto może dodawać nowe dokumenty i pliki. Jednym z najczęstszych zastosowań SharePointa jest przechowywanie dokumentów z kontrolą wersji (np. dokumentów Worda i arkuszy Excela). W wielu środowiskach do przesyłania dokumentów między użytkownikami służy poczta elektroniczna. Łatwo jest jednak wtedy pomylić wersje dokumentów. Ponadto przechowywanie wielu kopii dokumentu wymaga dużo miejsca na dysku. Ponieważ SharePoint zapewnia jedno źródło przechowywania, przeglądania i aktualizowania dokumentów, pozwala całkowicie wyeliminować wspomniane problemy.
Witryny SharePointa Przed przejściem do szczegółowego opisu integracji Accessa z SharePointem warto omówić typową witrynę SharePointa. Następny punkt pomoże Ci zrozumieć na podstawowym poziomie najważniejsze elementy witryn SharePointa — dokumenty i listy. SharePoint to rozbudowane narzędzie zasługujące na odrębną książkę. Dlatego nie znajdziesz tu omówienia tworzenia list lub bibliotek dokumentów SharePointa oraz zarządzania nimi. Zakładamy, że firma ma już witrynę SharePointa, którą można wykorzystać w Accessie. Jeśli chcesz nauczyć się konfigurowania SharePointa i zarządzania nim, polecamy książkę Beginning SharePoint 2013: Building Business Solutions with SharePoint autorstwa Amandy Perran, Shane’a Perrana, Jennifer Mason i Laury Rogers (wydawnictwo Wiley).
Dokumenty SharePointa Prawdopodobnie najczęstszym zastosowaniem SharePointa jest przechowywanie współużytkowanych dokumentów i innych plików. SharePoint śledzi pliki od momentu ich dodania do listy do czasu usunięcia z niej lub skasowania. Każdy użytkownik z uprawnieniami do zapisu w SharePoincie może udostępnić dokument do współużytkowania. Rysunek 32.1 przedstawia krótki wykaz różnych typów plików z biblioteki dokumentów SharePointa. Na rysunku 32.1 zwróć uwagę na to, że biblioteka obejmuje kilka różnych typów dokumentów. W każdym wierszu listy dokumentów znajduje się ikona określająca typ dokumentu, nazwa dokumentu, wielkość dokumentu, a także nazwisko osoby, która dodała plik do listy. Biblioteka obejmuje też informacje o stanie każdego obiektu.
996
Część VIII Access i Windows SharePoint Services
Rysunek 32.1. Biblioteka dokumentów w SharePoincie
Biblioteka dokumentów SharePointa obsługuje model pobierania i odsyłania plików. W danym momencie tylko jedna osoba może pobrać dokument w celu wprowadzenia w nim zmian. Choć na rysunku 32.1 nie jest to widoczne, SharePoint rejestruje pobieranie i odsyłanie dokumentów, a także śledzi, kto wprowadził zmiany. Można nawet nakazać SharePointowi anulowanie zmian i przywrócenie wcześniejszej wersji dokumentu, jeśli jest to konieczne. Ten mechanizm współużytkowania dokumentów często służy do udostępniania informacji w firmie. Umożliwia to współpracę między użytkownikami witryny SharePointa.
Listy SharePointa Użytkownicy SharePointa oprócz przechowywania i śledzenia całych dokumentów mogą też zapisywać i współużytkować dane za pomocą list SharePointa. Listy te przypominają tabele bazy danych, ponieważ każda lista obejmuje wiersze i kolumny. W każdej kolumnie przechowywane są dane określonego typu — tekst, daty, a nawet obiekty (np. zdjęcia). W tym uproszczonym ujęciu listy SharePointa to odpowiednik tabel Accessa. Typową listę SharePointa przedstawia rysunek 32.2. Jak widać, informacje są tu prezentowane na jednym ekranie. Można na nim dodawać nowe elementy oraz edytować i usuwać istniejące. Rysunek 32.2. Listy SharePointa umożliwiają przechowywanie i śledzenie danych w formacie tabelarycznym
SharePoint potrafi zarządzać danymi dowolnego typu, które użytkownicy mogą współużytkować z innymi osobami. Choć witrynę z rysunku 32.2 zaprojektowano w konkretnym celu, SharePointa można wykorzystać także w wielu innych scenariuszach. Na przykład dział kadr może za pomocą list SharePointa współużytkować i śledzić listy potrzebnych szkoleń, a dział IT może tworzyć listy zasobów (z uwzględnieniem statusu
Rozdział 32. Wprowadzenie do programu Windows SharePoint Services
997
i lokalizacji). Listy SharePointa mogą przydać się również w mniejszych organizacjach — lokalny klub kręglarski może udostępniać i przechowywać na takich listach plan turniejów oraz rankingi graczy. SharePoint obsługuje wiele list, dzięki czemu firma może utworzyć tyle list, ile potrzebuje. Na rysunku 32.3 widoczne są wszystkie listy dostępne w przykładowej witrynie SharePointa. Rysunek 32.3. Listy w przykładowej witrynie SharePointa
W odróżnieniu od tabel Accessa listy SharePointa nie są relacyjne. Nie można bezpośrednio powiązać danych z dwóch różnych list SharePointa ani tworzyć kwerend dla kilku list w celu znalezienia powiązanych informacji. Nie można też dodawać reguł sprawdzania poprawności dla poszczególnych kolumn list SharePointa ani dla całych list. Można jednak ograniczyć zakres wartości w kolumnach listy, aby zagwarantować, że na liście znajdą się poprawne dane. Dołączone dane SharePointa (proces ten został opisany w rozdziale 33.) można wykorzystać w aplikacjach Accessa tylko w ograniczony sposób. Ponieważ dane nie są relacyjne, a w listach SharePointa nie ma kluczy głównych, nie da się łatwo tworzyć sensownych relacji między dołączonymi listami SharePointa i tabelami Accessa. Jednak podczas lektury rozdziału 33. przekonasz się, że mimo to z danymi z SharePointa można dużo zrobić. Dane z SharePointa często wykorzystuje się w Accessie do zapełniania raportów lub łączenia danych z obu środowisk. Ponieważ w kwerendach Accessa można tworzyć jednorazowe złączenia, można też tworzyć raporty na podstawie danych z obu źródeł.
Omówienie podstaw integrowania Accessa z SharePointem Dane w SharePoincie przechowuje się na listach, które można połączyć z aplikacjami Accessa lub zaimportować do takich aplikacji. Listy SharePoint są dostępne w każdej witrynie SharePointa udostępniającej dane przez internet. Połączenie aplikacji z listami SharePointa powoduje, że dane w witrynie SharePointa są dostępne w Accessie jako tabele połączone. W kontekście użytkowania danych łączenie się z listami SharePointa nie różni się od łączenia z tabelami z baz danych serwera SQL
998
Część VIII Access i Windows SharePoint Services
Server lub innych źródeł danych. Jedyną różnicą (dla użytkownika) może być niewielkie opóźnienie związane z przesyłaniem danych z odległej witryny SharePointa do Accessa i z powrotem. SharePoint to narzędzie do współużytkowania danych przez internet. Witryna SharePointa zapewnia adres internetowy pozwalający na współużytkowanie danych przez wiele aplikacji. Aplikacje te mogą działać w dowolnym miejscu, przy czym muszą mieć dostęp do internetu. Jednak większość instalacji SharePointa to aplikacje wyłącznie intranetowe, używane tylko wewnątrz firmy w prywatnej sieci LAN. SharePoint nie jest uniwersalnym narzędziem do tworzenia witryn internetowych, a na jego stronach niedostępne są liczne mechanizmy przydatne w publicznych witrynach. Po połączeniu danych z SharePointa z aplikacją Accessa dane te są dostępne dla wszystkich użytkowników aplikacji. Oznacza to, że dane wprowadzone przez użytkowników SharePointa są widoczne i dostępne w aplikacji Accessa. Access staje się rozbudowaną aplikacją frontonową, w której zewnętrzne dane z SharePointa są używane tak, jakby były zapisane lokalnie. Użytkownik nie dostrzega niczego niezwykłego. Dla użytkownika aplikacja Accessa oparta na SharePoincie wygląda jak każda inna aplikacja Accessa — udostępnia te same ekrany do wprowadzania danych i raporty co każdy inny program tego rodzaju. W wielu firmach informatycznych dostępne jest środowisko oparte na SharePoincie. Możliwe, że SharePoint dostępny jest także w sieci Twojej firmy. Żaden pojedynczy użytkownik nie może samodzielnie utworzyć witryny SharePointa. Jeśli chcesz korzystać z tego narzędzia, skontaktuj się z działem informatycznym i zapytaj o dostęp do witryny SharePointa.
Rozdział 33.
Integrowanie Accessa z SharePointem W tym rozdziale:
Łączenie się z listami SharePointa
Importowanie list SharePointa
Eksportowanie tabel Accessa do SharePointa
Przenoszenie baz danych Accessa do SharePointa
Używanie szablonów list SharePointa
Już w kilku poprzednich rozdziałach tej książki poruszano temat różnych źródeł danych dla Accessa. Pokazane zostały metody importowania, łączenia oraz eksportowania danych. Na polu wymiany danych Access nie ma sobie równych. Dane z SharePointa połączone z aplikacją Accessa są dynamiczne i niemal natychmiast odzwierciedlają zmiany wprowadzone przez użytkowników. Integracja z SharePointem jest dla Microsoftu ważnym aspektem Accessa i pakietu Office 2013. Microsoft pracuje nad usprawnianiem współdziałania Accessa i SharePointa oraz współużytkowania danych między tymi programami. Usługi SharePoint mogą być zarówno lokalnie ograniczone do określonej firmy, jak i wynajmowane lub nawet dzierżawione od innych dostawców. Jeśli użytkownik otwiera raport Accessa, przynajmniej część danych może pochodzić z witryny SharePointa działającej tysiące kilometrów dalej. W tym rozdziale pokazujemy możliwości i swobodę, jakie daje wykorzystanie danych z SharePointa w aplikacjach Accessa. Początkową bazę danych dla tego rozdziału, Rozdział 33.accdb, można pobrać z witryny poświęconej tej książce.
1000
Część VIII Access i Windows SharePoint Services Aby wypróbować techniki współużytkowania danych opisane w tym rozdziale, będziesz potrzebować dostępu do serwera SharePoint. Jeśli chcesz korzystać z SharePointa, skontaktuj się z działem IT i zapytaj o dostęp do witryny SharePointa. Znajdziesz też witryny komercyjne, a nawet bezpłatne przykładowe usługi, które umożliwią Ci wypróbowanie SharePointa. W tym rozdziale wykorzystaliśmy przykładową witrynę dostępną pod adresem www.spsdemo.com.
Współużytkowanie danych Accessa z SharePointem Budowanie interfejsu Accessa przy wykorzystaniu SharePointa oznacza po prostu uruchomienie Accessa, podłączenie go do list SharePointa i następnie napisanie formularzy oraz raportów korzystających z tychże połączonych tabel. Dołączone listy SharePointa wyglądają w Accessie jak dowolne inne dołączone źródła danych. Więcej informacji o dołączaniu zewnętrznych danych znajdziesz w rozdziale 7.
Access 2013 umożliwia też importowanie danych SharePointa bezpośrednio do lokalnych tabel Accessa. Choć zaimportowane dane nie są połączone z witryną SharePointa (są więc „przestarzałe” w porównaniu z danymi używanymi w witrynie), czasem przydatny jest wycinek danych z takiej witryny.
Dołączanie list SharePointa Najbardziej podstawową formą współużytkowania danych między Accessem a SharePointem jest dołączanie list SharePointa i używanie danych w podobny sposób jak z innych dołączanych źródeł. Jedyna różnica związana jest z tym, że SharePoint nie obsługuje różnorodnych typów danych, dlatego dołączone listy SharePointa dają mniej możliwości niż na przykład połączone tabele baz SQL Servera. Dołączanie list SharePointa przypomina dołączanie innych źródeł danych. 1. Należy kliknąć listę rozwijaną Więcej w grupie Importowanie i łączenie w zakładce DANE ZEWNĘTRZNE. Pozwala to uzyskać dostęp do zaawansowanych opcji importowania i dołączania (zobacz rysunek 33.1). Rysunek 33.1. Przygotowywanie się do dołączenia listy SharePointa
Rozdział 33. Integrowanie Accessa z SharePointem
1001
2. Z listy opcji należy wybrać Lista programu SharePoint. Access otworzy okno dialogowe Pobieranie danych zewnętrznych — Witryna programu SharePoint (zobacz rysunek 33.2). W górnej części okna znajduje się lista niedawno odwiedzonych witryn SharePointa. Pod spodem widoczne jest pole tekstowe, w którym można wpisać adres URL docelowej witryny SharePointa. Jak może sobie przypominasz z rozdziału 32., witryny SharePointa są otwierane za pomocą adresu URL i znajdują się na serwerze WWW (najczęściej dostępnym w sieci LAN).
Rysunek 33.2. Okno dialogowe Pobieranie danych zewnętrznych — Witryna programu SharePoint
Aby utworzyć połączenie z listą SharePointa, potrzebne są odpowiednie uprawnienia. Bez nich Access nawet nie wyświetli list SharePointa ze wskazanej witryny. Na rysunku 33.3 widoczne jest standardowe okno logowania do SharePointa, w którym należy wprowadzić dane uwierzytelniające. Użytkownicy SharePointa są rozpoznawani na podstawie ich danych z usług Windows Active Directory i przynależności do odpowiednich grup SharePointa. Omawianie tych zagadnień wykracza poza zakres niniejszej książki, warto jednak wiedzieć, że dostęp do witryn i danych SharePointa jest chroniony w podobny sposób jak w innych aplikacjach systemu Windows. 3. Wpisz nazwę użytkownika i hasło. Jeśli używasz przykładowej witryny www.spsdemo.com, możesz podać nazwę użytkownika corp\demouser i hasło pass@word1. Zobaczysz wtedy zbiór list SharePointa z używanej witryny. Przy każdym elemencie na liście widoczne jest pole wyboru. 4. Zaznacz pole przy każdej liście, którą chcesz dołączyć, a następnie kliknij przycisk OK. Na rysunku 33.4 zaznaczona jest tylko lista Pages, ale można wybrać więcej list.
1002
Część VIII Access i Windows SharePoint Services
Rysunek 33.3. Okno logowania w programie SharePoint
Rysunek 33.4. Wybieranie dołączanych list SharePointa
Na rysunku 33.5 widoczna jest dołączona lista SharePointa wyświetlana w arkuszu danych Accessa. Ikony dołączonych list SharePointa bardzo przypominają ikony tabel Accessa. Przy każdej dołączonej liście widoczna jest strzałka, a kolor ikony to żółto-pomarańczowy. Dane w tabeli połączonej są zgodne z Accessem. Dane te można wykorzystać do tworzenia kwerend, formularzy i raportów. Warto zauważyć, że dane z dołączonych list są przeznaczone tylko do odczytu. Oznacza to, że w Accessie 2013 nie można modyfikować danych z list SharePointa.
Rozdział 33. Integrowanie Accessa z SharePointem
1003
Rysunek 33.5. Dołączona lista SharePointa wygląda jak inne tabele Accessa Zamiast wymagać od użytkowników logowania się za każdym razem, gdy używają danych SharePointa, po ustaleniu danych uwierzytelniających SharePointa Access tworzy tabelę UserInfo, w której przechowuje informacje na temat użytkownika i jego roli w SharePoincie. Choć użytkownik musi podać hasło, aby uzyskać początkowy dostęp do SharePointa, w tabeli UserInfo znajdują się dodatkowe informacje na temat danej osoby. Tabela ta znajduje się w Accessie, co oznacza, że jest dostępna przed zalogowaniem się użytkownika do SharePointa. Dzięki temu Access może udostępnić SharePointowi informacje o użytkowniku, gdy ten loguje się do SharePointa.
Importowanie list SharePointa Zamiast tworzyć aktywne połączenie z listą SharePointa, można ją zaimportować. Importowanie listy SharePointa pozwala pobrać jej stan z określonego momentu i umieścić dane w niezależnej, niepołączonej tabeli w Accessie. Zaimportowana lista SharePointa (w odróżnieniu od listy dołączonej) nie jest automatycznie aktualizowana nowymi danymi z SharePointa. Proces importowania listy SharePointa przypomina proces dołączania: 1. Kliknij listę rozwijaną Więcej w grupie Importowanie i łączenie w zakładce DANE ZEWNĘTRZNE. Pozwala to uzyskać dostęp do zaawansowanych opcji importowania i dołączania. 2. Z listy opcji wybierz Lista programu SharePoint. Pojawi się okno dialogowe Pobieranie danych zewnętrznych — Witryna programu SharePoint. 3. W górnej części otwartego okna dialogowego wybierz niedawno otwieraną witrynę SharePointa lub wprowadź adres URL nowej witryny. Następnie wybierz opcję importowania (tak jak na rysunku 33.6). 4. Podaj odpowiednie dane uwierzytelniające, aby połączyć się z listami SharePointa. Zobaczysz zbiór list SharePointa z określonej witryny. Przy każdej pozycji widoczne będzie pole wyboru. 5. Zaznacz pola przy listach, które chcesz zaimportować, a następnie kliknij przycisk OK. Access zaimportuje wybrane listy do tabeli. Będzie ją można przeglądać i stosować w taki sam sposób jak standardowe tabele z okienka nawigacji.
1004
Część VIII Access i Windows SharePoint Services
Rysunek 33.6. Wybieranie importowanej listy SharePointa
Eksportowanie tabel Accessa do SharePointa Czasem trzeba przesłać dane z Accessa do SharePointa, aby użytkownicy SharePointa uzyskali dostęp do tych samych informacji co osoby korzystające z Accessa. W pierwszym przykładzie opisano eksportowanie tabeli z Accessa do SharePointa: 1. Otwórz przykładową bazę danych Rozdział33.accdb. 2. Otwórz tabelę tblCustomers lub zaznacz ją w okienku nawigacji. Gdy otworzysz tabelę, na wstążce Accessa pojawi się kilka dodatkowych formantów. 3. Otwórz listę rozwijaną Więcej w grupie Eksportowanie w zakładce DANE ZEWNĘTRZNE. Wybierz opcję Lista programu SharePoint (zobacz rysunek 33.7). Pojawi się kreator witryny programu SharePoint. 4. Wprowadź adres URL witryny SharePointa (zobacz rysunek 33.8). Celem jest utworzenie listy SharePointa z wybranymi tabelami z bazy Accessa. 5. Kliknij przycisk OK. 6. Jeśli pojawi się prośba o dane logowania, wprowadź poprawną nazwę użytkownika i hasło SharePointa. Okno dialogowe logowania do SharePointa będzie bardzo podobne do okna z rysunku 33.3. Różnica polega na tym, że nowe okno wymaga tylko podania hasła (ponieważ nazwa użytkownika została zapisana w pamięci podręcznej).
Rozdział 33. Integrowanie Accessa z SharePointem
1005
Rysunek 33.7. Wybieranie SharePointa jako lokalizacji eksportowanych danych
Na dalszych stronach kreatora zobaczysz małe okno dialogowe z informacją o postępie procesu konwersji. Oznacza ono, że projekt tabeli Accessa jest kopiowany do SharePointa i powstaje nowa lista SharePointa. Po zakończeniu konwersji nowa lista jest wyświetlana w domyślnej przeglądarce. 7. Jeśli natrafiłeś na błędy lub ostrzeżenia, sprawdź pole Pokaż szczegóły w oknie kreatora i przeczytaj dostępne w nim informacje.
1006
Część VIII Access i Windows SharePoint Services Jeśli wykonujesz opisane operacje, używając przykładowej witryny SharePointa www.spsdemo.com, nie będziesz mógł utworzyć w niej nowej listy. Jest to zrozumiałe, ponieważ uprzejme osoby udostępniające tę witrynę nie chcą, aby tworzono w niej setki nieznanych nowych list. Aby dodać listę, musisz uzyskać dostęp do witryny SharePointa, na której będziesz mieć uprawnienia do zapisu.
8. Kliknij przycisk Zamknij w Accessie, aby zamknąć okno dialogowe Eksportowanie — Witryna programu SharePoint. Po zakończeniu procesu eksportowania dane będą się znajdowały w dwóch miejscach — w pierwotnej tabeli Accessa i na liście SharePointa. Te dwa źródła nie są ze sobą połączone, dlatego zmiany wprowadzone w jednym miejscu nie są widoczne w drugim. Eksportowanie pewnych typów pól do SharePointa sprawia problemy. Na przykład pole z obiektami OLE jest w SharePoincie puste (nie obejmuje żadnych danych). Jednak większość pozostałych typów pól jest poprawnie przekształcana na odpowiednie kolumny SharePointa i zapełniana danymi z tabeli Accessa. Tabela 33.1 przedstawia, w jaki sposób typy danych z Accessa są przekształcane na zgodne typy kolumn w SharePoincie. Zauważ, że listy SharePointa obsługują znacznie mniej typów danych niż tabele Accessa. Typy danych z tabeli 33.1 są stosowane za każdym razem, gdy tabele Accessa eksportuje się do SharePointa. Tabela 33.1. Konwersja na typy danych SharePointa Typ danych Accessa
Docelowy typ w SharePoincie
Autonumerowanie
Liczba
Krótki tekst
Pojedynczy wiersz tekstu
Długi tekst
Wiele wierszy tekstu (ograniczenie do 8192 znaków)
Wszystkie typy liczbowe (bajt, liczba całkowita, długa liczba całkowita, liczba pojedynczej precyzji, liczba podwójnej precyzji, liczba dziesiętna)
Liczba
Data/Godzina
Data i godzina
Waluta
Waluta
Tak/Nie
Tak/Nie
Obiekt OLE
Pojedynczy wiersz tekstu
Obliczeniowy
Obliczeniowa
Hiperłącze
Hiperłącze lub obraz
Przenoszenie tabel Accessa do SharePointa Zamiast eksportować tabele Accessa do SharePointa, można przenieść wszystkie tabele z aplikacji Accessa w jednej operacji eksportowania i dołączyć nowe listy SharePointa z powrotem do tej aplikacji. Wszystkie tabele z bazy Accessa zostaną wtedy przeniesione do SharePointa i dołączone z powrotem do Accessa w ramach jednego procesu.
Rozdział 33. Integrowanie Accessa z SharePointem
1007
Zaletą przenoszenia tabel Accessa do SharePointa jest to, że można utworzyć model danych w Accessie, gdzie dostępne są wygodne narzędzia do tworzenia tabel, a następnie przenieść ten model do SharePointa. Gdy dane znajdą się w SharePoincie, wprowadzane tam zmiany będą natychmiast odzwierciedlane w Accessie. Taki poziom integracji może umożliwiać wykorzystanie SharePointa jako mechanizmu do współużytkowania i śledzenia danych, a jednocześnie zapewniać dostęp do wygodniejszych narzędzi raportowania w Accessie. Przenoszenie tabel do SharePointa nie jest jedną z funkcji importowania i eksportowania Accessa 2013. Polecenia potrzebne do przeniesienia całego zbioru tabel Accessa do SharePointa znajdują się w zakładce NARZĘDZIA BAZY DANYCH na wstążce (zobacz rysunek 33.9). Rysunek 33.9. Grupa Przenoszenie danych na wstążce obejmuje kreator do przenoszenia baz do SharePointa
Gdy klikniesz przycisk SharePoint w grupie Przenoszenie danych, pojawi się okno dialogowe Kreator eksportowania tabel do programu SharePoint (zobacz rysunek 33.10). Niezbędny jest tu tylko adres URL docelowej witryny SharePointa — za resztę odpowiada Access. Rysunek 33.10. W Kreatorze eksportowania tabel do programu SharePoint należy podać docelową witrynę SharePointa
1008
Część VIII Access i Windows SharePoint Services
Zagadnienia, o których należy pamiętać przy przenoszeniu tabel Accessa do SharePointa Przed przeniesieniem tabel Accessa do SharePointa należy uwzględnić następujące kwestie:
Eksportowanie może się nie powieść, jeśli nazwa tabeli Accessa jest niezgodna z regułami tworzenia nazw w SharePoincie. Nazwy tabel Accessa mogą obejmować odstępy i niektóre znaki przestankowe, natomiast w nazwach list w SharePoincie dozwolone są tylko litery i nie można stosować odstępów. Jeśli proces eksportowania zakończy się niepowodzeniem, przyczyną prawdopodobnie będzie niewłaściwa nazwa listy.
Wszystkie kwerendy, formularze i raporty są teraz oparte na dołączonych tabelach i powinny działać w dawny sposób. Występują jednak pewne wyjątki. Z uwagi na niezgodność między danymi z Accessa i SharePointa nie każdy typ danych z Accessa można wykorzystać w SharePoincie. Niezgodne pola są dodawane do list SharePointa, ale jako puste kolumny tekstowe.
Problemy z eksportowaniem są zapisywane w tabeli o nazwie Problemy z przenoszeniem do witryny programu SharePoint. W tabeli tej każdy wiersz odpowiada jednemu problemowi. Jedno pole Accessa może spowodować powstanie szeregu wierszy w tabeli. Większość problemów z eksportowaniem to efekt niezgodnych danych, choć czasem przyczyny są inne.
W trakcie procesu eksportowania do listy SharePointa dodawanych jest kilka pól potrzebnych do zarządzania listą. Pola te są dostępne w tabeli połączonej w Accessie, ale nie ma ich w kwerendach, formularzach i raportach opartych na danej tabeli i utworzonych przed jej wyeksportowaniem do SharePointa. Opis tych dodatkowych pól znajdziesz w poniższej tabeli. Możliwe, że wykorzystasz przynajmniej niektóre z tych kolumn, jednak zwykle nie są one przydatne w aplikacjach Accessa. Nazwa pola w SharePoincie
Typ danych
_OldId
Liczba (podwójnej precyzji)
Typ zawartości
Krótki tekst
ID przepływu pracy
Krótki tekst
Typ pliku
Krótki tekst
Utworzony
Data/Godzina
Zmodyfikowane
Data/Godzina
Utworzony przez
Krótki tekst
Zmodyfikowane przez
Krótki tekst
Ścieżka URL
Krótki tekst
Ścieżka
Krótki tekst
Typ elementu
Krótki tekst
Zakodowany URL
Krótki tekst
Rozdział 33. Integrowanie Accessa z SharePointem
1009
Przycisk Dalej zapoczątkowuje proces eksportowania. Może on potrwać wiele minut. Zależy to od liczby tabel z bazy Accessa, ilości danych w każdym rekordzie, a także wydajności sprzętu i oprogramowania na serwerze SharePointa. Możliwe, że zobaczysz prośbę o wprowadzenie nazwy użytkownika i hasła, ponieważ SharePoint musi sprawdzić, czy masz wystarczające uprawnienia do tworzenia obiektów w docelowej witrynie. Warto przypomnieć, że jeśli wykonujesz opisane operacje, używając przykładowej witryny SharePointa www.spsdemo.com, nie będziesz mógł utworzyć w niej nowej listy. Jest to zrozumiałe, ponieważ uprzejme osoby udostępniające tę witrynę nie chcą, aby tworzono w niej setki nieznanych nowych list. Aby dodać listę, musisz uzyskać dostęp do witryny SharePointa, na której będziesz mieć uprawnienia do zapisu.
Nowe listy SharePointa otrzymują nazwę tabeli. Po zakończeniu procesu wszystkie tabele z bazy Accessa znajdą się w SharePoincie i zostaną dołączone do aplikacji Accessa. Zauważ, że ikona obok nazwy każdej tabeli zmieniła się i oznacza, iż tabela jest dołączona (nie jest przechowywana lokalnie). Za przechowywanie tabel i danych oraz zarządzanie nimi odpowiadają teraz usługi SharePointa. W bazie danych Accessa znajdują się tylko logiczne połączenia z witryną SharePointa. Tabele i dane nie są już przechowywane w bazie Accessa. Podobnie jak w innych operacjach eksportowania, można zachować kroki procesu w celu ich późniejszego wykorzystania. Ponadto Access przed rozpoczęciem eksportowania tworzy kopię pliku bazy danych. Pozwala to w razie potrzeby przywrócić wcześniejszy stan bazy.
Korzystanie z szablonów SharePointa W tym rozdziale opisujemy techniki dostępne, gdy baza Accessa już istnieje i użytkownicy potrzebują danych z niej w witrynie SharePointa. Aby wzmocnić powiązania między Accessem i SharePointem, Microsoft udostępnił jeszcze jeden sposób na integrowanie aplikacji Accessa z omawianym środowiskiem. Zamiast eksportować istniejące tabele Accessa do SharePointa lub dołączać listy SharePointa można utworzyć całkowicie nowe listy SharePointa w środowisku Accessa. Access 2013 udostępnia szablony list SharePointa. Obejmują one wszystkie aspekty (nazwy kolumn, typy danych i inne właściwości list) potrzebne do tworzenia list SharePointa. Mechanizm ten ma zapewnić oszczędność czasu użytkownikom, którzy chcą szybko przygotować nowe listy SharePointa. Szablony SharePointa w Accessie 2013 obsługują wiele ważnych funkcji biznesowych. Pozwalają tworzyć listy kontaktów, zadań, problemów lub wydarzeń, co pokazano na rysunku 33.11. Ponadto szablon listy niestandardowej (w dolnej części ekranu) umożliwia dodanie do pustej listy dowolnej kombinacji kolumn zgodnych z SharePointem. Ostatnia pozycja na liście rozwijanej istniejących list SharePointa zapewnia możliwości, które zostały opisane w punkcie „Dołączanie list SharePointa” we wcześniejszej części rozdziału.
1010
Część VIII Access i Windows SharePoint Services
Rysunek 33.11. Lista szablonów SharePointa dostępna w Accessie
Wybranie jednego z szablonów list SharePointa powoduje otwarcie okna dialogowego Tworzenie nowej listy (zobacz rysunek 33.12). Trzeba w nim podać adres URL witryny SharePointa i nazwę nowej listy.
Rysunek 33.12. Okno dialogowe Tworzenie nowej listy w trakcie tworzenia listy SharePointa na podstawie szablonu Accessa
Warto zauważyć, że nie można zmodyfikować szablonu przed utworzeniem go w SharePoincie. Oznacza to, że na liście znajdą się wstępnie zdefiniowane kolumny o konkretnych typach danych odpowiednich dla wykonywanych operacji.
Rozdział 33. Integrowanie Accessa z SharePointem
1011
W trakcie tworzenia nowej listy może się pojawić prośba o podanie danych uwierzytelniających SharePointa. Dodawanie list do witryny SharePointa wymaga uprawnień administratora. Dlatego nawet jeśli możesz dołączać listy, nie oznacza to, że masz uprawnienia do tworzenia nowych list. Nowa lista jest automatycznie dodawana do Accessa jako tabela połączona. Działa ona jak każda inna dołączona lista SharePointa. W przyszłości w Accessie mogą się pojawić inne szablony aplikacji. Mogą to być szablony dla aplikacji do monitorowania procesów, dotyczące projektów i zarządzania nimi, marketingu, kanałów sprzedaży, zarządzania studiami, zarządzania uczniami i studentami w szkołach i na uczelniach itp.
1012
Część VIII Access i Windows SharePoint Services
Rozdział 34.
Wprowadzenie do usług Access Services W tym rozdziale:
Wprowadzenie do aplikacji zarządzanych
Wprowadzenie do funkcji publikowania w sieci Accessa
Usługi Access Services w SharePoincie 2013
Ograniczenia usług internetowych Accessa
Microsoft przez ponad 10 lat promował program SharePoint jako platformę do zespołowego rozwijania aplikacji. W rozdziałach 32. i 33. zostały opisane niektóre możliwości Accessa, które umożliwiają użytkownikom tego programu płynne współużytkowanie danych z użytkownikami SharePointa. Tworząc aplikacje Access 2010 i SharePoint 2010, Microsoft zrobił następny krok w rozwijaniu SharePointa i usług Access Services. Access Services to element SharePointa, który umożliwia uruchamianie aplikacji Accessa bezpośrednio w przeglądarce. Oznacza to, że dzięki SharePointowi programiści Accessa po raz pierwszy w historii zyskali możliwość uruchamiania aplikacji w sieci WWW. W SharePoincie 2013 mechanizmy integracji SharePointa z Accessem zostały usprawnione dzięki nowej architekturze i możliwości zapisywania danych Accessa w tabelach serwera SQL Server. W tym rozdziale poznasz usługi Access Services i dowiesz się, jak przy ich użyciu tworzyć aplikacje Accessa 2013 dostępne w sieci WWW.
Aplikacje zarządzane Access dawno został sprowadzony do roli systemu tworzenia baz danych dla grup roboczych i działów firm. Wprawdzie oferuje znakomity interfejs użytkownika i narzędzia do tworzenia raportów, ale jest oparty na pliku bazy danych, który może zostać uszkodzony lub utracony w wyniku awarii sprzętu albo przypadkowo (lub celowo) skasowany. Dlatego użytkowników w wielu środowiskach trudno było przekonać do Accessa.
1014
Część VIII Access i Windows SharePoint Services
Wymagania SharePointa a Office 365 Aby móc korzystać z usług Access Services, trzeba mieć uprawnienia do publikowania w witrynie SharePointa z działającymi usługami tego rodzaju. Usługi Access Services są dostępne tylko w SharePoincie 2010 i 2013, dlatego upewnij się, czy witryna działa w którejś z tych wersji. Większość osób pracuje w firmach, w których już działa środowisko oparte na SharePoincie 2010 lub 2013. Jeśli jednak nie masz dostępu do takiego środowiska, możesz skorzystać z oferty setek dostawców udostępniających w systemie abonamentowym usługi SharePointa. Wielu z tych dostawców oferuje różne abonamenty dostosowane do potrzeb. Microsoft udostępnia narzędzie Office 365. Jest to oparte na chmurze środowisko Microsoftu, w którym abonenci mogą przez internet korzystać z narzędzi podobnych do tych ze standardowego pakietu Office. W środowisku Office 365 Microsoft udostępnia Worda, Excela i PowerPointa (podobnie jak Google udostępnia narzędzia Google Docs i Google Spreadsheets). Dostępne są też usługi Access Services połączone z SQL Azure (jest to działająca w chmurze wersja serwera SQL Server). Oznacza to, że można wykorzystać pakiet Office 365 do publikowania i hostingu sieciowych aplikacji Accessa. Wykupienie abonamentu u komercyjnego dostawcy SharePointa może się okazać najszybszym i najtańszym sposobem pozwalającym umieścić aplikacje Accessa w SharePoincie. Jedyną uwagą jest to, że dostawca musi oferować SharePointa 2010 lub 2013 z zainstalowanymi usługami Access Services.
Standardowo to dział informatyczny odpowiada za zarządzanie najważniejszymi systemami bazodanowymi firmy. Systemy te (niezależnie od tego, czy oparte na SQL Server, Oracle, DB2 czy innej serwerowej bazie danych) wymagają profesjonalnego zarządzania, w tym starannego projektowania, okresowego tworzenia kopii zapasowych i administrowania uprawnieniami użytkowników i grup. Duże systemy bazodanowe mają zagwarantować dostępność i integralność danych. Dla innych działów firmy i jednostek biznesowych (a nawet dla małych firm) najważniejsza jest elastyczność i dostęp do danych. Czas to pieniądz, dlatego oczekiwanie na to, aż dział informatyczny przygotuje interfejs użytkownika lub nowy raport w środowisku programistycznym, np. w SQL Server Reporting Services, może się okazać kosztowne. Wiele jednostek biznesowych woli korzystać z Accessa, ponieważ umożliwia szybkie przekształcenie wymagań użytkownika w solidne kompletne aplikacje. Problem się pojawia, gdy jednostka biznesowa chce przechowywać krytyczne dane w pliku Accessa na serwerze plików lub, co gorsza, na komputerze lub laptopie użytkownika. Bez właściwego zarządzania łatwo jest utracić dane w wyniku awarii dysku twardego lub kradzieży laptopa. Ponadto brak starannej synchronizacji danych może prowadzić do powstania różnych kopii bazy danych w wielu lokalizacjach. W efekcie nie będzie można ufać raportom Accessa, ponieważ nikt nie będzie wiedział, który z raportów odzwierciedla faktyczne dane. Trzeba dokonać wyboru między drogimi, dużymi, starannie zarządzanymi aplikacjami (takimi jak formularze internetowe oparte na platformie .NET i serwerze SQL Server) a mniejszymi, prostszymi i łatwiejszymi w modyfikowaniu aplikacjami rozwijanymi w Accessie. Nawet jeśli aplikacja Accessa korzysta z danych z bazy SQL Server, zapewnienie dostępu do takich danych przez przeglądarkę internetową jest w najlepszym razie skomplikowane. W większości sytuacji użytkownicy muszą korzystać z danych z bazy
Rozdział 34. Wprowadzenie do usług Access Services
1015
SQL Server w sieci LAN lub polegać na tym, że administratorzy bazy danych SQL Server w razie potrzeby przyznają accessowym frontonom uprawnienia do danych i innych zasobów. Aplikacje zarządzane (np. serwerowe systemy bazodanowe) oferują firmom i organizacjom wiele zalet. Jednak dla tych samych firm i organizacji korzystna jest elastyczność oraz możliwość wprowadzania zmian w aplikacjach niezarządzanych rozwijanych w Accessie.
Publikowanie w internecie za pomocą Accessa W idealnych warunkach użytkownicy powinni mieć szybki i prosty dostęp do danych bez ograniczeń związanych z dużymi systemami bazodanowymi, takimi jak SQL Server. Choć dołączanie tabel bazy SQL Server w aplikacjach Accessa rozwiązuje problemy związane z powstawaniem wielu kopii bazy na różnych komputerach i zapewnia wysoki poziom bezpieczeństwa bazy, użytkownicy często potrzebują pomocy administratorów bazy przy wykonywaniu prostych zadań, takich jak tworzenie procedur składowanych do sortowania i filtrowania danych na różne sposoby. Microsoft udostępnił w Accessie 2013 narzędzia rozwiązujące problem sprzecznych potrzeb użytkowników biznesowych i działów informatycznych. Narzędzia te pozwalają programistom Accessa publikować aplikacje Accessa w witrynach SharePointa. Jeśli poprawnie przygotowana aplikacja Accessa zostanie opublikowana za pomocą SharePointa, użytkownicy natychmiast będą mogli przeglądać i stosować internetowe formularze Accessa w witrynie SharePointa. Usługi Access Services zapewniają korzyści także programistom Accessa. Po pierwsze, nie muszą się oni uczyć języka programowania aplikacji sieciowych. SharePoint i usługi Access Services wykonują wszystkie operacje potrzebne do przekształcenia aplikacji Accessa w witrynę. Po drugie, rozwiązanie trzeba konserwować tylko w jednym miejscu. Ponadto, dzięki możliwości ponownego opublikowania aplikacji Accessa po wprowadzeniu w niej zmian, nie występują problemy z kontrolą wersji. Po ponownym opublikowaniu aplikacji wszyscy użytkownicy uzyskają dostęp do zaktualizowanej wersji, gdy znów otworzą aplikację sieciową. W Accessie 2010 opublikowanie aplikacji sieciowej w SharePoincie prowadziło do powstania list SharePointa z danymi aplikacji. W Accessie 2013 Microsoft usprawnił architekturę, udostępniając tabele SQL-a z danymi aplikacji. Gdy publikujesz w SharePoincie aplikację sieciową opartą na Accessie 2013, tworzone są nowe tabele serwera SQL Server 2012 z jej danymi. Jeśli aplikacja jest udostępniana w środowisku Office 365, używane są nowe tabele SQL Azure. Ta nowa architektura zapewnia większą skalowalność, ponieważ w porównaniu z listami SharePointa tabele SQL-a mogą przechowywać większe, bardziej złożone zbiory danych. Ponadto ponieważ dane z aplikacji Accessa znajdują się już w środowisku SQL Server, programiści SQL-a mogą łatwo korzystać z tych danych i integrować z nimi inne rozwiązania.
1016
Część VIII Access i Windows SharePoint Services
Dane w SharePoincie są bezpieczne, ponieważ użytkownik musi uzyskać uprawnienia do korzystania z tego programu. Po podaniu nazwy i hasła użytkownik może uzyskać dostęp do danych za pomocą dowolnej przeglądarki internetowej. W rozdziale 35. szczegółowo opisujemy ten proces i wyjaśniamy zmiany, jakie trzeba wprowadzić w aplikacji Accessa, aby jej obiekty były zgodne z SharePointem. Użytkownicy korzystający z opublikowanych aplikacji sieciowych Accessa nie muszą instalować Accessa na komputerze. Access jest jednak potrzebny osobom, które chcą wprowadzać zmiany w strukturze bazy danych.
Dlaczego SharePoint? Wielu programistów zastanawia się, dlaczego Microsoft zdecydował się uzależniać tworzenie rozwiązań internetowych w Accessie od usług SharePoint Services. Skoro celem jest stworzenie z Accessa solidnego narzędzia do budowania aplikacji internetowych, czy nie miałoby sensu wbudowanie w niego potrzebnych do tego funkcji, podobnie jak wiele lat temu w środowisku Visual Studio? Gdy w Microsofcie przeanalizowano wszystkie kwestie, okazało się, że dodawanie do Accessa rozbudowanych funkcji tworzenia rozwiązań internetowych jest niepraktyczne. Wiele osób zapomina, że witryna internetowa to nie tylko strony HTML. Uwzględnić trzeba też bezpieczeństwo, wydajność i integralność danych. Na przykład Jet (a także ACE) nie nadaje się do tworzenia internetowych systemów bazodanowych. Za pomocą bazy danych .accdb nie można zapewnić wielodostępności, stabilności i przepustowości niezbędnych w publicznej witrynie internetowej. Obecna architektura się do tego nie nadaje, a jej poprawienie wymagałoby zmodyfikowania silnika ACE pod kątem środowiska internetowego.
Wykorzystanie funkcji SharePointa Microsoft wybrał SharePointa jako platformę do publikowania accessowych rozwiązań internetowych, ponieważ udostępnia on ważne wbudowane funkcje. Oto niektóre z nich:
Bezpieczeństwo — SharePoint obsługuje użytkowników i ich grupy. Użytkownikom i grupom można przyznawać uprawnienia do różnych części witryny SharePointa oraz odmawiać takich uprawnień. Konkretnym użytkownikom można nadać uprawnienia do dodawania, usuwania i modyfikowania witryny.
Kontrola wersji — SharePoint automatycznie przechowuje historię wersji obiektów i danych. Zmiany w niemal dowolnym momencie można anulować i przywrócić wcześniejszy stan. Możliwość anulowania zmian można przyznać poszczególnym użytkownikom. W procesie anulowania nie musi uczestniczyć administrator bazy.
Kosz — usunięte dane i obiekty znajdują się w koszu, dlatego można je przywrócić. Inaczej niż Access, gdzie wszystkie operacje usuwania i modyfikowania są nieodwracalne, SharePoint obsługuje funkcję przywracania danych.
Rozdział 34. Wprowadzenie do usług Access Services
1017
Alerty — można wysyłać do użytkowników i grup wiadomości w reakcji na dodanie, usunięcie lub zmianę określonych danych na liście SharePointa. Jeśli użytkownik ma odpowiednie uprawnienia, może zarządzać własnymi alertami.
Zarządzanie przez użytkowników — witryny SharePointa mają być zarządzane przez ich użytkowników (bez angażowania w to działu informatycznego). Choć strony SharePointa nie są tak elastyczne jak typowe strony WWW, programista SharePointa może dodawać i usuwać funkcje, zmieniać czcionki, nagłówki, kolory i inne cechy, tworzyć podwitryny i listy, a także wykonywać liczne zadania związane z zarządzaniem i usprawnianiem.
Inne funkcje — każda witryna SharePointa obejmuje liczne funkcje, takie jak kalendarz, lista zadań i ogłoszenia. Użytkownicy mogą wyłączyć te funkcje lub je usunąć.
Możliwość zarządzania witrynami SharePointa przez użytkowników jest ważną różnicą między witryną SharePointa a witrynami WWW rozwijanymi za pomocą ASP.NET i podobnych narzędzi. Strony WWW w witrynie zbudowanej za pomocą środowiska .NET są ściśle powiązane ze skompilowanym kodem, który steruje witryną. Użytkownik nie może zmodyfikować strony ASPX, ponieważ znajduje się ona na serwerze WWW. Ponadto kod powiązany ze stroną trzeba (zwykle) ponownie skompilować po wprowadzeniu zmian w jej interfejsie.
Usługi Access Services Z tego rozdziału dowiedziałeś się, że wersja SharePoint Server 2010 była pierwszą, w której pojawiły się serwerowe usługi Access Services potrzebne do hostingu aplikacji Accessa w SharePoincie. Aplikacje Accessa buduje się oczywiście w Accessie. Służą do tego te same narzędzia co we wcześniejszych wersjach. Gdy aplikacja jest publikowana w SharePoincie, usługi Access Services generują strony ASPX potrzebne do wyświetlania aplikacji Accessa w przeglądarce internetowej. Oznacza to, że usługi Access Services odpowiadają za działanie aplikacji Accessa przechowywanych w SharePoincie. Usługi te ponadto kompilują i wykonują kwerendy z sieciowej aplikacji Accessa, a także uruchamiają kwerendy dotyczące list SharePointa z danymi. Usługi Access Services synchronizują też aktualizacje wersji aplikacji Accessa między komputerem programisty a SharePointem. Zagadnienia te opisaliśmy szczegółowo w rozdziale 35.
Prawdopodobnie najważniejszym zadaniem usług Access Services jest zarządzanie relacjami między tabelami eksportowanymi do SharePointa w trakcie publikowania aplikacji Accessa. SharePoint nie jest relacyjny w znaczeniu nadawanym temu określeniu w kontekście baz danych. Usługi Access Services zapewniają logikę potrzebną do złączania danych z list i zachowywania integralności referencyjnej między listami, o ile relacje między tabelami zostaną zdefiniowane przed opublikowaniem aplikacji Accessa w SharePoincie.
1018
Część VIII Access i Windows SharePoint Services
Do aktualizowania schematu aplikacji należy użyć okna projektowego baz danych w Accessie (opisano to w rozdziale 35.), a następnie zsynchronizować zmiany z bazą danych opublikowaną wcześniej w SharePoincie. Usługi Access Services w SharePoincie obsługują też pamięć podręczną danych. Zamiast korzystać z wbudowanej w SharePointa możliwości lokalizowania i udostępniania danych, usługi Access Services zapewniają pamięć podręczną w warstwie pośredniej. Zapisywane są w niej dane, które prawdopodobnie będą potrzebne aplikacji. Dzięki temu dane te są udostępniane znacznie szybciej niż przy użyciu samego SharePointa. Zapisywanie w pamięci podręcznej odbywa się w sposób niezauważalny dla użytkowników i programistów. Nie istnieją nawet opcje konfiguracyjne do ustawiania pamięci podręcznej i modyfikowania jej parametrów. Warstwa Access Services filtruje dane w kwerendzie przed dodaniem ich do pamięci podręcznej. Oznacza to, że kwerendy z klauzulą WHERE działają szybciej i lepiej wykorzystują pamięć podręczną usług Access Services niż kwerendy pobierające wszystkie wiersze tabel. Podobnie jak w aplikacjach bazodanowych, tak i tu należy zaplanować stosowanie predykatów kwerendy (klauzuli WHERE), aby zminimalizować ilość danych przenoszonych między ich repozytorium (tu są nim listy SharePointa) a interfejsem użytkownika.
Ograniczenia aplikacji internetowych Accessa Aplikacje internetowe Accessa nie są najlepszym sposobem tworzenia witryn publicznych. Są przeznaczone raczej dla działów firm i grup roboczych. Pewne ograniczenia sprawiają, że aplikacje internetowe oparte na Accessie i SharePoincie stosuje się tylko w konkretnych sytuacjach. Ograniczenia internetowych aplikacji Accessa wynikają w większym stopniu z działania SharePointa niż z samego Accessa. SharePoint nie umożliwia na przykład anonimowego dostępu do witryn. Użytkownicy muszą logować się do witryny SharePointa, podając poprawną nazwę i hasło (w SharePoincie do identyfikowania użytkowników służą usługi Windows Active Directory). Trudno jest też ograniczyć dostęp użytkowników do wybranych fragmentów aplikacji SharePointa (choć z tym ograniczeniem można sobie poradzić). Gdy użytkownik zostanie uwierzytelniony przez system zabezpieczeń SharePointa, zwykle ma dostęp do list, kalendarzy i innych funkcji witryny. Aby ograniczyć możliwości użytkownika, trzeba ustalić, które funkcje powinny być dostępne dla określonych grup, i ustawić uprawnienia do tych funkcji w witrynie. Większość tradycyjnych aplikacji internetowych udostępnia tylko funkcje określone przez programistę. SharePoint nigdy nie miał być ogólnym narzędziem do tworzenia witryn internetowych. Zaprojektowano i zbudowano go jako platformę do współużytkowania danych i dokumentów w ramach pracy zespołowej. Oznacza to, że strony SharePointa tworzy się na podstawie szablonów, a nie przez swobodne wprowadzanie kodu w HTML-u. Dlatego wszystkie strony SharePointa mają te same elementy interfejsu.
Rozdział 34. Wprowadzenie do usług Access Services
1019
W większości sytuacji podobieństwa między stronami z różnych witryn SharePointa są zaletą, a nie wadą. Gdy użytkownik zaznajomi się z SharePointem i jego stronami, nie będzie potrzebował dodatkowych instrukcji. Dlatego użytkownicy są wydajni szybciej niż przy korzystaniu z aplikacji, w których każda strona jest inna. Standardowe operacje, takie jak dodawanie nowych pozycji do listy lub modyfikowanie istniejących danych, wykonuje się tak samo na każdej stronie SharePointa. Można zmienić kolor, czcionkę i inne aspekty wyglądu strony SharePointa. Jednak podstawowy układ — okienko nawigacji po lewej, wstążka i ścieżka powrotu u góry oraz listy z elementami na prawo od okienka nawigacji — jest identyczny na wszystkich stronach SharePointa. Jeśli jest to konieczne, można utworzyć niestandardowy szablon stron (od podstaw lub w oparciu o istniejący szablon) i wykorzystać go w witrynie SharePointa. Jednak ponieważ większość witryn SharePointa jest używana w intranecie przez specjalną grupę odbiorców, domyślny układ strony zwykle dobrze się sprawdza.
Limity w usługach Access Services W usługach Access Services (podobnie jak w innych technologiach Microsoftu) obowiązują pewne ograniczenia. Opisujemy je w tabeli 34.1. Warto je poznać przed zdecydowaniem się na publikowanie aplikacji Accessa w SharePoincie. Zwróć uwagę na wartości domyślne limitów. Są to standardowe wartości obowiązujące, gdy usługi Access Services są instalowane na serwerze SharePointa. Aby ustawić wartości maksymalne, administrator SharePointa musi bezpośrednio skonfigurować każdy atrybut i zmienić jego wartość na maksymalną. Po zapoznaniu się z tymi limitami powinno być oczywiste, że nie wszystkie aplikacje Accessa nadają się do udostępniania jako aplikacje sieciowe. W przeszłości Microsoft zasugerował, że aplikacje przechowujące ponad 40 000 wierszy w jednej tabeli nie są odpowiednie do umieszczania w SharePoincie. Jest to jednak ogólna sugestia, która pomaga uniknąć problemów z wydajnością po opublikowaniu aplikacji w sieci. Wydajność aplikacji sieciowych Accessa zależy od wielu czynników: liczby rekordów, liczby tabel, złożoności kwerend, liczby żądań danych kierowanych do serwera itd. Zależy to od sytuacji. Jeśli dana aplikacja Accessa przekracza jeden z limitów przedstawionych w tabeli 34.1, warto rozważyć bardziej standardowy sposób rozwijania aplikacji. Można na przykład zastosować narzędzia ASP.NET i SQL Server. Te platformy programowania są przeznaczone do tworzenia dużych i wydajnych witryn opartych na danych.
Limity w zakresie transakcji Aplikacje internetowe Accessa udostępniane w SharePoincie nie są dobrym rozwiązaniem w środowiskach, w których setki użytkowników nieustannie dodają lub aktualizują dane. Choć SharePoint korzysta z baz SQL Server, aktualizacje bazy danych są znacznie wolniejsze niż przy bezpośrednim używaniu tabel bazy SQL Server za pomocą połączonych tabel Accessa lub procedur składowanych.
1020
Część VIII Access i Windows SharePoint Services
Tabela 34.1. Limity w usługach Access Services Typ kwerendy lub pola
Uwagi Maksymalna liczba rekordów, które można zapisać w tabeli w aplikacji
Maksymalna liczba rekordów na tabelę
Maksymalnie: bez limitu Domyślnie: 500 000
Maksymalna liczba kolumn na kwerendę
Maksymalna liczba kolumn, które można podać w kwerendzie (warto zauważyć, że niektóre kolumny są automatycznie dodawane przez silnik kwerend — są one uwzględniane przy kontrolowaniu limitu) Maksymalnie: 255 Domyślnie — 40 Maksymalna liczba wierszy w danych wyjściowych kwerendy
Maksymalna liczba wierszy na kwerendę
Maksymalnie: 200 000 Domyślnie: 25 000 Maksymalna liczba list, które można wykorzystać jako dane wyjściowe w kwerendzie
Maksymalna liczba źródeł na kwerendę
Maksymalnie: 20 Domyślnie: 12
Maksymalna liczba kolumn obliczeniowych na kwerendę
Maksymalna liczba kolumn obliczeniowych w kwerendzie (i w samej kwerendzie, i w używanych podkwerendach) Maksymalnie: 32 Domyślnie: 10
Maksymalna liczba pól w klauzuli ORDER BY kwerendy
Maksymalna liczba pól w klauzuli ORDER BY w kwerendzie Maksymalnie: 8 Domyślnie: 4
Maksymalny czas obsługi żądania (limit czasu oczekiwania)
Maksymalny czas (w sekundach) oczekiwania na obsługę żądania przez aplikację Maksymalnie: bez limitu Domyślnie: 30 Maksymalna liczba prywatnej pamięci (w megabajtach) przydzielonej dla procesu Access Database Services
Wykorzystanie pamięci
Maksymalnie: 50% fizycznej pamięci na komputerze klienta Domyślnie: 50% fizycznej pamięci na komputerze klienta
Rozdział 34. Wprowadzenie do usług Access Services
1021
Oznacza to, że aplikacji Accessa nie należy udostępniać w SharePoincie, jeśli wymagają jednoczesnego wprowadzania dużych ilości danych. W SharePoincie najlepiej jest udostępniać aplikacje Accessa, w których częstotliwość aktualizowania danych i tworzenia raportów jest umiarkowana.
1022
Część VIII Access i Windows SharePoint Services
Rozdział 35.
Instalowanie aplikacji Accessa w SharePoincie W tym rozdziale:
Tworzenie początkowego modelu danych
Inicjowanie aplikacji sieciowej
Edytowanie tabel i widoków domyślnych
Tworzenie reguł sprawdzania poprawności i zdarzeń
Tworzenie własnych widoków
Zarządzanie aplikacjami sieciowymi
W Accessie 2013 pojawiły się nowe ważne funkcje dla programistów rozwijających aplikacje współużytkowane przez wiele osób. Microsoft przede wszystkim wykorzystał mechanizmy platformy SharePoint i usług Access Services do zwiększenia zasięgu aplikacji Accessa 2013 w sieci. Dobra wiadomość dla programistów Accessa jest taka, że stosowanie omawianych technik nie wymaga zaawansowanej wiedzy z zakresu SharePointa. Wystarczy adres URL do serwera SharePointa i odpowiednie uprawnienia do tworzenia witryn SharePointa na tym serwerze. Wszystkie prace programistyczne wykonywane są w Accessie 2013, a za pozostałe zadania odpowiadają SharePoint i usługi Access Services. Aby wypróbować techniki współużytkowania danych opisane w tym rozdziale, będziesz potrzebować dostępu do serwera SharePointa. Jeśli chcesz używać SharePointa, skontaktuj się z działem IT i zapytaj o dostęp do witryny SharePointa. Jeżeli nie masz dostępu do istniejącego środowiska SharePointa, możesz skorzystać z oferowanego przez Microsoft środowiska Office 365. Jest to oparte na chmurze środowisko Microsoftu, w którym abonenci mogą korzystać przez sieć z narzędzi do pracy zespołowej (przypominają one aplikacje pakietu Microsoft Office). W środowisku Office 365 Microsoft oferuje Worda, Excela i PowerPointa (przypominają one narzędzia Google Docs i Google Spreadsheets). Dostępne są też usługi Access Services połączone z narzędziem SQL Azure (jest to oparta na chmurze wersja serwera SQL Server). Oznacza to, że środowisko Office 365 umożliwia publikowanie i hosting sieciowych aplikacji Accessa.
1024
Część VIII Access i Windows SharePoint Services
Publikowanie niestandardowej aplikacji Accessa w SharePoincie W opisanym przykładzie w SharePoincie opublikowana zostanie cała aplikacja Accessa 2013. Aplikacja Accessa umieszczona zostanie w usługach Access Services działających w SharePoincie. Użytkownicy mogą korzystać z aplikacji Accessa z poziomu SharePointa. Tabele, kwerendy i powiązane elementy są ukryte przed użytkownikami i obsługiwane przez usługi Access Services SharePointa. Wszystkie formularze mają postać stron internetowych. Każdy użytkownik z odpowiednimi uprawnieniami SharePointa może uzyskać dostęp do aplikacji za pomocą przeglądarki internetowej. Na komputerze użytkownika nie trzeba instalować środowiska uruchomieniowego Accessa. Proces publikowania w SharePoincie różni się od technik przenoszenia aplikacji stosowanych w starszych wersjach Accessa i trzeba przyznać, że wymaga przyzwyczajenia się.
Przygotowywanie modelu danych Accessa W tym punkcie utworzysz aplikację sieciową do wprowadzania danych potencjalnych klientów. Za pomocą tej aplikacji przedstawiciele handlowi będą mogli wpisać dane potencjalnego nabywcy za pomocą strony internetowej opartej na SharePoincie. Ponadto menedżerowie będą mogli uruchamiać raporty z danymi z nowej aplikacji sieciowej. Przy tworzeniu aplikacji sieciowej Accessa trzeba zacząć od podstawowego modelu danych Accessa. Ponieważ usługi Access Services nie obsługują złożonej logiki ani procedur VBA, początkowy model danych musi być stosunkowo prosty. SharePoint i usługi Access Services nie akceptują aplikacji Accessa z kodem VBA, ponieważ formularzy Accessa i kodu VBA nie można przekształcić na używany w SharePoincie kod w JavaScripcie. Ponadto zaawansowane mechanizmy (np. formanty ActiveX) nie zawsze mają odpowiedniki w platformie .NET, dlatego usługi Access Services nie potrafią utworzyć właściwych zastępników. Doświadczeni programiści Accessa mogą się poczuć rozczarowani, jednak w dalszej części rozdziału przekonasz się, że dużą część potrzebnej logiki z kodu VBA można zastąpić regułami sprawdzania poprawności i makrami danych.
Punktem wyjścia jest zbiór podstawowych tabel (zobacz rysunek 35.1). Tabele te znajdują się w standardowej bazie .accdb. Rysunek 35.1. Zacznij od zbioru podstawowych tabel
Wyjściowa baza danych do omawianych ćwiczeń, SalesApplication.accdb, jest dostępna razem z przykładowymi plikami dla tej książki.
Rozdział 35. Instalowanie aplikacji Accessa w SharePoincie
1025
Należy utworzyć relacje między tabelami. Użyj do tego narzędzia Relacje z zakładki NARZĘDZIA BAZY DANYCH. Relacje gwarantują, że usługi Access Services będą poprawnie obsługiwały interakcje między tabelami modelu. Rysunek 35.2 przedstawia ekran Relacje dla wyjściowego modelu danych. Rysunek 35.2. Pamiętaj, aby utworzyć relacje między tabelami modelu danych
Chcesz przypomnieć sobie informacje na temat relacji między tabelami? Wróć do rozdziału 4. tej książki.
Zauważ, że każda tabela z rysunku 35.2 ma klucz główny. Ważne jest to, że usługi Access Services nie obsługują relacji wiele do wielu, dlatego trzeba się upewnić, czy każda tabela w wyjściowym modelu danych ma jednopolowy klucz główny, który pełni funkcję unikatowego identyfikatora wierszy tabeli. Najlepiej jest utworzyć w każdej tabeli pole typu Autonumerowanie, które posłuży za klucz główny. W tym celu otwórz każdą tabelę w widoku projektu i dodaj pole o nazwie ID (zobacz rysunek 35.3). Następnie ustaw typ danych tego pola na Autonumerowanie i zastosuj to pole jako klucz główny. Rysunek 35.3. Dla każdej tabeli utwórz pole typu Autonumerowanie i ustaw je jako klucz główny
Projektowanie i konfigurowanie tabel omówiliśmy szczegółowo w rozdziale 3.
Następnym krokiem w procesie przygotowywania modelu danych jest dodanie pola odnośnika, które ma ułatwiać użytkownikom wprowadzanie danych. Rysunek 35.4 przedstawia pole odnośnika w tabeli Opportunities. Umożliwia ono użytkownikom wybranie pozycji z listy firm w czasie wprowadzania nowego rekordu. Dzięki temu użytkownicy nie muszą zapamiętywać nazw firm. Pozwala to przyspieszyć pracę i uniknąć błędów przy wprowadzaniu danych.
1026
Część VIII Access i Windows SharePoint Services
Rysunek 35.4. Tam, gdzie to możliwe, dodaj pola odnośnika, aby usprawnić wprowadzanie danych
Dokładne omówienie pól wyszukiwania znajdziesz w rozdziale 3. W ramach przypomnienia przyjrzyj się rysunkowi 35.5. Pole odnośnika można ustawić w widoku projektowania tabeli. Tu ustawiono odnośnik dla pola Customer. Jest on powiązany z polami ID, Company i ContactName z tabeli Customers. Powoduje to wyświetlanie użytkownikom interaktywnej listy rozwijanej, co pozwala ławo wybrać i zaznaczyć dane odpowiedniej firmy. Rysunek 35.5. W widoku projektowania tabeli można ustawiać pola odnośnika
Po wykonaniu tych wstępnych kroków można utworzyć niestandardową aplikację sieciową. Zauważ, że w początkowym modelu danych nie ma żadnych kwerend ani formularzy. Model ten obejmuje tylko podstawowe tabele z prostą logiką. Aplikacje sieciowe Accessa 2013 początkowo nie mogą zawierać żadnych innych danych. Jednak w dalszych punktach zobaczysz, że do utworzonej aplikacji sieciowej można dodawać kwerendy, zaawansowaną logikę i inne elementy.
Inicjowanie i konfigurowanie niestandardowej aplikacji sieciowej Gdy początkowy model danych jest już gotowy, można przystąpić do tworzenia niestandardowej aplikacji sieciowej. 1. Otwórz Accessa 2013 za pomocą przycisku Start systemu Windows (Start/ Programy/Access 2013). Pojawi się domyślny ekran powitalny widoczny na rysunku 35.6. 2. Kliknij przycisk Niestandardowa aplikacja sieci Web. Pojawi się okno dialogowe Niestandardowa aplikacja sieci Web.
Rozdział 35. Instalowanie aplikacji Accessa w SharePoincie
1027
Rysunek 35.6. Uruchom Accessa 2013 za pomocą przycisku Start systemu Windows, a następnie kliknij przycisk Niestandardowa aplikacja sieci Web
3. Podaj nazwę aplikacji i adres URL docelowej witryny SharePointa (zobacz rysunek 35.7), a następnie kliknij przycisk Utwórz. Rysunek 35.7. Wpisz nazwę aplikacji i adres URL docelowej witryny SharePointa
4. Gdy pojawi się żądanie, podaj nazwę użytkownika i hasło. Access zapisze te informacje na przyszłość i nie będzie żądał ponownego ich wprowadzenia (chyba że się zmienią). Po chwili pracy SharePoint utworzy pustą aplikację sieciową w witrynie SharePointa. W Accessie zobaczysz nową sieciową bazę danych podobną do tej z rysunku 35.8. 5. Następnie należy poinformować Accessa, które tabele mają znaleźć się w aplikacji sieciowej. Przyjrzyj się przez chwilę dolnej części rysunku 35.8. Zauważ, że można pobrać tabele z różnych źródeł danych: Accessa, Excela, serwera SQL Server, innych połączeń ODBC, plików tekstowych, a nawet list SharePointa. Zapewnia to dużą swobodę, ponieważ w aplikacji sieciowej można wykorzystać niemal dowolne źródło danych. Tu wykorzystaj prosty model danych z pliku SalesApplication.accdb. 6. Kliknij ikonę Accessa widoczną w dolnej części rysunku 35.8.
1028
Część VIII Access i Windows SharePoint Services
Rysunek 35.8. Kliknij ikonę Accessa, aby pobrać dane z modelu z pliku SalesApplication.accdb
7. Wybierz bazę, która ma być źródłem danych. Pojawi się okno dialogowe importowania obiektów (zobacz rysunek 35.9). Rysunek 35.9. Zaznacz wszystkie tabele, które chcesz umieścić w aplikacji sieciowej
8. Wybierz tabele, które mają znaleźć się w aplikacji sieciowej (tu wybierz opcję Select All i kliknij przycisk OK. Przeglądanie i edytowanie widoków tabel Gdy wybierzesz tabele źródłowe, Access zaimportuje je do aplikacji sieciowej. Na tym etapie ekran wygląda podobnie jak na rysunku 35.10. Po lewej stronie ekranu znajdują się nazwy tabel, a w środkowej części widoczny jest zbiór widoków. Kliknięcie przycisku Navigation Pane na wstążce pozwala wyświetlić znane okienko nawigacji używane w standardowych bazach danych Accessa.
Rozdział 35. Instalowanie aplikacji Accessa w SharePoincie
1029
Szablony tabel W tym ćwiczeniu utworzyłeś niestandardowy model danych, obejmujący tabele potrzebne w aplikacji sprzedażowej. Tabele te posłużyły następnie jako źródło danych aplikacji sieciowej. Jeśli jednak nie chcesz wykonywać tych zadań, możesz wykorzystać zbiór wbudowanych szablonów tabel Microsoftu. Zauważ, że na rysunku 35.8 widoczne jest pole wyszukiwania, które umożliwia szukanie szablonów tabel z witryny Microsoftu. Gdy w tym polu wpiszesz szukane wyrażenie, pojawi się lista gotowych szablonów tabel, które można zastosować zamiast niestandardowego modelu danych. Gdy wprowadzisz wyrażenie „project tracking”, pojawi się lista tabel związanych ze śledzeniem prac nad projektem. Zaznaczenie jednej z tabel powoduje dodanie jej wraz z innymi tabelami związanymi ze śledzeniem prac nad projektem. Metoda ta pozwala przyspieszyć pracę i utworzyć aplikację sieciową bez konieczności budowania własnego modelu danych. Po dodaniu szablonów tabel można łatwo dostosować je do swoich potrzeb. Rysunek 35.10. Access importuje wszystkie zaznaczone tabele i dla każdej tabeli tworzy dwa domyślne widoki
Z każdą tabelą powiązane są dwa domyślne widoki: widok listy i widok arkusza danych. Widok listy umożliwia przeglądanie i edytowanie pól tabeli w formularzu (zobacz rysunek 35.11). To nie pomyłka — Access automatycznie tworzy formularz dla każdej tabeli. Projekt i układ takich automatycznie generowanych formularzy są zaskakująco dobre. W razie potrzeby formularz można zmodyfikować. Rysunek 35.11. Access automatycznie tworzy dla każdej tabeli formularz wyświetlany w widoku listy
Po otwarciu tabeli w widoku arkusza danych można przeglądać i edytować wszystkie pola w tym widoku. Można też zmodyfikować widok, aby dodać lub usunąć pola.
1030
Część VIII Access i Windows SharePoint Services
Niektóre tabele w modelu danych pełnią funkcje pomocnicze i nie powinny być publicznie wyświetlane. Na rysunku 35.12 taką tabelą jest tabela Categories. Tu jest ona ukrywana. W tym celu należy wybrać tę tabelę i kliknąć ikonę koła zębatego, aby wyświetlić polecenie Hide. Jego kliknięcie daje pewność, że użytkownicy nie będą mogli wyświetlać ani edytować tabeli. Rysunek 35.12. Można ukryć tabele, jeśli nie chcesz, aby użytkownicy mogli je wyświetlać lub edytować
Gdy ukryjesz tabelę, będzie miała wyróżnione obramowanie i jaśniejszy, wyblakły kolor. Pozwala to stwierdzić, że tabela jest ukryta. Dodawanie reguł sprawdzania poprawności dla tabeli Na tym etapie można dodać reguły i logikę sprawiające, że aplikacja będzie czymś więcej niż zestawem kilku prostych tabel. W tym celu trzeba zmodyfikować każdą tabelę. Zaznacz docelową tabelę i kliknij ikonę koła zębatego, aby otworzyć opcję Edit table (zobacz rysunek 35.13). Rysunek 35.13. Otwórz tabelę Customers do edycji
Rysunek 35.14 przedstawia tabelę Customers w widoku projektu. Gdy użytkownik wprowadza dane nowego klienta w formularzu, należy się upewnić, że rekord nie zostanie zapisany, jeśli w polach Company i ContactName nie wpisano wartości. Rysunek 35.14. Dodaj nową regułę sprawdzania poprawności dla tabeli Customers
Rozdział 35. Instalowanie aplikacji Accessa w SharePoincie
1031
Aby w Accessie dodać reguły sprawdzania poprawności do tabel, należy kliknąć polecenie Sprawdzanie poprawności na wstążce. Pojawi się wtedy okno dialogowe Konstruktor wyrażeń (zobacz rysunek 35.15). Można w nim wprowadzić dowolne wyrażenie. Tu aplikacja ma sprawdzać, czy pola Company i ContactName nie są puste. Posłuży do tego następujące wyrażenie: Coalesce([Company], [ContactName]) IS NOT NULL
Rysunek 35.15. Wprowadź odpowiednią regułę sprawdzania poprawności w formie wyrażenia. To wyrażenie gwarantuje, że pola Company i ContactName nie pozostaną puste
Coalesce to funkcja SQL-a, która zwraca pierwsze różne od Null wyrażenie spośród podanych argumentów. Tu funkcja ta służy do upewniania się, że pola ContactName i Company nie są puste.
Po wpisaniu poprawnego wyrażenia można kliknąć polecenie Validation Massage (zobacz rysunek 35.16), aby wprowadzić komunikat wyświetlany użytkownikom. Rysunek 35.16. Kliknij polecenie Validation Massage
W oknie dialogowym Enter validation massage (zobacz rysunek 35.17) wpisz komunikat, który użytkownicy zobaczą, jeśli naruszą jedną z nowych reguł sprawdzania poprawności. Rysunek 35.17. Wpisz komunikat pojawiający się w odpowiedzi na naruszenie reguł sprawdzania poprawności
1032
Część VIII Access i Windows SharePoint Services
Dodawanie zdarzeń do tabeli Czasem aplikacja sieciowa powinna zgłaszać zdarzenie w reakcji na wstawienie, zaktualizowanie lub usunięcie rekordu. Wcześniej wspomnieliśmy już, że usługi Access Services nie potrafią przekształcać kodu VBA na kod w JavaScripcie, nie można więc zastosować języka VBA. Dlatego aby dodać zdarzenia, trzeba posłużyć się makrami danych. Tworzenie i konfigurowanie makr danych omówiliśmy w rozdziale 36. tej książki.
Aby zobaczyć, jak korzystać ze zdarzeń, dodaj zdarzenie do tabeli Opportunities. W tworzonej tu niestandardowej aplikacji sieciowej znajduje się tabela, w której użytkownicy mogą zapisywać dane potencjalnych klientów. Przy wprowadzaniu danych użytkownik musi oszacować potencjalną wysokość zakupów i prawdopodobieństwo ich dokonania. Jeśli w którymś z pól na te informacje znajdą się dane niezgodne z wymogami aplikacji, należy zgłosić zdarzenie. Najpierw zaznacz tabelę Opportunities i kliknij ikonę koła zębatego, aby wyświetlić opcję Edit table. Po kliknięciu tej opcji zobaczysz tabelę Opportunities w widoku projektu (zobacz rysunek 35.18). Tu kliknij polecenie On Insert z grupy Design. Rysunek 35.18. Grupa Design w widoku projektu umożliwia dodanie makr danych uruchamianych przy zdarzeniach Przy wstawianiu, Przy aktualizacji i Przy usunięciu
Access otworzy okno Makra, w którym można określić działanie makra danych. Jak widać na rysunku 35.19, makro ma wyświetlać komunikat o błędzie, jeśli pole Est Revenue ma wartość mniejszą niż 0 lub gdy pole Probability ma wartość spoza przedziału 0 – 1. Rysunek 35.19. Za pomocą okna Makra można dodać logikę obsługi zdarzenia
Rozdział 35. Instalowanie aplikacji Accessa w SharePoincie
1033
Tworzenie własnych kwerend i widoków Jak wcześniej wspomnieliśmy, Access początkowo tworzy dwa domyślne widoki (listy i arkusza danych) dla każdej tabeli z aplikacji sieciowej. Można wzbogacić aplikację, dodając własne widoki oparte na niestandardowych kwerendach. Najpierw otwórz listę rozwijaną Advanced i wybierz opcję Query (zobacz rysunek 35.20). Rysunek 35.20. Otwórz listę rozwijaną Zaawansowane (Advanced) i wybierz opcję Kwerenda (Query)
Na rysunku 35.20 widać, że można utworzyć własny widok listy lub arkusza danych, a nawet pusty widok. Gdy wybierzesz jedną z tych opcji, Access wyświetli listę pól, które można dodać do nowego widoku. Wystarczy wybrać potrzebne pola i rozpocząć tworzenie widoku.
Gdy wybierzesz opcję Query z listy rozwijanej Advanced, Access otworzy znane okno konstruktora wyrażeń. Na rysunku 35.21 pokazano, że tworzenie kwerend w aplikacjach sieciowych przypomina budowanie kwerend w standardowych bazach Accessa. Tu kwerenda tworzy podsumowanie dotyczące potencjalnych klientów zgłoszonych przez poszczególnych przedstawicieli handlowych. Rysunek 35.21. Utwórz kwerendę w taki sam sposób jak w standardowej bazie danych Accessa
Po zapisaniu kwerendy (tu przypisano jej nazwę SalesSummary) Access wyświetli wyniki jej uruchomienia (zobacz rysunek 35.22). Teraz na podstawie kwerendy można utworzyć nowy widok. Wybierz dowolną tabelę używaną w kwerendzie, a następnie kliknij ikonę ze znakiem plus. Pojawi się okno dialogowe widoczne na rysunku 35.23. Podaj w nim nazwę nowego widoku i jego typ (lista lub arkusz danych), a następnie wybierz utworzoną wcześniej kwerendę jako źródło danych.
1034
Część VIII Access i Windows SharePoint Services
Rysunek 35.22. Zapisz kwerendę pod wybraną nazwą i wyświetl wyniki
Rysunek 35.23. Zacznij tworzenie nowego widoku od kliknięcia ikony ze znakiem plus, a następnie wpisz potrzebne właściwości
Gdy klikniesz przycisk Add New View, widok będzie dostępny obok widoków domyślnych (zobacz rysunek 35.24). Rysunek 35.24. Nowe widoki są dostępne obok widoków domyślnych
Ostatnie uwagi na temat konfigurowania aplikacji sieciowych W tym punkcie pokrótce opisaliśmy różne sposoby konfigurowania aplikacji sieciowych. Oczywiście prosty scenariusz omówiony w tym miejscu ma pozwolić na przegląd narzędzi Accessa przeznaczonych do konfigurowania aplikacji. Nie trzeba wyjaśniać, że przedstawione proste elementy można wzbogacić, aby tworzyć dowolnie złożone aplikacje sieciowe. Najważniejszą kwestią, jaką należy zapamiętać, jest to, że konfigurowanie aplikacji sieciowych Accessa 2013 odbywa się już po ich utworzeniu. Wielu programistów Accessa myśli, że może wziąć istniejącą bazę danych i po prostu udostępnić ją w sieci. Niestety, Access 2013 nie działa w ten sposób. Aplikacja sieciowa początkowo jest tylko zbiorem tabel powiązanych prostymi relacjami. Całą logikę, reguły i zdarzenia trzeba utworzyć w środowisku aplikacji sieciowej.
Uruchamianie aplikacji sieciowej i zarządzanie nią Po zakończeniu konfigurowania aplikacji sieciowej można kliknąć polecenie Launch App (zobacz rysunek 35.25). W razie potrzeby wpisz nazwę użytkownika i hasło.
Rozdział 35. Instalowanie aplikacji Accessa w SharePoincie
1035
Rysunek 35.25. Uruchamianie aplikacji sieciowej
Aplikacja sieciowa widoczna jest na ekranie SharePointa. Dostępne są dla niej wbudowane mechanizmy — wygodna nawigacja i opcje filtrowania (zobacz rysunek 35.26). Rysunek 35.26. Aplikacja sieciowa jest wyświetlana w portalu SharePointa
SharePoint i usługi Access Services dobrze radzą sobie z zapewnianiem profesjonalnego wyglądu aplikacji sieciowych. Na przykład na rysunku 35.27 widać, że dla każdego pola daty dostępny jest atrakcyjny wizualnie kalendarz, który pozwala wybrać datę. Rysunek 35.27. SharePoint i usługi Access Services automatycznie uatrakcyjniają aplikację sieciową
Dodane zdarzenia są kompilowane i stają się częścią aplikacji. W przykładowej aplikacji dodano zdarzenie, które zgłasza błąd, jeśli wartość w polu Est Revenue jest mniejsza od zera. Na rysunku 35.28 widać, że w reakcji na to zdarzenie aplikacja wyświetla eleganckie okno komunikatu. Ponieważ w tworzonej aplikacji znalazły się poprawne relacje między tabelami, usługi Access Services automatycznie dodały hierarchiczne widoki przydatne dla użytkowników. Na rysunku 35.29 w tabeli Customers zaznaczona jest firma DataPig Technologies, a w tabeli Opportunities wyświetla się lista potencjalnych transakcji z tą organizacją.
1036
Część VIII Access i Windows SharePoint Services
Rysunek 35.28. Zdarzenia wbudowane w aplikację sieciową są zgłaszane zgodnie z planem
Rysunek 35.29. Na podstawie relacji między tabelami automatycznie generowane są przydatne widoki hierarchiczne
Dostępny jest też niestandardowy widok. Automatycznie pojawiają się w nim wszelkie nowe dane (zobacz rysunek 35.30). Rysunek 35.30. Niestandardowe widoki są dynamicznie aktualizowane na podstawie danych z aplikacji sieciowej
Użytkownicy mogą w portalu SharePointa kliknąć dowolny widok arkusza danych prawym przyciskiem myszy i wyeksportować tabelę do lokalnego arkusza Excela (zobacz rysunek 35.31). Rysunek 35.31. Aby wyeksportować dane do Excela, wystarczy kliknąć widok arkusza danych prawym przyciskiem myszy
Rozdział 35. Instalowanie aplikacji Accessa w SharePoincie
1037
Jeśli chcesz wprowadzić zmiany w aplikacji sieciowej, kliknij ikonę koła zębatego widoczną w prawym górnym rogu aplikacji. Następnie wybierz opcję Customize in Access pokazaną na rysunku 35.32. Prowadzi to do pobrania pliku bazy danych .accdw, który można otworzyć i zmodyfikować w Accessie 2013. Warto zauważyć, że nie wszyscy użytkownicy mają dostęp do ikony koła zębatego. Jest ona dostępna tylko dla użytkowników z uprawnieniami do publikacji (są one przyznawane przez administratora SharePointa). Rysunek 35.32. Aby wprowadzić zmiany w aplikacji sieciowej, wybierz opcję Dostosuj w Accesie
Po wprowadzeniu potrzebnych zmian wystarczy ponownie uruchomić aplikację. Spowoduje to płynne pojawienie się u użytkowników zmian wprowadzonych w bazie w formacie .accdw. Przeglądać aplikacje sieciowe i zarządzać nimi można w SharePoincie. Gdy klikniesz ikonę wielokropka obok nazwy aplikacji, pojawi się okno dialogowe widoczne na rysunku 35.33. Pozwala ono wyświetlać dzienniki użycia, zarządzać uprawnieniami do aplikacji i usuwać aplikacje. Rysunek 35.33. SharePoint umożliwia administratorom i wydawcom przeglądanie aplikacji z witryny, wyświetlanie dzienników, zarządzanie uprawnieniami oraz usuwanie aplikacji
1038
Część VIII Access i Windows SharePoint Services
Rozdział 36.
Makra danych W tym rozdziale:
Tworzenie makr danych
Zdarzenia tabel
Tworzenie makr danych
Ograniczenia związane z makrami danych
Od wersji 2007 makra odgrywają istotną rolę w wielu aplikacjach Accessa. Przez bardzo długi czas makra uważano za mechanizm znacznie uboższy od instrukcji VBA. Choć pod wieloma względami język VBA i makra oferowały podobne możliwości, od zawsze uważano, że makra gorzej się nadają do tworzenia logiki aplikacji. Z tradycyjnymi makrami Accessa związane były poważne problemy:
Makra istniały jako odrębne obiekty bazy danych, dlatego śledzenie makr działających dla danego formularza było często trudne. Z uwagi na brak bezpośrednich powiązań między formularzami (i raportami) a makrami łatwo było zepsuć makro w wyniku zmiany nazwy formularza. Z kodem VBA umieszczonym w module z kodem formularza nigdy nie było takich problemów.
Nie istniał sposób na przechwytywanie ani obsługiwanie błędów w makrach. W wersjach Accessa starszych niż 2007 makra kończyły pracę i wyświetlały komunikat o błędzie, gdy natrafiły na nieoczekiwane warunki. Takie zakłócenia nie były mile widziane przez użytkowników — zwłaszcza z uwagi na to, że użytkownik przeważnie nie mógł nic zrobić, aby naprawić problem lub mu zapobiec. W kodzie VBA zawsze dostępna była solidna obsługa błędów. Często pozwalała ona użyć wartości domyślnej lub poinformować użytkownika, co powinien zrobić.
Makra nie współdziałały z kodem. Nie istniał na przykład sposób na to, aby w makro przejść w pętli po zbiorze rekordów i zsumować wartości pól lub wykryć dane spoza oczekiwanego zakresu. Kod VBA dobrze nadawał się do zarządzania danymi i obejmował wszystkie pętle niezbędne do iteracyjnego przechodzenia po zbiorach rekordów.
1040
Część VIII Access i Windows SharePoint Services
W Accessie 2013 te problemy są już przeszłością. Dodano obsługę błędów i umożliwiono stosowanie zmiennych tymczasowych w trakcie wykonywania makr. W Accessie 2013 dostępne są też makra osadzone. W rozdziale 22. wyjaśniamy, że makra osadzone eliminują problemy związane z tym, iż makra są niezależne od formularzy i raportów, w których działają. W tym samym rozdziale opisujemy, że makra w Accessie 2013 umożliwiają stosowanie pętli i obsługę błędów. Ten rozdział dotyczy makr danych, które są kolejnym aspektem sprawiającym, że makra w Accessie 2013 są bardziej atrakcyjnym rozwiązaniem niż kiedykolwiek wcześniej. Początkową bazę danych do tego rozdziału, Rozdział36.accdb, możesz pobrać z witryny poświęconej tej książce. Jeśli jeszcze tego nie zrobiłeś, zapoznaj się z rozdziałem 22. Znajdziesz tam podstawy, które pomogą Ci zrozumieć pojęcia i mechanizmy opisane w tym miejscu.
Wprowadzenie do makr danych Makro danych to kod dołączony do tabeli w celu wymuszania reguł biznesowych na poziomie tabeli. Pod niektórymi względami makra danych przypominają reguły sprawdzania poprawności, przy czym reguły nie są inteligentne. Reguły sprawdzania poprawności nie umożliwiają modyfikowania danych ani ustalania, czy potrzebne są operacje naprawcze. Makra danych udostępniono, aby umożliwić wykonywanie na poziomie tabeli operacji związanych z danymi. Makra danych zazwyczaj służą do wymuszania reguł biznesowych (takich jak „wartość nie może być mniejsza niż wartość progowa”) lub przekształcania danych w trakcie ich wprowadzania. Bardzo cenną ich cechą jest to, że działają zawsze wtedy, gdy dane z tabeli są używane — nawet w aplikacjach sieciowych uruchamianych w SharePoincie. Makra danych działają zarówno w aplikacjach biurkowych, jak i w sieciowych. Ponieważ makra danych działają w środowisku SharePointa, są przydatne zwłaszcza w aplikacjach sieciowych Accessa. Jeśli makro danych dołączyć do tabeli z transakcjami, zadziała za każdym razem, gdy dane dotyczące transakcji pojawią się w formularzu sieciowym. Makro wykrywa zmiany w danych i automatycznie kontroluje, co się dzieje z informacjami z tabeli. Makra danych mają ułatwiać gwarantowanie spójnej obsługi danych w aplikacji (nawet jeśli działa ona w sieci). Ponieważ makra tego rodzaju działają na poziomie tabel, każda aktualizacja tabeli prowadzi do wykonania identycznych operacji. Choć zbiór akcji dostępnych w makrach danych jest znacznie mniejszy niż w makrach interfejsu, starannie opracowane i napisane makra danych są cennym dodatkiem do aplikacji Accessa. Makra danych są wyjątkowo przydatne w podzielonych aplikacjach bazodanowych (w takich aplikacjach tabele przechowywane są w innym pliku niż formularze i raporty). Ponieważ makra są powiązane z tabelami, działają nawet wtedy, gdy ktoś połączy się z tabelami za pomocą innych mechanizmów niż przygotowana aplikacja frontonowa.
Rozdział 36. Makra danych
1041
Zdarzenia tabel Istnieje pięć różnych zdarzeń tabel, dla których można zaprogramować makra: Przed zmianą, Przed usunięciem, Po wstawieniu, Po aktualizacji i Po usunięciu. Aby zobaczyć te zdarzenia na wstążce, otwórz bazę danych Rozdział36.accdb, a następnie wyświetl tabelę tblProducts w widoku arkusza danych. Na wstążce widoczna jest zakładka TABELA. Otwórz tę zakładkę. Zobaczysz wtedy zdarzenia widoczne na rysunku 36.1: Przed zmianą, Przed usunięciem, Po wstawieniu, Po aktualizacji i Po usunięciu. Rysunek 36.1. Każda tabela Accessa jest powiązana z pięcioma zdarzeniami dotyczącymi danych. Są one dostępne w widoku arkusza danych
Początkową bazę danych do tego rozdziału, Rozdział36.accdb, możesz pobrać z witryny poświęconej tej książce.
Zdarzenia te można opisać jako zdarzenia „przed” i „po”. Zdarzenia „przed” zachodzą przed wprowadzeniem zmian w danych tabeli, natomiast zdarzenia „po” oznaczają, że informacje zostały z powodzeniem zmodyfikowane.
Zdarzenia „przed” Zdarzenia „przed” (Przed zmianą i Przed usunięciem) są bardzo proste i obsługują tylko niektóre akcje makr. Mogą obejmować mechanizmy przepływu sterowania (Komentarz, Grupa, Jeżeli) i blok danych WyszukajRekord. Jedyne obsługiwane akcje to WyczyśćBłąd Makra, PrzyBłędzie, ZgłośBłąd, UstawZmiennąLokalną i ZatrzymajMakro. Zdarzenie Przed zmianą jest podobne do zdarzenia Przed aktualizacją formularzy, raportów i formantów. Jak wskazuje nazwa, zdarzenie Przed zmianą zachodzi tuż przed zmodyfikowaniem danych w tabeli przez użytkownika, kwerendę lub kod VBA. Przed zmianą umożliwia sprawdzenie nowych wartości bieżącego rekordu i wprowadzenie zmian, jeśli są konieczne. Domyślnie odwołania do pól w zdarzeniach Przed zmianą i Przed usunięciem dotyczą bieżącego rekordu. Zdarzenie Przed zmianą to doskonałe miejsce na sprawdzanie poprawności danych wejściowych od użytkownika przed zatwierdzeniem wartości w tabeli. Prosty przykład przedstawiono na rysunku 36.2. Tu wartość domyślna pola Description w procedurze tblProducts_BeforeChange to Opis. Jeśli użytkownik nie zmieni wartości pola Description w trakcie dodawania nowego rekordu do tabeli, zdarzenie Przed zmianą zmodyfikuje tę wartość na Prosimy o podanie opisu.
1042
Część VIII Access i Windows SharePoint Services
Rysunek 36.2. Używanie zdarzenia Przed zmianą do zaktualizowania pola
Zdarzenie Przed zmianą nie może zakłócać pracy użytkownika przez wyświetlanie okna komunikatu lub blokować aktualizacji rekordu w powiązanej tabeli. Może jedynie zmienić wartość pola lub ustawić wartość zmiennej lokalnej makra przed dodaniem rekordu albo zaktualizowaniem go w tabeli. Zdarzenie Przed zmianą jest zgłaszane przy aktualizowaniu istniejących rekordów i wstawianiu nowych rekordów do tabeli. Access udostępnia też właściwość JestWstawione, która informuje makro o tym, czy zmiana jest wynikiem wstawienia nowego rekordu czy jego aktualizacji. Rysunek 36.3 pokazuje, jak zastosować tę właściwość w bloku Jeżeli, aby się upewnić, że zdarzenie Przed zmianą zaszło w wyniku wstawienia nowego rekordu do tabeli. Rysunek 36.3. Używanie właściwości JestWstawione do ustalenia, czy zdarzenie Przed zmianą zgłoszono w wyniku dodania nowego rekordu
Na rysunku 36.3 pokazano też, że bloki przepływu sterowania (np. Jeżeli) można zagnieżdżać. Zewnętrzny blok Jeżeli sprawdza wartość właściwości JestWstawione, natomiast wewnętrzny blok warunkowo ustawia wartość pola Description. Zdarzenie Przed usunięciem jest pod prawie każdym względem analogiczne do zdarzenia Przed zmianą, dlatego nie przedstawiamy tu żadnych przykładów. Zdarzenie Przed usunięciem można stosować do sprawdzania, czy warunki umożliwiają usunięcie. Zdarzenie Przed usunięciem (podobnie jak Przed zmianą) nie może zapobiec usunięciu rekordu, jednak można tu ustawić zmienną lokalną lub zgłosić błąd, jeśli warunki tego wymagają.
Zdarzenia „po” Zdarzenia „po” (Po zmianie, Po wstawieniu i Po usunięciu) są bardziej rozbudowane od ich odpowiedników „przed”. Każde z tych zdarzeń obsługuje wszystkie akcje makr danych (UsuńRekord, UstawPole, WyślijWiadomośćEmail itd.), dlatego prawdopodobnie często będziesz używać tych zdarzeń do tworzenia makr danych.
Rozdział 36. Makra danych
1043
Rysunek 36.4 przedstawia typowe zastosowanie zdarzenia Po wstawieniu. Zdarzenie to jest zgłaszane po dodaniu nowego rekordu do tabeli. Nowy rekord jest już zatwierdzony, a zdarzenie Po wstawieniu służy do zaktualizowania tabeli o nazwie tblProductActivityLog. Rysunek 36.4. Wykorzystanie zdarzenia Po wstawieniu do dodania rekordu do tabeli tblProductActivityLog
Na rysunku 36.4 zwróć uwagę na to, że w bloku UtwórzRekord aktualizowane są trzy pola (ProductActivity, ProductID i ProductDescription) tabeli tblProductActivityLog.ProductID to pole typu Autonumerowanie w zdarzeniu tblProducts_AfterInsert. Blok UtwórzRekord wcześniej dodał rekord do tabeli, dlatego w makrze danych dostępna jest wartość ProductID nowego rekordu. Gdy makro UstawPole aktualizuje pole ProductID w tabeli tblProduct ActivityLog, identyfikator rekordu z nowym produktem można z powodzeniem dodać do tabeli z rejestrem. Makro danych dla zdarzenia Po wstawieniu uruchamiane jest każdorazowo po dodaniu rekordu do tabeli. Podobne makra danych można dodać dla zdarzeń Po aktualizacji i Po usunięciu, aby rejestrować inne zmiany w tabeli. Najprzydatniejszą cechą zdarzeń „po” jest to, że można w nich zastosować blok DlaKażdego Rekordu, aby przejść po zbiorze rekordów z tabeli lub kwerendy. Dzięki temu zdarzenia „po” doskonale nadają się do sprawdzania spójności danych w tabeli, dodawania rekordów do tabeli z danymi dziennika operacji lub wykonywania innych wymagających obliczeniowo aktualizacji.
Używanie edytora makr do tworzenia makr danych Makra danych tworzy się za pomocą tego samego edytora makr co makra osadzone i interfejsu użytkownika. Po opanowaniu edytora makr można używać go do ich rozwijania i zarządzania nimi. Główną różnicą między poszczególnymi typami makr jest wykaz akcji (opisany w dalszej części rozdziału), który w zależności od kontekstu obejmuje inne operacje. Dodawanie makr danych do tabel jest proste. Tabela Accessa nie musi nawet być otwarta w widoku projektu — makra danych można dodawać także do tabel otwartych w formie arkusza. Makra danych dla tabel są aktywowane natychmiast, dlatego można
1044
Część VIII Access i Windows SharePoint Services
wygodnie pracować nad makrem i obserwować, jak dobrze działa. Nie trzeba przy tym kompilować kodu ani przełączać się między widokami projektowania i arkusza danych. W bazie danych Rozdział36.accdb otwórz tabelę tblProdukty w arkuszu danych. Pojawi się wtedy zakładka TABELA. Gdy ją klikniesz, zobaczysz zdarzenia widoczne na rysunku 36.5.
Rysunek 36.5. Aby otworzyć okno edytora makr, kliknij dwukrotnie dowolne ze zdarzeń wymienionych w zakładce TABELA
Gdy klikniesz dwukrotnie polecenie Po aktualizacji na wstążce, otworzy się okno projektowe makr (zobacz rysunek 36.6). Początkowo jest ono dość ubogie.
Rysunek 36.6. Okno projektowe makr dla zdarzenia Po aktualizacji tabeli
Duży prostokąt po lewej stronie okna to obszar projektowania makr. To tu umieszcza się akcje makra. Po prawej stronie widoczny jest Wykaz akcji — hierarchiczna lista wszystkich dostępnych obecnie akcji makr. Jedynymi informacjami o programowanym zdarzeniu tabeli są nagłówek głównego okna Accessa i zakładka nad obszarem projektowania. Gdy w obszarze projektowania otwarte jest makro, na wstążce znajduje się kilka narzędzi przydatnych przy pracy nad makrami. Zauważ, że można zwinąć lub rozwinąć sekcje makra, zapisać rozwijane makro, a także zamknąć okno projektowe makr.
Rozdział 36. Makra danych
1045
Wstążka widoczna na rysunku 36.6 jest taka sama jak przy pracy nad osadzonymi lub niezależnymi makrami interfejsu użytkownika. Jednak tu pewne opcje są niedostępne. Na przykład wszystkie elementy w grupie Narzędzia po lewej stronie wstążki są obecnie zablokowane. Makra danych nie umożliwiają przechodzenia przez akcje krok po kroku ani przekształcania makr na kod VBA. Makra danych powinny być stosunkowo proste, krótkie i konkretne, a nie długie i skomplikowane. Ten sam widok można otworzyć w inny sposób, jeśli tabela wyświetlona jest w widoku projektu. Należy wtedy kliknąć polecenie Utwórz makra danych z zakładki PROJEKTOWANIE (zobacz rysunek 36.7). Rysunek 36.7. Wybieranie zdarzenia tabeli w widoku projektu
W obu sytuacjach pojawi się okno projektowe makr widoczne na rysunku 36.6. Gdy używany jest interfejs Accessa z zakładkami, nazwa tabeli i wybranego zdarzenia widoczne są w zakładce okna projektowego makr. Jeżeli używany jest interfejs z nakładającymi się oknami, informacja o tabeli i zdarzeniu znajduje się w nagłówku głównego okna Accessa. Zwróć uwagę na opcję Nazwane makro na rysunkach 36.5 i 36.7. Nazwane makro to makro danych dołączone do zdarzenia tabeli. Jedyna różnica polega na tym, że nazwane makro jest niezależne — nie jest powiązane z konkretnym zdarzeniem. Makro nazwane można wywoływać w makrach dla dowolnych zdarzeń; zwykle obejmuje kod używany we wszystkich polach tabeli. Załóżmy, że w aplikacji obowiązuje reguła biznesowa dotycząca sposobu aktualizowania ceny produktu. Jeśli więcej niż jedno makro danych tabeli może zmienić cenę hurtową produktu, można utworzyć nazwane makro do obsługi aktualizowania pola RetailPrice. Makro to można następnie wywoływać w innych makrach danych dla dowolnej tabeli. Dzięki temu każde makro z tabeli będzie obsługiwać aktualizacje w ten sam sposób.
Posługiwanie się wykazem akcji Wykaz akcji widoczny po prawej stronie okna projektowego makr to zbiór akcji, które można dodawać do makr danych. Zawartość wykazu makr zależy od wybranego zdarzenia tabeli. Dlatego wygląd wykazu znacznie się zmienia w trakcie pracy nad makrami Accessa.
1046
Część VIII Access i Windows SharePoint Services
Przepływ sterowania w programie W górnej części wykazu akcji (zobacz rysunek 36.6) znajdują się mechanizmy makr związane z przepływem sterowania w programie. W trakcie pracy nad makrami danych jedyne dostępne mechanizmy to komentarze, grupy i bloki Jeżeli. Komentarze pomagają w dokumentowaniu pracy makr. Należy je stosować, jeśli trudno jest zrozumieć działanie makr. Komentarze nie są kodem wykonywalnym — służą do dodawania tekstu wyjaśniającego funkcjonowanie makra. Grupa makr pozwala umieścić zbiór akcji makr w nazwanej jednostce. Grupę można zwijać, kopiować i przenosić w ramach makra. Grupa makra nie jest jednak jednostką wykonywalną. Stanowi tylko wygodne narzędzie do tworzenia bloków akcji makr, co pozwala uprościć wygląd makra w oknie projektowym. Blok Jeżeli dodaje do makra rozgałęzienie. W innych rozdziałach zetknąłeś się już z instrukcjami If...Then...Else w kodzie VBA. Blok Jeżeli w makrach działa podobnie.
Bloki danych Na rysunku 36.6 pod sekcją Przepływ sterowania programu widoczna jest sekcja Bloki danych. Każda instrukcja z grupy Bloki danych obejmuje obszar, w którym można umieścić jedną lub więcej akcji makr. Blok danych w ramach działania wykonuje wszystkie powiązane z nim akcje. Oznacza to, że należy utworzyć blok danych (np. EdytujRekord), a następnie dodać do niego akcje, które mają być wykonywane w jego ramach. Bloki danych można zagnieżdżać. Można na przykład utworzyć blok DlaKażdegoRekordu, a następnie uruchomić blok UtwórzRekord i dodać do innej tabeli rekordy z danymi z rekordów zwróconych przez blok DlaKażdegoRekordu. Oto akcje dostępne w blokach danych: — umożliwia dodanie rekordu do bieżącej (jest to rzadko wykorzystywana możliwość) lub do innej tabeli (to podejście stosuje się częściej). W ten sposób można na przykład utworzyć rejestr z wszystkimi zmianami wprowadzonymi w tabeli tblProducts (podobny do rejestru generowanego przez kod z rysunku 36.4). Akcja UtwórzRekord pozwala dodać nowy rekord do tabeli i zapełnić pola rekordu danymi z bieżącej tabeli. Rzadko jest stosowana do dodawania rekordów do bieżącej tabeli, ponieważ może prowadzić do rekurencji. Dodawanie nowego rekordu do bieżącej tabeli powoduje zgłoszenie zdarzenia Po wstawieniu (opisanego w punkcie „Zdarzenia »po«” we wcześniejszej części rozdziału), co może prowadzić do ciągłego uruchamiania akcji UtwórzRekord.
UtwórzRekord
— umożliwia zmianę zawartości rekordu w bieżącej lub innej tabeli. Doskonale się nadaje na przykład do dostosowywania stanu magazynu po sprzedaży lub zwrocie produktu albo do obliczania podatków i kosztów dostawy po określeniu liczby sztuk.
EdytujRekord
— tworzy pętlę. Przyjmuje nazwę tabeli lub kwerendy i wykonuje operacje na wszystkich rekordach ze zbioru. W ten sposób można aktualizować dane za pomocą akcji UstawPole (opisanej w dalszym punkcie),
DlaKażdegoRekordu
Rozdział 36. Makra danych
1047
kopiować dane, a także wykonywać operacje matematyczne na danych ze zbioru rekordów. Blok DlaKażdegoRekordu obejmuje akcję, co umożliwia łatwe wskazanie operacji, które należy w nim wykonać. Ponadto w bloku tego typu można umieścić wiele akcji, aby wykonywać złożone zadania. — jest to stosunkowo prosta i zrozumiała akcja. Zwraca rekord znaleziony w tabeli i udostępnia obszar akcji, w którym można określić operacje wykonywane na zwróconym rekordzie.
WyszukajRekord
Bloki UtwórzRekord, EdytujRekord i DlaKażdegoRekordu są dostępne tylko przy tworzeniu makr dla zdarzeń „po” (czyli dla makr danych Po wstawieniu, Po aktualizacji i Po usunięciu). Makra „przed” powinny być bardzo szybkie i proste, dlatego nie obsługują wymagających obliczeniowo operacji takich jak dodawanie lub edytowanie rekordów.
Akcje danych Następnym grupą akcji w ich wykazie są Akcje danych. Są to akcje wykonywane przez makra danych. Wiesz już, że makro danych obejmuje akcje wykonywane wspólnie w odpowiedzi na zgłoszenie zdarzenia tabeli. Należy dobrze poznać różnorodne akcje dostępne w makrach danych. Nie wszystkie akcje są dostępne dla każdego zdarzenia tabeli. Dla zdarzeń Przed zmianą i Przed usunięciem (opisanych w punkcie „Zdarzenia »przed«” we wcześniejszej części rozdziału) można używać tylko niektórych akcji. Wiele akcji wymaga przeprowadzenia wielu obliczeń (np. aktualizowania lub dodawania rekordów), a zdarzenia „przed” powinny być bardzo szybkie i proste.
Oto dostępne akcje makr danych: — usuwa rekord z tabeli (użytkownik nie musi potwierdzać tej operacji). Oczywiście akcję tę trzeba stosować ostrożnie, aby nie usunąć z aplikacji cennych danych. Standardowo używa się jej w ramach archiwizowania, gdy dane są kopiowane z jednej tabeli do drugiej (np. do powiązanej tabeli bazy SQL Server), a następnie usuwane z bieżącej tabeli.
UsuńRekord
— operacje EdytujRekord i UtwórzRekord wprowadzają w rekordzie nieodwracalne zmiany. Akcja AnulujZmianęRekordu w połączeniu z blokiem Jeżeli pozwala makru danych anulować zmiany wprowadzone przez te operacje przed zatwierdzeniem modyfikacji w bazie danych.
AnulujZmianęRekordu
ZakończDlaKażdegoRekordu — przechodzi w pętli po zbiorze rekordów zwróconym
przez tabelę lub kwerendę i umożliwia makru danych wprowadzenie zmian w danych ze zbioru lub sprawdzenie danych pod kątem ciekawych wartości. W wielu sytuacjach makro danych powinno wyjść z pętli DlaKażdegoRekordu przed dojściem do końca zbioru. Wyobraź sobie makro, które szuka określonej wartości w tabeli. Po jej znalezieniu dalsze wykonywanie pętli nie ma sensu. Akcja ZakończDlaKażdegoRekordu jest zwykle wykonywana w bloku Jeżeli (opisanym w innym punkcie), gdy spełniony zostanie określony warunek. RejestrujZdarzenie
— każda aplikacja w Accessie 2013 obejmuje ukrytą tabelę
USysApplicationLog (tabela jest ukryta z uwagi na przedrostek USys). Tabela ta
służy do rejestrowania błędów makr danych. Można w niej zapisywać także inne
1048
Część VIII Access i Windows SharePoint Services
informacje. Akcja RejestrujZdarzenie jest przeznaczona specjalnie do dodawania rekordu do tabeli USysApplicationLog w dowolnym miejscu makra danych. Jedyne pole tej tabeli, które można określić w akcji RejestrujZdarzenie, to pole Description typu Długi tekst. Wartości pozostałych pól tabeli USysApplicationLog (Category, Context, DataMacroInstanceID, ErrorNumber, ObjectType i SourceObject) są podawane przez samo makro. — wysyła wiadomość e-mail przy użyciu domyślnego programu pocztowego z systemu Windows (zwykle jest to Outlook). Argumenty tej akcji to Do, DW, UDW, Temat i Treść. Akcja ta jest przydatna w pewnych sytuacjach, na przykład przy automatycznym wysyłaniu wiadomości po wystąpieniu błędu lub gdy liczba produktów w magazynie spada poniżej ustalonego poziomu.
WyślijWiadomośćEmail
— aktualizuje wartość pola w tabeli. Argumentami tej akcji są nazwy tabeli i pola, a także przypisywana wartość. Nie jest dostępna dla zdarzeń Przed zmianą i Przed usunięciem.
UstawPole
— w makrach w Accessie 2013 można używać zmiennych lokalnych do przekazywania wartości z jednej części makra do innej. Można na przykład utworzyć makro, które wyszukuje wartość w tabeli i przekazuję tę wartość jako zmienną do następnej akcji. UstawZmiennąLokalną to uniwersalna akcja do deklarowania zmiennych i przypisywania im wartości. Tworzy zmienną i przypisuje do niej wartość.
UstawZmiennąLokalną
— przerywa pracę wykonywanego makra. Powoduje jego zatrzymanie i zamknięcie. Najczęściej używa się jej w połączeniu z blokiem danych Jeżeli lub z akcją PrzyBłędzie. Akcja ZatrzymajMakro nie przyjmuje argumentów.
ZatrzymajMakro
— działa podobnie jak ZatrzymajMakro, ale dotyczy wszystkich wykonywanych aktualnie makr. Makra działają czasem asynchronicznie, ponieważ zdarzenia tabeli mogą spowodować jednoczesne uruchomienie wielu makr. Ponadto w makrach można też wywoływać różne makra nazwane.
ZatrzymajWszystkieMakra
— jest to bardzo prosta akcja. Jej jedynym argumentem jest nazwa innego makra danych, które Access ma uruchomić. Jest przydatna, gdy pewne makro danych wykonuje zadanie przydatne w innym makrze danych. Zamiast powielać akcje, łatwiej jest wywołać odpowiednie makro i pozwolić mu na wykonanie jego akcji. Wymaga to tylko jednej instrukcji.
UruchomMakroDanych
— akcja ta jest podstawą mechanizmu obsługi błędów makr w Accessie. Jest to dyrektywa, która informuje Accessa, co należy zrobić, gdy w trakcie wykonywania makra wystąpi błąd. Pierwszy argument (Przejdź do) jest wymagany. Przyjmuje wartości Następny, Niepowodzenie lub nazwę makra. Argument Następny powoduje zignorowanie błędu i przejście do akcji makra znajdującej się po operacji, która spowodowała problem.
PrzyBłędzie
Jeśli w określonym makrze danych nie znajduje się inna akcja PrzyBłędzie, argument Przejdź do o wartości Następny powoduje, że Access ignoruje wszystkie błędy w makrze danych i kontynuuje działanie niezależnie od tego, jakie problemy wystąpią. Jeżeli argumentem jest nazwa makra, po wystąpieniu błędu Access przeskoczy do niego. Należy tu podać makro nazwane, czyli kolekcję akcji makr niepowiązanych z konkretnym zdarzeniem tabeli. Może to być makro nazwane z bieżącej lub innej tabeli.
Rozdział 36. Makra danych
1049
— przekazuje błąd do warstwy interfejsu użytkownika. Akcję tę można wykorzystać w zdarzeniu Przed zmianą przy sprawdzaniu poprawności danych przed ich zatwierdzeniem w bazie. Przekazuje ona do aplikacji numer i opis błędu, a także zapisuje informacje o błędzie w tabeli USysApplicationLog.
ZgłośBłąd
— po obsłużeniu błędu za pomocą akcji ZgłośBłąd lub przekierowaniu sterowania do nazwanego makra można uruchomić akcję WyczyśćBłądMakra, która zeruje obiekt błędu makra (MacroError) i przygotowuje Accessa na wystąpienie kolejnych błędów.
WyczyśćBłądMakra
Tworzenie pierwszego makra danych Poznałeś już podstawowe informacje na temat okna projektowego makr i wykazu akcji. Pora przystąpić do tworzenia pierwszego makra danych. W tym ćwiczeniu załóżmy, że narzut firmy standardowo wynosi 66,66%. Oznacza to, że cena hurtowa produktu jest mnożona przez 1,6666, aby uzyskać cenę detaliczną. Firma ustaliła, że narzut w wysokości 66,66% jest wystarczający, aby można było oferować upusty przy zakupie większej liczby produktów, organizować wyprzedaże i proponować rabaty wybranym nabywcom, a jednocześnie nadal generować zyski. Problem można rozwiązać za pomocą makra danych, które aktualizuje cenę detaliczną produktu za każdym razem, gdy zmienia się koszt. Choć efekt ten można łatwo uzyskać za pomocą kodu lub makra powiązanego z formularzami Accessa, wyobraź sobie sytuację, gdy koszt produktu może się zmienić w dziesiątkach różnych formularzy. Wtedy identyczny kod lub to samo makro trzeba dodać w wielu różnych miejscach. Zwiększa to koszty pisania kodu i zarządzania nim. Ponadto zawsze może się zdarzyć, że programista zapomni zmodyfikować formularze, jeśli firma zdecyduje się zmienić sposób ustalania domyślnej ceny detalicznej produktów. Makro danych połączone bezpośrednio z tabelą produktów pozwala uprościć pisanie kodu i zarządzanie formularzami i raportami aplikacji. Ponieważ reguła biznesowa (mnożenie kosztu przez 1,6666) jest wymuszana w warstwie danych, nowe makro danych będzie przydatne we wszystkich formularzach, raportach i kwerendach używających danych o produktach. Jeśli jeszcze tego nie zrobiłeś, otwórz bazę danych dla tego ćwiczenia, Rozdział36.accdb (można ją pobrać z witryny poświęconej tej książce).
1. Otwórz tabelę tblProducts w widoku arkusza danych. 2. Otwórz zakładkę TABELA na wstążce i wybierz zdarzenie Przed zmianą. Access wyświetli wtedy okno projektowe makr. 3. Kliknij dwukrotnie akcję Grupa z sekcji Przepływ sterowania programu lub przeciągnij tę akcję na powierzchnię okna projektowego makr. Pozwala to utworzyć nową grupę makra. Nadaj grupie makra nazwę, jak pokazano na rysunku 36.8.
1050
Część VIII Access i Windows SharePoint Services
Rysunek 36.8. Dodaj grupę do makra i nadaj jej nazwę
4. Umieść kursor w nowo utworzonej grupie i kliknij dwukrotnie akcję Komentarz z sekcji Przepływ sterowania programu. Spowoduje to dodanie komentarza w oknie projektowym makra. W komentarzu wpisz zrozumiały tekst wyjaśniający, jak działa makro (zobacz rysunek 36.9).
Rysunek 36.9. Dodaj komentarz opisujący działanie makra
5. Teraz kliknij dwukrotnie akcję Jeżeli, aby dodać nowy test logiczny w oknie projektowym makra. Na rysunku 36.10 pokazano, że test sprawdza, czy wartość w polu Cost jest większa niż zero. Ten test gwarantuje, że pozostała część makra zostanie wykonana tylko wtedy, gdy spełnione są określone warunki.
Rysunek 36.10. Blok Jeżeli warunkowo wykonuje akcje makra na podstawie podanych testów Zauważ, że w prawym dolnym rogu bloku Jeżeli znajdują się opcje, które umożliwiają dodanie warunku „inaczej” lub „jeżeli inaczej”. Za pomocą tych opcji można rozbudować blok Jeżeli o nowe warunki sprawdzane w ramach tego samego bloku.
Rozdział 36. Makra danych
1051
6. Jeśli podany warunek jest sprawdzony, makro ma zmodyfikować rekord. Kliknij dwukrotnie akcję UstawPole, aby dodać ją do bloku Jeżeli. W tej akcji należy wskazać edytowane pole i określić wartość. Ustawienia z rysunku 36.11 oznaczają, że makro ma ustawiać w polu [RetailPrice] wartość wyrażenia [Cost]*1,66.
Rysunek 36.11. Akcja UstawPole to informacja dla Accessa, że ma zmodyfikować rekord, jeśli warunek jest spełniony
7. Na tym etapie kod makra jest gotowy. Ostatni krok polega na kliknięciu polecenia Zapisz, co spowoduje utworzenie makra (zobacz rysunek 36.12).
Rysunek 36.12. Po kliknięciu przycisku Zapisz makro zostaje utworzone i zaczyna działać
Aby przetestować makro, otwórz tabelę tblProducts i wpisz dodatnią wartość w polu Cost dowolnego rekordu, jak pokazano na rysunku 36.13. Wartość pola RetailPrice zostanie automatycznie obliczona na podstawie akcji z utworzonego wcześniej makra danych dla zdarzenia Przed zmianą.
1052
Część VIII Access i Windows SharePoint Services
Rysunek 36.13. Gdy wpiszesz dodatnią wartość w polu Cost, pole RetailPrice zostanie automatycznie zaktualizowane
Opisane makro danych będzie działać nawet wtedy, gdy modyfikacje będą wprowadzane za pomocą formularzy Accessa w bazie danych na komputerze biurkowym lub w sieciowej aplikacji Accessa.
Zarządzanie elementami makr Na tym etapie powinieneś już dobrze wiedzieć, jak działa okno projektowe makr. Ten podrozdział jest bardziej szczegółowy. Poznasz w nim sposoby zarządzania dodanymi do projektu elementami makr.
Zwijanie i rozwijanie elementów makr Zauważ, że na rysunku 36.12 po lewej stronie nazwy każdego elementu makra w oknie projektowym znajdują się przyciski zwijania i rozwijania. Umożliwiają one wyświetlanie i ukrywanie fragmentów makr. Na rysunku 36.14 widoczne jest to samo makro ze zwiniętą grupą. Rysunek 36.14. Można zwijać i rozwijać elementy makr, aby uprościć obszar okna projektowego
Zwinięcie elementów jest pomocne, gdy trzeba wyświetlić długie makro lub tylko jego fragment. Można też zastosować instrukcje Rozwiń i Zwiń ze wstążki.
Przenoszenie elementów makr Czasem trzeba zmienić kolejność akcji makra. Access udostępnia kilka technik przenoszenia elementów w oknie projektowym makr. Elementy makr (bloki, akcje itd.) można kopiować i wklejać w makrze. Wystarczy kliknąć element i wcisnąć kombinację klawiszy Ctrl+C lub Ctrl+X, aby skopiować albo wyciąć ten element. Następnie należy umieścić kursor w innym miejscu okna projektowego makr i wcisnąć kombinację klawiszy Ctrl+V.
Rozdział 36. Makra danych
1053
Elementy makra można przenosić w inne miejsce za pomocą myszy. Proces ten jest nieco skomplikowany, ponieważ bardzo łatwo można przypadkowo przesunąć element znajdujący się w odpowiedniej lokalizacji. Precyzyjnie umieść kursor myszy w górnej części docelowego elementu, kliknij i przeciągnij element w nowe miejsce. Access udostępnia też wygodne strzałki skierowane w górę i w dół (zobacz rysunek 36.15), które pozwalają szybko przenieść dowolny element makra w odpowiednie miejsce. Rysunek 36.15. Kolejność elementów makra można zmienić, klikając i przeciągając obiekty, kopiując je i wklejając, a także używając strzałek skierowanych w górę i w dół, które znajdują się obok docelowego elementu
Zapisywanie makr w plikach XML Ukrytą funkcją makr danych w Accessie jest możliwość skopiowania ich z okna projektowego i wklejenia do edytora tekstu w formacie XML. Access przechowuje makra właśnie w tym formacie. Także przy kopiowaniu makra mają format XML. Jest kilka przyczyn, dla których przydatne może być zapisanie makra w formacie XML:
Przesłanie makra w wiadomości e-mail.
Zarchiwizowanie makra. Ponieważ tabele obejmują tylko jedną kopię makr dla poszczególnych zdarzeń (np. dla zdarzenia Po aktualizacji), nie istnieje prosty sposób, by utworzyć kopię makra przed wprowadzeniem zmian w jego kodzie.
Rysunek 36.16 przedstawia makro z rysunku 36.15 w formacie XML wklejone w Notatniku w systemie Windows. Aby uzyskać kod w XML-u, wystarczy skopiować makro z okienka nawigacyjnego, a następnie wkleić je w wiadomości e-mail albo w Notatniku lub innym edytorze tekstu. Kod XML-a zapisany w pliku tekstowym można wkleić bezpośrednio w oknie projektowym makra. Access wyświetli wtedy makro w standardowy sposób. Wklejanie odbywa się jak w programie Microsoft Word lub zwykłym edytorze tekstu. Wklejone makro pojawia się tam, gdzie znajduje się kursor.
1054
Część VIII Access i Windows SharePoint Services
Rysunek 36.16. Zapisywanie makra w formacie XML
Ograniczenia makr danych Choć makra danych dają dużo możliwości, są rzeczy, których nie da się zrobić przy ich użyciu. Nie mają na przykład interfejsu użytkownika. Nie potrafią wyświetlać okien komunikatów ani otwierać formularzy i raportów. Możliwość komunikowania się z interfejsem użytkownika z poziomu makr danych jest bardzo ograniczona. Makr tego rodzaju nie można więc stosować do powiadamiania użytkowników o problemach lub do modyfikowania danych w tabelach. Wyświetlanie elementów interfejsu użytkownika (np. okien komunikatów) prowadziłoby do znacznego spadku wydajności, zwłaszcza przy masowym aktualizowaniu lub wstawianiu danych. Makra danych mają działać w niewidoczny sposób i być jak najwydajniejsze. Makra danych są dołączane bezpośrednio do tabel Accessa, a nie do poszczególnych pól. Jeśli chcesz śledzić lub aktualizować większą liczbę pól, będziesz potrzebować skomplikowanego makra. Wykorzystanie bloku Jeżeli to dobry sposób na warunkowe wykonywanie zbiorów instrukcji makra. Okno projektowe makr obsługuje tylko jedno makro w danym momencie. Trzeba zatrzymać bieżące makro przed zamknięciem go i otwarciem innego. Ponadto okno projektowe makr jest modalne. Nie można wyjść z edytora makr bez zamknięcia i zapisania bieżącego makra (lub odrzucenia wprowadzonych w nim zmian). Z uwagi na to podglądanie danych z tabeli w trakcie pracy nad kodem makra danych jest niewygodne. Dlatego przed przystąpieniem do tworzenia makra danych dla tabeli warto starannie opracować plan. W modelu z podziałem bazy danych makra danych nie są wykonywane na zapleczu. Choć makra danych znajdują się w tabelach w bazach działających na zapleczu, są wykonywane tylko we frontonie. Makra danych nie obsługują pól o wielu wartościach i z załącznikami. Jeśli potrzebny jest kod do kontrolowania tych typów danych, trzeba zastosować tradycyjne makra interfejsu użytkownika lub kod VBA.
Rozdział 36. Makra danych
1055
Makra danych w Accessie 2013 nie działają dla tabel związanych. Nie można pisać makr danych dla tabel z bazy danych Accessa, które są powiązane z bazą SQL Server. Niezbędne są wtedy tradycyjne makra interfejsu użytkownika lub kod VBA. Makra danych nie potrafią wywoływać procedur języka VBA. Ważną cechą makr danych jest zgodność ze środowiskiem SharePointa przy rozbudowywaniu aplikacji Accessa do aplikacji sieciowych. Wywołania procedur VBA zakończą się niepowodzeniem, ponieważ nie istnieje sposób na przekształcenie kodu VBA na kod JavaScriptu w środowisku SharePointa. Publikowanie baz danych Accessa w środowisku SharePointa omówiliśmy w rozdziałach 34. i 35.
Makra danych nie obsługują transakcji. Aktualizacja każdego pola i rekordu zachodzi natychmiast. Nie ma możliwości wycofania zbioru zmian wprowadzonych w tabeli. Makra danych nie są też zgodne z wersjami Accessa wcześniejszymi niż 2007. Access 2007 z zainstalowanym dodatkiem SP1 potrafi wczytywać tabele Accessa 2010 i 2013 z makrami danych, jednak nie potrafi zapisywać w nich informacji.
1056
Część VIII Access i Windows SharePoint Services
Dodatki W tej części:
Dodatek A Specyfikacja Accessa 2013
Dodatek B Optymalizowanie aplikacji Accessa
Dodatek C Wydajność kwerend i uszkodzenia baz danych
Dodatek D Przegląd funkcji dla analityków danych
Książka kończy się kilkoma dodatkami przydatnymi jako encyklopedyczne źródło wiedzy w trakcie pracy z programem Microsoft Access 2013. W dodatku A omówiliśmy specyfikację Accessa 2013. Poznasz tu ograniczenia dotyczące obiektów Accessa (rozmiaru bazy danych, liczby obiektów bazy danych, liczby wierszy w tabeli Accessa itd.). W dodatku B znajdziesz wybrane najlepsze praktyki zapewniające optymalną pracę aplikacji Accessa. Dodatek C zawiera pomysły pomagające uniknąć problemów z wydajnością i uszkodzeniem danych w trakcie korzystania z baz Accessa. W dodatku D szczegółowo omawiamy wybrane z najczęściej stosowanych wbudowanych funkcji Accessa dostępnych dla analityków danych.
1058
Dodatki
Dodatek A
Specyfikacja Accessa 2013 W tym dodatku:
Specyfikacje i ograniczenia Accessa 2013
Limity dotyczące tabel, kwerend, formularzy i raportów w Accessie 2013
Przegląd ograniczeń serwera SQL Server Express
W dodatku pokazano ograniczenia baz danych programu Microsoft Access 2013, a także tabel, kwerend, formularzy, raportów i makr. Warto pamiętać, że wartości podane w dodatku mogą się zmienić. Najnowsze informacje na temat specyfikacji znajdziesz w witrynie Microsoftu (http://www.microsoft.com). Maksymalna wielkość bazy danych, liczba kolumn i inne ograniczenia baz danych Accessa w większości aplikacji są więcej niż wystarczające. Jednak dla wielu programistów częstym problemem jest limit rozmiaru bazy danych. Obecnie wynosi on 2 gigabajty. Może się okazać, że z powodu dużej ilości danych zostanie on szybko przekroczony. Jeśli baza obejmuje ponad 2 gigabajty danych, których nie można rozdzielić do kilku baz zaplecza, prawdopodobnie warto rozważyć przeniesienie jej do bazy SQL Server Express. SQL Server Express obsługuje bazy o wielkości do 10 gigabajtów, dlatego może przydać się w początkowym etapie przenoszenia. W Accessie narzędzia do przenoszenia baz są bardzo łatwe w użyciu i niemal niezawodne. Baza SQL Server Express jest bezpłatna i można ją swobodnie rozpowszechniać wraz z aplikacjami Accessa. Aby znaleźć bezpłatny pakiet z tą bazą do pobrania, wpisz w wyszukiwarce wyrażenie „SQL Server Express 2008 R2”.
Zawsze należy pamiętać, że Access to system bazodanowy oparty na plikach. Plik bazy danych Accessa —.accdb, .mdb lub innego typu — to tylko plik systemu Windows. Bazy danych Accessa nie obsługują rejestrowania, anulowania, archiwizowania i innych zadań administracyjnych, które mają chronić dane z bazy. W pewnym momencie przechowywanie dużych ilości bardzo ważnych danych w systemie bazodanowym opartym
1060
Dodatki
na plikach nie ma już sensu biznesowego. Serwerowe systemy bazodanowe (np. SQL Server Express) udostępniają wszelkie narzędzia potrzebne do właściwego zarządzania dużymi ilościami danych i ich ochrony.
Specyfikacje dotyczące baz danych Accessa W tabelach od A.1 do A.5 znajdziesz specyfikacje dotyczące plików z bazami danych Accessa. W każdej tabeli przedstawiamy specyfikacje różnych elementów baz danych Accessa. Tabela A.1. Bazy danych Atrybut
Wartość maksymalna
Rozmiar pliku .accdb lub .mdb włącznie ze wszystkimi obiektami bazy danych i danymi
2 GB minus rozmiar potrzebny dla obiektów systemowych*
Całkowita liczba obiektów w bazie danych (tabel, kwerend, formularzy, raportów, itp.)
32 768
Liczba modułów włącznie z modułami dołączonymi do formularzy i raportów
1000
Liczba znaków w nazwach obiektów
64
Liczba znaków w haśle dostępu do bazy danych
14
Liczba znaków w nazwach użytkowników lub grup
20
Liczba współbieżnych użytkowników
255
*
Ponieważ baza danych może zawierać dołączone tabele w wielu plikach, całkowity rozmiar bazy danych jest ograniczony jedynie przez dostępną ilość miejsca na dysku. Tabela A.2. Tabele Atrybut
Wartość maksymalna
Liczba znaków w nazwie tabeli
64
Liczba znaków w nazwie pola
64
Liczba pól w rekordzie lub tabeli
255
Liczba otwartych tabel
2048 włącznie z tabelami systemowymi otwieranymi wewnętrznie przez program Access i tabelami dołączonymi
Rozmiar tabeli
2 GB minus miejsce potrzebne do zapisania obiektów systemowych*
Liczba znaków w polu Krótki tekst
255
Liczba znaków w polu Długi tekst
65 535 w przypadku wprowadzania danych za pomocą interfejsu użytkownika, 1 GB w przypadku wprowadzania programowego
Dodatek A Specyfikacja Accessa 2013
1061
Tabela A.2. Tabele — ciąg dalszy
*
Atrybut
Wartość maksymalna
Rozmiar pól z obiektami OLE
1 GB
Liczba indeksów w rekordzie lub tabeli (włącznie z indeksami złożonymi, indeksami kluczy głównych i innymi)
32 (z uwzględnieniem indeksów jednopolowych i złożonych, a także indeksów tworzonych wewnętrznie do zarządzania relacjami między tabelami)
Liczba pól w indeksach lub kluczach głównych
10
Liczba znaków w komunikacie sprawdzania poprawności
255
Liczba znaków w regule poprawności (włącznie z operatorami i znakami interpunkcyjnymi)
2048
Liczba znaków w opisie tabeli lub pola
255
Liczba znaków w rekordzie
4000 (oprócz pól typu Długi tekst i obiektów OLE)
Liczba znaków w ustawieniu właściwości pola
255
Liczba wierszy w tabelach Accessa jest nieograniczona.
Tabela A.3. Kwerendy Atrybut
Wartość maksymalna
Liczba tabel w kwerendzie
32
Liczba wymuszonych relacji w tabeli
32 minus liczba indeksów dla tabeli zdefiniowanych dla pól lub kombinacji pól, które nie biorą udziału w relacjach
Liczba pól w zestawie rekordów
255
Maksymalna wielkość zbioru rekordów
1 GB
Limit sortowania
255 znaków w jednym lub kilku polach
Liczba poziomów w kwerendach zagnieżdżonych
50
Liczba znaków w komórce w widoku projektu
1024
Liczba znaków w nazwie parametru dla kwerendy z parametrami
255
Liczba warunków AND w klauzuli WHERE lub HAVING
99
Liczba znaków w instrukcjach SQL-a
64 000 (w przybliżeniu)
1062
Dodatki
Tabela A.4. Formularze i raporty Atrybut
Wartość maksymalna
Liczba znaków w etykietach
2048
Liczba znaków w polu tekstowym
65 535
Szerokość formularza lub raportu
57,79 cm (22,75 cala)
Wysokość sekcji
57,79 cm (22,75 cala)
Wysokość wszystkich sekcji wraz z nagłówkiem w widoku projektu
508 cm (200 cali)
Liczba poziomów w zagnieżdżonych formularzach lub raportach
7 (formularz — podformularz — podformularz)
Liczba pól (wyrażeń), na podstawie których możesz sortować lub grupować pola (tylko w raportach)
Liczba znaków w instrukcjach SQL-a będących właściwościami Źródło rekordów lub Źródło wierszy formularza, raportu lub formantu (zarówno dla plików .mdb, jak .adp)
32 750
Liczba formantów lub sekcji, które można dodać w „czasie życia” formularza lub raportu
754
Liczba znaków w instrukcji SQL-a spełniającej funkcję właściwości Źródło wierszy formularza lub raportu albo Źródło wierszy formantu
32 750
Tabela A.5. Makra Atrybut
Wartość maksymalna
Liczba operacji w makrach
999
Liczba znaków w warunku
255
Liczba znaków w komentarzu
255
Liczba znaków w argumencie operacji
255
Dodatek A Specyfikacja Accessa 2013
1063
Specyfikacja bazy danych Microsoft SQL Server Express Tabela A.6 przedstawia specyfikację tylko wersji SQL Server 2008 R2 Express Edition. Pozostałe wersje baz SQL Server Express są pod wieloma względami podobne. Wyjątkiem jest maksymalna wielkość bazy danych. Na przykład w wersji SQL Server 2005 Express maksymalna wielkość bazy wynosiła 4 gigabajty. Tabela A.6. Możliwości systemu Microsoft SQL Server Express 2008 Atrybut baz danych SQL Server
Maksymalne rozmiary/liczby
Wykorzystywane rdzenie procesora
1*
Maksymalne wykorzystanie pamięci
1 gigabajt
Rozmiar bloku tekstu (ang. batch size)
65 536 rozmiar pakietu sieciowego
Rozmiar kolumny short string w bajtach
8000
Rozmiar klauzuli GROUP BY, ORDER BY w bajtach
8060
Rozmiar klucza indeksowego (w bajtach)
900
Rozmiar klucza obcego (w bajtach)
900
Rozmiar klucza głównego (w bajtach)
900
Rozmiar wiersza (w bajtach)
8060
Rozmiar tekstu źródłowego procedury składowanej
Mniejsza z dwóch wartości: rozmiar bloku danych lub 250 MB
Rozmiar kolumn typu varchar(max), varbinary(max), 1 073 741 823 xml, text lub image (w bajtach) Rozmiar kolumn typu ntext lub nvarchar(max) (w znakach)
536 870 910
Liczba indeksów podzielonych na klastry w tabeli
1
Liczba kolumn w klauzuli GROUP BY, ORDER BY
Ograniczona tylko rozmiarem w bajtach
Liczba kolumn lub wyrażeń w instrukcjach GROUP BY 10 WITH CUBE lub WITH ROLLUP Liczba kolumn tworzących klucz indeksowy
16
Liczba kolumn tworzących klucz obcy
16
Liczba kolumn tworzących klucz główny
16
Liczba kolumn w tabeli bazy
1024
Liczba kolumn w instrukcji SELECT
4096
Liczba kolumn w instrukcji INSERT
1024
Liczba połączeń dla klienta
Maksymalna liczba skonfigurowanych połączeń
Rozmiar bazy danych
10 gigabajtów
1064
Dodatki
Tabela A.6. Możliwości systemu Microsoft SQL Server Express 2008 — ciąg dalszy Atrybut baz danych SQL Server
Maksymalne rozmiary/liczby
Liczba baz danych na egzemplarz serwera SQL Server
32 767
Liczba grup plików w bazie danych
32 767
Liczba plików w bazie danych
32 767
Rozmiar pliku (dane)
4 gigabajty (bez pliku dziennika)
Rozmiar pliku (dziennik)
2 terabajty
Liczba odwołań do klucza obcego w tabeli
253
Rozmiar identyfikatora (w znakach)
128
Liczba egzemplarzy na komputer
16
Rozmiar ciągu zawierającego instrukcje SQL-a (rozmiar bloku)
65 536 rozmiar pakietu sieciowego
Liczba blokad w połączeniu
Maksymalna liczba blokad na serwer
Liczba blokad na egzemplarz serwera SQL Server
Maksymalnie 2 147 483 647
Liczba poziomów zagnieżdżonych procedur składowanych
32
Liczba poziomów zagnieżdżonych podkwerend
32
Liczba poziomów zagnieżdżonych wyzwalaczy
32
Liczba indeksów niepodzielonych na klastry w tabeli 999
*
Liczba parametrów w procedurze składowanej
2100
Liczba parametrów w funkcji użytkownika
2100
Liczba odwołań REFERENCES w tabeli
253
Liczba wierszy w tabeli
Ograniczona dostępną ilością pamięci masowej
Liczba tabel w bazie danych
Ograniczona liczbą obiektów w bazie danych
Liczba partycji w tabelach lub indeksach podzielonych na partycje
1000
Liczba statystyk w niepoindeksowanej kolumnie
30 000
Liczba tabel w instrukcji SELECT
256
Liczba wyzwalaczy w tabeli
Ograniczona liczbą obiektów w bazie danych
Liczba połączeń użytkowników
32 767
Liczba indeksów XML
249
SQL Server Express nie korzysta z więcej niż jednego rdzenia na komputerach wielordzeniowych.
Dodatek B
Optymalizowanie aplikacji Accessa W tym dodatku:
Stosowanie funkcji ładowania na żądanie w kodzie VBA
Zwiększanie wydajności dzięki kompilacji
Przyspieszanie pracy aplikacji
Stosowanie specjalnych technik dla dużych baz danych
Kiedy firma Microsoft zaprezentowała 32-bitowy Access, wraz z nowymi właściwościami i funkcjami pojawiło się wiele nowych problemów dotyczących wydajności. Microsoft nadal podejmuje wysiłki zmierzające do poprawienia wydajności programu Access za pomocą ulepszeń w silniku bazy danych, a także technik kompilacji i takich właściwości, jak poprzednio nieudokumentowane polecenie dekompilacji. W efekcie, można powiedzieć, że Microsoft ułatwił życie użytkownikowi, ale w żaden sposób nie zdjął z niego całej odpowiedzialności. Podawane minimalne wymaganie odnośnie wielkości pamięci RAM dla komputerów, na których uruchamiany jest Access w systemach Windows XP (z dodatkiem SP2 lub nowszym), Windows Server 2003 (lub nowszym) albo Windows Vista lub Windows 7, to 256 MB — z naciskiem na słowo minimalne. Jeżeli ktoś zamierza realizować poważne projekty przy użyciu programu Access, powinien zainstalować przynajmniej 512 MB lub 1 GB pamięci RAM, a najlepiej 2 GB lub więcej. Biorąc pod uwagę obecne ceny komputerów i pamięci, taka ilość RAM-u jest korzystną inwestycją. W rzeczywistości zainstalowanie dodatkowej pamięci zwiększy szybkość znacznie bardziej niż wymiana procesora. Przyczyną tego stanu rzeczy jest fakt, że jeśli Access nie ma wystarczającej ilości pamięci, musi wykorzystywać dysk twardy jako obszar pamięci wirtualnej. Dyski twarde, a zwłaszcza duże dyski twarde są wolne — bez względu na szybkość procesora.
1066
Dodatki
Ładowanie modułu na żądanie Jedną z doskonałych właściwości języka Visual Basic for Applications (jest to główny język systemu Microsoft Access) jest ładowanie na żądanie. Wykorzystując ten mechanizm, program Access ładuje moduły kodu tylko wtedy, kiedy są potrzebne, lub wtedy, gdy następuje odwołanie do nich. W pierwszych wersjach programu Access ładowanie modułów na żądanie nie było w pełni realizowane, ponieważ załadowanie modułu powodowało załadowanie całego potencjalnego drzewa wywołań modułu (czyli wszystkich modułów obejmujących procedury, które mogą zostać wywołane przez bieżącą procedurę). W Accessie właściwość ładowania na żądanie pozwala na istotne zmniejszenie ilości wymaganej pamięci RAM i umożliwia szybsze działanie programu. Ponieważ Access nie usuwa kodu po jego załadowaniu do pamięci, w czasie projektowania warto co jakiś czas zamykać aplikację. Podczas projektowania aplikacji zwykle otwiera się wiele różnych procedur umieszczonych w wielu modułach. Pozostają one w pamięci do momentu zamknięcia Accessa, co prowadzi do spadku wydajności.
Organizowanie modułów Trzeba wiedzieć, że kiedy w aplikacji pojawia się odwołanie do dowolnej procedury lub zmiennej, do pamięci ładowany jest cały moduł zawierający tę procedurę lub zmienną. Aby zminimalizować liczbę modułów ładowanych do pamięci, procedury i zmienne należy zorganizować w logiczne moduły. Na przykład dobrym pomysłem jest umieszczenie wszystkich zmiennych globalnych w jednym module. Wystarczy, że w module jest zadeklarowana tylko jedna zmienna globalna, a i tak do pamięci ładowany jest cały moduł. Podobnie w module zawierającym zmienne globalne, powinno się umieścić tylko takie procedury, które w aplikacji wykonają się zawsze (np. procedury startowe).
Przycinanie drzewa wywołań W dalszej części rozdziału określenie procedura oznacza zarówno funkcje, jak i podprogramy.
Drzewo wywołań (ang. call tree) procedury to wszystkie funkcje lub procedury, do których odwoływała się bieżąca procedura (lub funkcja), jak również te, do których odwołują się nowo załadowane funkcje i procedury itd. Ponieważ procedura, w zależności od realizowanych przez nią działań, może odwoływać się do licznych dodatkowych procedur zapisanych w różnych modułach, ładowanie wszystkich potencjalnie wywoływanych procedur zabiera dużo czasu i pamięci. Należy pamiętać, że w czasie wywoływania procedury w pamięci umieszczany jest cały moduł, w którym ta procedura się znajduje. Tak więc drzewo potencjalnych wywołań zawiera wszystkie procedury, które mogłyby być wywołane przez bieżącą procedurę. Ponadto wszystkie procedury, które mogłyby być wywołane z tych procedur itd., są również częścią drzewa potencjalnych wywołań. Oto przykład:
Dodatek B Optymalizowanie aplikacji Accessa
1067
1. Jeżeli wywołasz Procedurę A, zostanie załadowany cały moduł zawierający Procedurę A. 2. Zostaną załadowane moduły zawierające deklaracje zmiennych wykorzystywanych przez Procedurę A. 3. Procedura A ma wiersze kodu, w których wywoływane są Procedury B i C — zostaną załadowane moduły zawierające Procedurę B i Procedurę C. Nawet jeżeli instrukcje wywołania występują w pętlach warunkowych i nigdy nie będą wykonane, moduły będą załadowane i tak, ponieważ procedury potencjalnie mogłyby być wywołane. 4. Zostaną załadowane wszystkie procedury, które mogłyby być wywołane przez Procedurę B i Procedurę C, jak również całe moduły zawierające te procedury. 5. I tak dalej… Na szczęście dla wszystkich programistów pracujących w programie Access zajęto się zagadnieniem pełnego ładowania drzewa potencjalnych wywołań. Access obecnie automatycznie kompiluje moduły na żądanie, zamiast wczytywać całe drzewo potencjalnych wywołań. Można wyłączyć ładowanie na żądanie, powodując w ten sposób, że Access będzie kompilował wszystkie moduły jednocześnie. Należy to zrobić w programie Visual Basic for Applications zamiast w programie Access. Access łączy się bezpośrednio ze środowiskiem projektowym VBA przy pracy z kodem Visual Basica.
Aby sprawdzić stan opcji kompilacji na żądanie, wykonaj następujące czynności: 1. W edytorze VBA wybierz polecenie Tools/Options. Wyświetli się okno dialogowe Options. 2. Wybierz zakładkę General. Zaznacz lub usuń zaznaczenie pola wyboru Compile on Demand. 3. Kliknij przycisk OK. W przypadku wybrania opcji Compile on Demand Access nie załaduje całego drzewa wywołań modułu, lecz tylko część drzewa wywołań wykonanej procedury. Na przykład jeżeli wywołasz procedurę A w module A, załadowane i skompilowane zostaną wszystkie moduły, które zawierają procedury, do których nastąpiło odwołanie w procedurze A. Access nie weźmie jednak pod uwagę procedur, które mogą być wywołane z innych procedur w module A, i nie będzie brał pod uwagę drzewa potencjalnych wywołań załadowanych modułów tylko dlatego, że w procedurze A nastąpiło odwołanie do jednej z zawartych w nich procedur. Ponieważ Access załaduje jedynie moduły odległe o jeden poziom od bezpośredniego drzewa wywołań wykonywanej procedury — a nie całe drzewo wywołań procedury — aplikacje powinny ładować i wykonywać się o wiele szybciej niż w poprzednich wersjach. Chociaż w Accessie poczyniono znaczne postępy w sposobie ładowania i kompilowania modułów, nadal można wykonać wiele czynności, aby zmniejszyć liczbę ładowanych i kompilowanych modułów. Na przykład nigdy nie należy umieszczać rzadko wywoły-
1068
Dodatki
wanych procedur w tym samym module, w którym umieszczono procedury wywoływane często. Czasami jednak może to spowodować, że moduły staną się mniej logiczne i trudniejsze do zrozumienia. Na przykład można zdefiniować w aplikacji wiele funkcji wykonujących różne operacje na informacjach o klientach. Funkcje te można umieścić w module modKlienci, który będzie zawierać wszystkie procedury i zmienne dotyczące klientów. Ponieważ w momencie wywołania procedury lub zawartej w niej zmiennej Access ładuje cały moduł, procedury dotyczące klientów można rozdzielić do oddzielnych modułów (jednego, w którym będą procedury wykorzystywane często, i innego, w którym będą procedury używane rzadko i do których nie następują odwołania w często wykorzystywanych procedurach). Należy pamiętać, że moduły zawierające procedury, do których następują odwołania w procedurach innego modułu, są ładowane w momencie wywołania tych procedur. Jeżeli w aplikacji dowolna z często wykorzystywanych procedur odwołuje się do procedury, która jest wykorzystywana rzadko, procedurę, która nie jest często wykorzystywana, należy umieścić w tym samym module, w którym umieszczono procedury wykorzystywane często. Ma to zapobiec załadowaniu i skompilowaniu innego modułu (zawierającego procedury wykorzystywane rzadko). W przypadku dużych ilości kodu zapisanego w wielu rzadko wykorzystywanych procedurach można nawet wykorzystać więcej niż dwa moduły. Chociaż rozdzielenie powiązanych procedur do oddzielnych modułów może spowodować, że kod stanie się trochę mniej czytelny, to jednak taka czynność może znacznie poprawić wydajność aplikacji.
Dystrybucja plików .accde Jednym ze sposobów zapewnienia przechowywania kodu aplikacji w stanie skompilowanym jest dystrybucja bazy danych w formacie.accde. Jeśli zapiszesz bazę danych w postaci pliku .accde, Access skompiluje wszystkie moduły kodu (włącznie z modułami formularzy i raportów), usunie wszystkie możliwe do edycji fragmenty i skompaktuje bazę danych. Nowy plik .accde nie zawiera kodu źródłowego, ale w dalszym ciągu działa, ponieważ zawiera skompilowaną kopię kodu. Jest to nie tylko doskonały sposób zabezpieczenia kodu źródłowego, ale także możliwość rozprowadzania baz danych o zmniejszonym rozmiarze (ponieważ nie zawierają one kodu źródłowego i zawsze utrzymują moduły w skompilowanym stanie). Ponieważ kod jest zawsze w stanie skompilowanym, aplikacja zużywa mniej pamięci i nie następuje zmniejszenie wydajności związane z kompilowaniem kodu w czasie wykonania. Poza brakiem możliwości oglądania istniejącego kodu, ponieważ jest on całkowicie skompilowany, istnieją następujące ograniczenia:
Nie można oglądać, modyfikować lub tworzyć formularzy, raportów lub modułów w widoku projektu (w plikach .accde można jednak tworzyć i modyfikować tabele i kwerendy).
Nie można dodawać, usuwać lub modyfikować odwołań do bibliotek obiektów lub baz danych.
Nie można zmieniać nazwy projektu VBA bazy danych za pomocą okna dialogowego Options.
Dodatek B Optymalizowanie aplikacji Accessa
1069
Nie można importować lub eksportować formularzy, raportów lub modułów. Należy jednak zauważyć, że tabele, kwerendy i makra mogą być importowane z lub eksportowane do baz danych o formacie innym niż .accde.
Z powodu tych ograniczeń dystrybucja określonych aplikacji w postaci pliku .accde może nie być możliwa. Na przykład jeżeli w aplikacji formularze są tworzone w czasie przetwarzania, takiej aplikacji nie można rozpowszechniać jako pliku .accde. Aby utworzyć wersję demonstracyjną aplikacji w taki sposób, by użytkownicy nie mogli oglądać kodu lub projektów formularzy i raportów, należy utworzyć plik .accde. Ponieważ projektów formularzy, raportów i wszystkich modułów kodu nie ma w pliku skompilowanym w wersji źródłowej (są zapisane jedynie w wersji skompilowanej), nie trzeba się martwić, że ktoś ukradnie albo zmodyfikuje projekty lub kod. Plik .accde sprawdza się również jako plik dystrybucji w środowiskach, gdzie nie chcesz, aby ktoś inny modyfikował projekty. Nie ma możliwości przekształcenia pliku .accde w zwykły plik bazy danych. Z tego powodu należy zawsze zapisywać i przechowywać kopię pierwotnej bazy danych. Aby dokonać zmian w aplikacji, należy otworzyć bazę danych w zwykłym formacie, a następnie, przed dystrybucją, utworzyć nowy plik .accde. W przypadku usunięcia pierwotnej bazy danych nie można uzyskać dostępu do żadnego z obiektów w widoku projektu.
Aby utworzyć plik .accde, wykonaj następujące czynności: 1. Zapisz i zamknij wszystkie obiekty bazy danych. Jeżeli nie zamknie się tych obiektów, Access spróbuje zamknąć je sam, zachęcając do zapisania zmian tam, gdzie występuje taka potrzeba. W przypadku współdzielonej bazy danych, muszą ją zamknąć wszyscy użytkownicy. Do pracy z bazą danych Access wymaga uprawnień wyłączności. Ponieważ Access nie może przekształcić aplikacji na plik .accde, jeśli nie można jej skomplikować, to warto najpierw przeprowadzić kompilację.
2. Wybierz polecenie PLIK/Zapisz jako/Utwórz plik ACCDE. Wyświetli się okno dialogowe Zapisz jako. 3. Określ nazwę, napęd i folder bazy danych. Nie zapisuj pliku .accde z taką samą nazwą pliku jak pierwotna baza danych (uwzględniając rozszerzenie). Nie należy usuwać, ani zastępować pierwotnej bazy danych. Nie istnieje sposób przekształcania pliku .accde na zwykłą bazę danych, a w pliku .accde nie można modyfikować obiektów. Jeżeli ktoś usunie lub w inny sposób utraci pierwotną bazę danych, nigdy nie będzie ponownie w stanie uzyskać dostępu do obiektów w widoku projektu. Plik .accde można utworzyć tylko wtedy, kiedy najpierw przekształci się bazę danych na format .accdb Accessa. Jeśli plik jest w formacie Accessa 2002 – 2003, można utworzyć plik .mde — odpowiednik pliku .accde dla wersji Accessa 2002 – 2003.
1070
Dodatki
Czym jest stan skompilowany? Zrozumienie przebiegu kompilacji na żądanie ma podstawowe znaczenie dla osiągnięcia maksymalnej wydajności aplikacji Accessa. Jednak równie ważne jest poznanie pojęcia kompilacji i znaczenia pojęcia „stan skompilowany”. W programie Access istnieją dwa rodzaje kodu — kod, który pisze programista, oraz kod, który Access może zrozumieć i wykonać. Zanim procedura VBA, którą napisze programista, będzie mogła być wykonana, kod musi przejść przez kompilator, który wygeneruje kod w postaci, którą Access będzie w stanie zinterpretować — kod skompilowany. W Accessie nie istnieje rzeczywisty kompilator. Zamiast niego wykorzystywany jest częściowo skompilowany kod i interpreter. Rzeczywisty kompilator przekształca kod źródłowy na instrukcje kodu maszynowego, które są wykonywane przez procesor komputera. Access przekształca kod źródłowy na formę pośrednią, którą może bardzo szybko zinterpretować i wykonać. Kod w przekształconej formie określa się jako kod skompilowany. W przypadku wywołania procedury, która nie jest w stanie skompilowanym, najpierw musi zostać ona skompilowana, a następnie skompilowany kod jest przekazywany do interpretera w celu wykonania. W rzeczywistości, jak stwierdzono poprzednio, nie dzieje się to na poziomie procedury, ale na poziomie modułu. W momencie wywołania procedury jest ładowany i kompilowany moduł zawierający tę procedurę oraz wszystkie moduły zawierające procedury, do których wywoływana procedura się odwołuje. Kod można skompilować ręcznie lub można wykorzystać Accessa, który zrobi to „w locie”. Kompilowanie kodu zabiera czas, jeżeli więc zlecisz Accessowi kompilację „w locie”, zmniejszy się wydajność aplikacji. Oprócz tego, że kompilowanie kodu w czasie jego wykonywania zajmuje czas, nieskompilowane programy zajmują znacznie więcej pamięci niż kod skompilowany. W przypadku całkowitego skompilowania kodu aplikacji w momencie wywołania procedury do pamięci ładowany jest tylko skompilowany kod. Jeśli aplikacji znajduje się w stanie nieskompilowanym, Access ładuje nieskompilowany kod i generuje kod skompilowany. Po kompilacji kod nieskompilowany nie jest usuwany z pamięci, zatem w pamięci znajdują się dwie wersje tego samego kodu. Nawet w komputerach z dużą ilością zainstalowanej pamięci załadowanie zarówno skompilowanej, jak i nieskompilowanej wersji modułów zajmuje więcej czasu w porównaniu z załadowaniem tylko wersji skompilowanej. Aplikacje skompilowane mają jedną wadę — zajmują więcej pamięci na dysku twardym niż ich wersje nieskompilowane. Dzieje się tak, ponieważ na dysku twardym są zapisywane obydwie wersje: skompilowana i nieskompilowana. Miejsce na dysku twardym nie powinno stanowić zbyt wielkiego problemu, ale w przypadku aplikacji o bardzo dużej ilości kodu można zaoszczędzić przestrzeń dyskową poprzez utrzymywanie tej aplikacji w stanie nieskompilowanym. Należy pamiętać, że trzeba wybrać kompromis pomiędzy wykorzystywaną przestrzenią na dysku, a wydajnością bazy danych. Z reguły użytkownicy decydują się na poświęcenie kilku megabajtów, aby w zamian uzyskać szybciej działającą aplikację.
Dodatek B Optymalizowanie aplikacji Accessa
1071
Opisaną wyżej technikę oszczędzania miejsca na dysku można stosować przy udostępnianiu dużej aplikacji, której odbiorcy mają pełną wersję programu Access wraz z dodatkami programisty. Dzięki dystrybucji wersji nieskompilowanych potrzeba znacznie mniej miejsca na dysku twardym, a odbiorcy mogą skompilować aplikacje samodzielnie. W takiej sytuacji należy pozostawić całą aplikację w stanie nieskompilowanym. Zagadnienie pełnej dekompilacji aplikacji zostało omówione w dalszej części tego rozdziału w ramce „Sześć kroków wiodących do sukcesu przy pracy z dużą bazą danych”.
Przekształcenie kodu aplikacji na postać skompilowaną Jest tylko jeden sposób przekształcenia całej aplikacji na postać skompilowaną — należy zastosować polecenie menu Debug/Compile [nazwa bazy danych] z paska narzędzi Modules w oknie edytora VBA. Aby uzyskać dostęp do menu Debug, trzeba otworzyć moduł. Aby zagwarantować zapisanie całego kodu w stanie skompilowanym, należy zawsze stosować polecenie Compile [nazwa bazy danych]. Kompilowanie złożonych aplikacji może zabrać dużo czasu i z reguły kompilację projektów należy wykonywać tylko przed dystrybucją aplikacji lub przed wykonaniem testów wydajności. Kiedy stosujesz opcję Debug/Compile [nazwa bazy danych], w menu wyświetla się nazwa projektu. Jest to nazwa, której użyto do zapisania pliku bazy danych za pierwszym razem, kiedy była ona tworzona lub zapisywana. Jeżeli później zmienisz nazwę pliku bazy danych, nazwa projektu nie ulegnie zmianie. Można ją zmienić za pomocą opcji Tools/Properties w oknie projektu modułu. W oknie dialogowym Properties bazy danych znajduje się ustawienie z nazwą bazy.
Utrata stanu skompilowanego Jedną z największych przeszkód w zwiększeniu wydajności aplikacji programu Access był fakt, że aplikacja mogła zostać bardzo łatwo zdekompilowana. Kiedy aplikacja programu Access była w stanie nieskompilowanym, występowała konieczność ciągłej kompilacji kodu w momencie jego wywoływania. W rzeczywistości w poprzednich wersjach programu Access można było tak łatwo utracić stan skompilowany, że programiści często czynili to, nie zdając sobie z tego sprawy. W Accessie 2013 w stan nieskompilowany są ustawiane tylko te fragmenty kodu, w których dokonano zmian — nie cała aplikacja. Następujące działania spowodują, że fragmenty kodu staną się nieskompilowane:
zapisanie zmodyfikowanego formularza, raportu, formantu lub modułu (jeżeli nie zapiszesz zmodyfikowanego obiektu, aplikacja będzie zachowana w jej poprzednim stanie);
dodanie nowego formularza, raportu, formantu lub modułu (łącznie z dodaniem nowego kodu obsługi formularza lub raportu);
usunięcie lub zmiana nazwy formularza, raportu, formantu lub modułu;
dodanie lub usunięcie odwołania do biblioteki obiektów lub bazy danych poprzez zastosowanie polecenia References z menu Tools.
1072
Dodatki
Jeżeli ktoś uważa, że to, co napisaliśmy powyżej, wystarczy, aby odpowiednio postępować z kodem, który traci swój stan skompilowany — myli się. Poniżej przedstawiono kilka dodatkowych spraw, które należy wziąć pod uwagę:
Jeżeli za pomocą kodu VBA zmodyfikujesz obiekty (np. raporty lub formularze) w czasie wykonywania programu, fragmenty aplikacji zostaną ustawione w stan nieskompilowany (często tak działają kreatory).
Jeżeli aplikacja tworzy obiekty takie jak raporty lub formularze „w locie”, fragmenty aplikacji zostaną ustawione w stan nieskompilowany (takie działanie również jest typowe dla kreatorów). Jeżeli zmienisz nazwę projektu (nie nazwę pliku), cała aplikacja straci swój stan skompilowany. Z tego powodu nazwę projektu należy zmieniać tylko wtedy, kiedy jest to absolutnie konieczne. Natychmiast po wykonaniu tej czynności należy ponownie skompilować bazę danych.
Poprawianie szybkości działania aplikacji Przy omawianiu wydajności aplikacji słowo wydajność jest zwykle utożsamiane z szybkością działania. Chodzi tu o szybkość, z jaką aplikacja wykonuje funkcje, np. przetwarza pewną kwerendę. Niektóre oczywiste czynniki zwiększenia szybkości bezwzględnej przedstawiono poniżej:
Utrzymywanie aplikacji w stanie skompilowanym. W punkcie „Dystrybucja plików .accde” można przeczytać, że przekształcenie pliku .accdb na format .accde to dobry sposób, by się upewnić, że kod zawsze znajduje się w stanie skompilowanym.
Organizowanie procedur w „inteligentne” moduły. W punkcie „Ładowanie modułu na żądanie” wyjaśniamy, że dobrym pomysłem jest rozmieszczenie procedur w modułach na podstawie częstości wywoływania poszczególnych procedur.
Regularne scalanie (kompaktowanie) baz danych. Często pomijanym sposobem maksymalizacji wydajności bazy danych jest jej regularne scalanie (nazywane również kompaktowaniem). Kiedy rekordy są usuwane z bazy danych, przestrzeń na dysku twardym, w której przechowywano usunięte dane, nie zostanie odzyskana, dopóki baza nie zostanie scalona. Ponadto w miarę modyfikowania danych baza ulega fragmentacji. Scalenie bazy danych powoduje jej defragmentację i umożliwia odzyskanie miejsca na dysku.
Wszystkie te metody są doskonałymi (i koniecznymi) sposobami pomagającymi utrzymać wydajność aplikacji na optymalnym poziomie, ale nie są to jedyne zadania, które można wykonać, aby zwiększyć bezwzględną szybkość aplikacji. Aby zapewnić aplikacji maksymalną szybkość bezwzględną, można zoptymalizować prawie każdy obszar projektowania — od formularzy do modułów.
Dodatek B Optymalizowanie aplikacji Accessa
1073
Dostrajanie systemu Jeden z ważnych aspektów wydajności nie ma nic wspólnego z projektem aplikacji. Znaczenie ma tu komputer, na którym działa aplikacja. Chociaż niemożliwe jest wzięcie pod uwagę wszystkich możliwych konfiguracji, które mogą mieć komputery klientów, to jednak należy przetestować określone ustawienia na własnym komputerze i polecić je użytkownikom:
Zainstaluj w komputerze jak najwięcej pamięci RAM. Czynność ta często jest kwestią pieniędzy. Po zakupie wystarczy zainstalować pamięć. Jednak ceny pamięci RAM ciągle spadają, a dodanie pamięci RAM do komputera jest jedną z najbardziej efektywnych metod zwiększenia szybkości działania Accessa.
Zamknij wszystkie aplikacje, które nie są aktualnie używane. W systemie Windows bardzo wygodne jest utrzymywanie dowolnej liczby otwartych aplikacji, które są używane od czasu do czasu. Chociaż w systemach Windows XP, Windows Vista i Windows 7 obsługa pamięci dla wielu otwartych aplikacji jest dość zaawansowana, to jednak każda działająca aplikacja zużywa zasoby komputera.
Upewnij się, że plik wymiany systemu Windows znajduje się na szybkim dysku z dużą ilością wolnego miejsca. Jeżeli jest to możliwe, powinieneś ustawić minimalną ilość miejsca na dysku twardym dostępną dla pamięci wirtualnej na wartość równą przynajmniej dwukrotnej ilości zainstalowanej pamięci RAM i uczynić ją stałym plikiem wymiany.
Często defragmentuj dysk twardy. Defragmentacja dysku pozwala na pobieranie danych z dysku w większych porcjach, co przyczynia się do zmniejszenia liczby bezpośrednich odczytów i operacji ustawiania pozycji głowic odczytu.
Optymalne wykorzystanie tabel Oprócz przeglądu wszystkich kwestii technicznych omówionych powyżej warto poświęcić trochę uwagi podstawom projektowania aplikacji. Takie narzędzia jak Access pozwalają nowicjuszom szybko i łatwo tworzyć relacyjne bazy danych, ale nie uczą ich dobrych technik projektowania baz danych. Wyjątkiem jest Kreator analizatora tabel. Aby uruchomić Kreatora analizatora tabel, należy kliknąć polecenie Analizuj tabelę w grupie Analiza w zakładce NARZĘDZIA BAZY DANYCH. Chociaż sugestie kreatora analizatora tabel są często przydatne w nauce dobrych technik projektowania, jego zalecenia nie powinny nigdy być traktowane bezwzględnie. W wielu sytuacjach okazało się, że analizator tabel nie miał racji.
Tematyce teorii baz danych poświęcono całe książki. Nauczanie tej teorii z całą pewnością wykracza poza zakres tego rozdziału (lub nawet tej książki). Warto jednak poznać kilka podstawowych zasad dobrego projektowania baz danych. Tworzenie wydajnych indeksów Indeksy w programie Access pomagają wyszukiwać i porządkować rekordy szybciej i bardziej efektywnie. Aby znaleźć dane, Access poszukuje lokalizacji danych w indeksie, a następnie pobiera dane z tej lokalizacji. Indeksy można tworzyć na podstawie jednego
1074
Dodatki
albo wielu pól. Indeksy utworzone na podstawie wielu pól pozwalają rozróżniać rekordy, w których pierwsze pole może mieć taką samą wartość. Jeżeli indeksy utworzone na podstawie wielu pól są właściwie zdefiniowane, to mogą być używane przez optymalizację kwerendy Rushmore’a Microsoftu, która jest technologią wykorzystywaną przez silnik ACE do optymalizacji szybkości wykonywania kwerend obsługującą indeksy oparte na wielu polach. Więcej o indeksach dowiesz się z rozdziałów 3. i 4.
Decydowanie, które pola indeksować Programiści zaczynający projektowanie baz danych zazwyczaj popełniają dwa błędy: pierwszy, bo nie stosują indeksów, i drugi, bo stosują zbyt wiele indeksów (nieraz ustawiając je dla każdego pola w tabeli). Obydwa błędy są poważne — czasami tabela ze zdefiniowanymi indeksami w każdym polu może mieć mniejszą wydajność niż tabela bez indeksów. Dlaczego? W czasie zapisywania rekordu Access musi zapisać także pozycję dla każdego zdefiniowanego indeksu. Zabiera to czas i zajmuje znaczną ilość miejsca na dysku twardym. Wykorzystywany czas jest zazwyczaj niezauważany w przypadku kilku indeksów, ale przy wielu indeksach czas aktualizowania rekordów może być bardzo długi. Ponadto indeksy mogą spowolnić niektóre kwerendy funkcjonalne (np. kwerendy dołączające), kiedy przy wykonywaniu kwerendy muszą zostać uaktualnione indeksy dla wielu pól. Kiedy tworzysz klucz główny tabeli, pole (lub pola) używane do zdefiniowania klucza są indeksowane automatycznie. Dodatkowo można zaindeksować dowolne pole, o ile jego typem danych nie jest Długi tekst lub Obiekt OLE. Indeksowanie pola należy rozważyć w przypadku, gdy są spełnione wszystkie poniższe warunki:
Typem danych pola jest Krótki tekst, Liczba lub Data/Godzina.
Przewidujesz wyszukiwanie wartości zapisanych w tym polu.
Przewidujesz sortowanie rekordów na podstawie wartości umieszczonych w tym polu.
Przyłączasz pole do pól w innych tabelach w kwerendach.
Przewidujesz zapisywanie wielu różnych wartości w polu (jeżeli wiele rekordów będzie miało taką samą wartość w polu, indeks nie przyśpieszy znacząco wyszukiwania lub sortowania).
Definiując indeks, można utworzyć go jako rosnący (ustawienie domyślne) lub malejący. Indeks malejący jest przydatny dla pól przechowujących na przykład daty. Dzięki temu późniejsze daty pojawiają się na początku wyników kwerendy. Stosowanie indeksów opartych na wielu polach Jeżeli często wyszukujesz lub sortujesz dane według wielu pól jednocześnie, możesz utworzyć indeks dla takiej kombinacji pól. Na przykład jeżeli często ustawiasz kryteria dla pól Nazwisko i Imię w tej samej kwerendzie, warto utworzyć indeks na podstawie obydwu tych pól.
Dodatek B Optymalizowanie aplikacji Accessa
1075
Podczas sortowania tabeli według indeksu utworzonego na podstawie wielu pól Access najpierw sortuje według pierwszego pola zdefiniowanego dla indeksu. Jeżeli pierwsze pole zawiera rekordy z takimi samymi wartościami, Access następnie sortuje według drugiego pola zdefiniowanego dla indeksu itd. Tworzy to efekt zagłębiania się. Aby indeks z wieloma polami działał, musi być zdefiniowane kryterium wyszukiwania dla pierwszego pola w indeksie, ale nie dla pól dodatkowych. W poprzednim przykładzie w przypadku wyszukiwania kogoś o nazwisku Kowalski bez podania imienia drugie pole w indeksie nie zostałoby wykorzystane. Aby przeprowadzić wyszukiwanie na podstawie poszczególnych pól z indeksu obejmującego wiele pól, należy dodatkowo utworzyć indeks dla każdego pola (oprócz indeksu dla wielu pól). Nie trzeba tworzyć dodatkowego indeksu dla pierwszego pola z indeksu obejmującego wiele pól. Na przykład jeśli istnieje już indeks dla kombinacji pól Nazwisko i Imię, nie trzeba tworzyć nowego indeksu dla samego pola Nazwisko.
Optymalne wykorzystanie kwerend Problemy z wydajnością wielu aplikacji Accessa wynikają z projektowania kwerend. Wszystkie aplikacje bazy danych opierają się na przeglądaniu danych i pracy z danymi, a kwerendy są najważniejszym elementem określającym wyświetlane i używane dane. Kwerendy są używane do łączenia danych z tabel z formularzami i raportami, wypełniania pól list i pól kombi, tworzenia nowych tabel i wielu innych funkcji w ramach aplikacji Accessa. Ponieważ są one tak powszechnie używane, ich optymalizacja jest niezwykle ważna. Kwerenda, która jest właściwie zaprojektowana, może dostarczać wyników kilka minut, a nawet godzin szybciej niż źle zaprojektowana kwerenda zwracająca taki sam zbiór wyników. Projektując kwerendy, należy wziąć pod uwagę następujące zagadnienia:
Projektując kwerendy i tabele, należy tworzyć indeksy dla wszystkich pól, które są wykorzystywane w sortowaniu, złączeniach i polach kryteriów. Indeksy umożliwiają silnikowi ACE szybkie sortowanie i wyszukiwanie w bazie danych.
Tworząc złączenia należy (kiedy tylko jest to możliwe) stosować klucz główny zamiast zwykłego indeksu. W polach kluczy głównych nie są dozwolone wartości null, ponadto w przypadku wykorzystania kluczy głównych optymalizator kwerend ma więcej możliwości wykorzystania złączeń.
Należy ograniczyć kolumny danych zwracane w kwerendzie wybierającej tylko do tych, które są potrzebne. Jeżeli informacje z pola nie są potrzebne, nie należy zwracać go w kwerendzie. Kwerendy działają znacznie szybciej, kiedy zwracają mniej informacji. Jeżeli trzeba użyć pola w warunku kwerendy i jeżeli nie jest konieczne wyświetlenie pola w tabeli wynikowej, należy usunąć zaznaczenie pola wyboru Pokaż, aby uniknąć wyświetlania pola i jego zawartości.
Aby uzyskać liczbę rekordów zwróconą przez instrukcję SQL-a, należy skorzystać z instrukcji Policz(*) zamiast Policz([Nazwa pola]), ponieważ wykonanie funkcji Policz(*) jest znacznie szybsze. Instrukcja Policz(*) zlicza rekordy, które zawierają puste pola; instrukcja Policz([NazwaPola]) sprawdza
1076
Dodatki
występowanie wartości null i sprawia, że nie są one brane pod uwagę. Jeżeli określisz nazwę pola zamiast gwiazdki, instrukcja Policz nie policzy rekordów, które mają wartość null w określonym polu. Nazwę pola w instrukcji Policz można zastąpić wyrażeniem, ale to jeszcze bardziej spowalnia działanie.
Należy unikać używania pól obliczeniowych w zagnieżdżonych kwerendach. Pola obliczeniowe w kwerendzie podrzędnej znacznie spowalniają kwerendę wyższego poziomu. Pól obliczeniowych można używać tylko w kwerendach najwyższego poziomu i tylko wtedy, kiedy jest to konieczne.
Aby pogrupować rekordy według wartości pola użytej w złączeniu, należy określić opcję Grupuj według dla pola, które występuje w tej samej tabeli, dla której obliczasz podsumowanie. Można przeciągnąć pole z drugiej tabeli występującej w złączeniu, ale zastosowanie opcji Grupuj według dla pola z tabeli, którą podsumowujesz, daje lepsze wyniki.
Funkcje agregujące domeny, takie jak DLookup lub DCount, które są używane jako wyrażenia w kwerendach, znacząco je spowalniają. Zamiast tego, aby zwrócić potrzebne informacje, lepiej dodać tabelę do kwerendy lub użyć podkwerendy.
Kwerendy (podobnie jak moduły kodu VBA) są kompilowane. Aby skompilować kwerendę, optymalizator kwerendy ocenia kwerendę, by określić najszybszy sposób jej wykonania. Jeżeli kwerenda jest zapisana w stanie skompilowanym, działa z najwyższą szybkością już za pierwszym razem, kiedy się ją wykonuje. Jeżeli nie jest skompilowana, to kiedy wykonuje się pierwszy raz, trwa to dłużej, ponieważ musi zostać skompilowana, ale w kolejnych wykonaniach działa szybciej. Aby skompilować kwerendę, należy ją uruchomić poprzez otwarcie w widoku arkusza danych, a następnie zamknąć bez zapisywania. W przypadku wprowadzania zmian w definicji kwerendy należy uruchomić kwerendę ponownie po zapisaniu zmian, a następnie zamknąć bez zapisywania.
Aby optymalnie wykorzystać kwerendy, należy poeksperymentować poprzez tworzenie kwerend na różne sposoby (np. definiowanie różnych typów złączeń). Wyniki mogą się zmieniać w zaskakujący sposób.
Optymalne wykorzystanie formularzy i raportów Formularze i raporty mogą spowolnić aplikację, zabierając dużo czasu na załadowanie lub przetworzenie informacji. Istnieje wiele sposobów zwiększenia wydajności formularzy i raportów. Minimalizacja złożoności i rozmiarów formularzy i raportów Jednym z kluczowych elementów osiągnięcia lepszej wydajności formularzy i raportów jest ograniczenie ich złożoności i rozmiaru. Aby ograniczyć złożoność i rozmiar formularzy i raportów warto wypróbować następujące metody:
Zminimalizuj liczbę obiektów na formularzu lub raporcie. Im mniej używanych obiektów, tym mniej zasobów potrzebnych do wyświetlenia i przetworzenia formularza lub raportu.
Dodatek B Optymalizowanie aplikacji Accessa
1077
Ogranicz użycie podformularzy. W przypadku użycia podformularza w pamięci są dwa formularze — formularz nadrzędny i podformularz. Kiedy tylko jest to możliwe, zamiast podformularzy należy używać pól listy oraz pól kombi.
Dla pól ukrytych używaj etykiet zamiast pól tekstowych, ponieważ pola tekstowe zużywają więcej zasobów niż etykiety. Pola ukryte są często używane jako alternatywa do tworzenia zmiennych do przechowywania informacji. Pamiętaj jednak, że etykiet nie można używać jako parametrów w kwerendach. W etykiecie (w odróżnieniu od pola tekstowego) nie można bezpośrednio zapisywać wartości, ale można ją zapisać w tytule etykiety za pomocą kodu VBA, na przykład: Etykieta1.Caption = "MojaWartość".
Przenieś część kodu z modułu formularza do modułu standardowego. Dzięki temu formularz ładuje się szybciej, ponieważ nie ma konieczności ładowania kodu do pamięci. Jeżeli podczas ładowania (np. w zdarzeniu Przy ładowaniu formularza) formularza wystąpi odwołanie do procedur, które przeniesiono do modułu standardowego, przeniesienie procedur nie pomoże, ponieważ będą one i tak ładowane jako część drzewa potencjalnych wywołań wykonanej procedury.
Unikaj nakładania się formantów w formularzu lub raporcie.
Umieść powiązane grupy formantów na stronach formularza. Jeżeli tylko jedna strona jest pokazana w danej chwili, Access nie musi generować wszystkich formantów jednocześnie.
Jako źródła rekordów formularza lub raportu zamiast używania tabeli lub podstawowej kwerendy, która wykorzystuje tabele, używaj kwerend, które zwracają ograniczony zbiór wyników. Im mniej danych zwracanych dla źródła rekordów, tym szybciej ładuje się formularz lub raport. Ponadto zwracaj tylko te pola, które są faktycznie wykorzystywane przez formularz lub raport. Nie stosuj kwerendy z polami, które nie będą wyświetlane na formularzu lub w raporcie (z wyjątkiem sprawdzania warunkowego).
Przyspieszanie działania pól listy i pól kombi Ważnym elementem optymalizacji jest usprawnienie działania pól listy i pól kombi. Można podjąć wiele kroków pozwalających na przyspieszenie działania tych formantów:
W przypadku korzystania z formularzy wielostronicowych (lub z zakładkami), które zawierają pola listy i pola kombi na więcej niż jednej stronie, nie należy ustawiać właściwości Źródło wiersza pól listy i pól kombi, dopóki strona zawierająca dany formant nie zostanie wyświetlona.
Warto zaindeksować pierwsze pole wyświetlone w polu listy lub polu kombi. Pozwala to Accessowi znacznie szybciej znaleźć pozycje pasujące do tekstu wprowadzonego przez użytkownika.
Chociaż nie zawsze jest to praktyczne, czasami warto powstrzymać się od ukrywania powiązanej kolumny pola kombi. Ukrywanie powiązanej kolumny powoduje znaczne spowolnienie mechanizmu wyszukiwania stosowanego w formancie.
1078
Dodatki
Jeżeli nie są potrzebne możliwości wyszukiwania zapewniane przez właściwość Autorozwijanie, należy ustawić właściwość Autorozwijanie pola kombi na Nie. W takim przypadku Access nie musi nieustannie przeszukiwać listy w celu znalezienia pozycji pasujących do tekstu wprowadzonego w części tekstowej pola kombi.
Kiedy jest to możliwe, należy spowodować, aby pierwsza nieukryta kolumna pola kombi lub listy miała tekstowy, a nie numeryczny typ danych. Aby znaleźć dopasowanie na liście pola kombi lub pola listy, Access musi przekształcić wartość numeryczną na tekstową w celu dopasowania danych znak po znaku. Jeżeli dane są typu tekstowego, Access może pominąć etap konwersji.
Często zapomina się o możliwości zwiększenia wydajności poprzez zastosowanie zapisanych kwerend dla właściwości Źródło rekordów i Źródło wiersza pól listy i pól kombi. Zapisana kwerenda ma znacznie lepszą wydajność niż instrukcja SQL-a SELECT, ponieważ kwerenda SQL-a jest optymalizowana „w locie”.
Optymalne wykorzystanie modułów Jednym z obszarów, w których często można wykorzystać efektywne techniki optymalizacji, są moduły. Na przykład w kodzie związanym z formularzami należy stosować słowo kluczowe Me przy odwoływaniu się do formantów. To podejście daje korzyść związaną z możliwościami programu Access; używanie Me jest szybsze niż tworzenie zmiennej formularza i odwoływanie się do formularza w zmiennej. Innymi technikami optymalizacji są efektywne praktyki kodowania, które są znane od wielu lat. Zawsze należy próbować wykorzystywać techniki optymalnego kodowania. W przypadku wątpliwości warto spróbować innych metod realizacji zadania i przekonać się, która jest najszybsza. Tam, gdzie jest to możliwe, warto ograniczyć liczbę modułów i procedur w aplikacji poprzez ich konsolidację. Użycie każdego modułu i procedury zajmuje pamięć, zatem ich konsolidacja może zwolnić trochę pamięci. Jednak w trakcie konsolidowania należy pamiętać o uwagach z punktu „Ładowanie modułu na żądanie”.
Stosowanie odpowiednich typów danych Należy zawsze jawnie deklarować zmienne, używając funkcji Dim, zamiast przypisywać dowolne wartości do zmiennych, które nie zostały zadeklarowane za pomocą tej funkcji. Aby się upewnić, że wszystkie zmienne w aplikacji przed użyciem w procedurze zostały jawnie zadeklarowane, należy w edytorze VBA wybrać polecenie Tools/Options, wybrać zakładkę Editor, a następnie włączyć opcję Require Variable Declaration. Jeśli zapomnisz włączyć opcję Require Variable Declaration przed rozpoczęciem pisania kodu, będziesz musiał dodać wiersz Option Explicit na początku każdego istniejącego modułu. Tam, gdzie to jest możliwe, należy stosować wartości typu integer i long integer zamiast single i double. Dane typu integer i long integer wykorzystują mniej pamięci i ich przetwarzanie zajmuje mniej czasu niż dla danych typu single i double. W tabeli B.1 pokazano względną szybkość różnych typów danych dostępnych w Accessie.
Dodatek B Optymalizowanie aplikacji Accessa
1079
Tabela B.1. Typy danych i ich szybkość w operacjach matematycznych Typ danych
Względna szybkość przetwarzania
Integer/Long
Najszybszy
Single/Double
Drugi pod względem szybkości
Currency
Trzeci pod względem szybkości
Variant
Najwolniejszy
Ponadto oprócz używania kiedy jest to możliwe typów integer i long integer, należy tam, gdzie się da, posługiwać się arytmetyką liczb całkowitych zamiast arytmetyką zmiennoprzecinkową. Na przykład aby podzielić liczbę typu long integer przez drugą liczbę typu long integer, można zastosować następującą instrukcję: x = Long1 / Long2
Instrukcja ta jest standardową funkcją matematyczną, która wykorzystuje arytmetykę zmiennoprzecinkową. Można wykonać tę samą funkcję, stosując arytmetykę liczb całkowitych (warto zauważyć, że znakiem działania matematycznego jest tu prawy ukośnik zamiast lewego ukośnika): x = Long1 \ Long2
Oczywiście arytmetyka liczb całkowitych nie zawsze jest możliwa do zastosowania. Jednakże jest ona powszechnie stosowana, kiedy zwracany jest procent. Na przykład można zwrócić procent za pomocą następującego wyrażenia: x = Suma / Wartość
Tę samą funkcję można wykonać, stosując arytmetykę liczb całkowitych, najpierw mnożąc wartość Suma przez 100, a następnie stosując arytmetykę liczb całkowitych, w następujący sposób: x = (Suma * 100) \ Wartość
Tam, gdzie to możliwe, należy również stosować funkcje znakowe ($). Podczas wykonywania działań ze zmiennymi typu String należy stosować funkcje znakowe (np. Str$()) zamiast ich odpowiednika — funkcji dla danych typu variant (Str()). W przypadku korzystania z danych typu Variant należy stosować funkcje nieznakowe (bez znaku $). Używanie funkcji znakowych przy pracy z łańcuchami znaków jest szybsze, ponieważ Access nie musi wykonywać konwersji typu dla zmiennych. Aby zwrócić podłańcuch znaków, stosując funkcję Mid$(), można opuścić trzeci parametr, aby otrzymać cały podłańcuch od określonego znaku do końca łańcucha. Na przykład aby zwrócić podłańcuch, który zaczyna się od drugiego znaku łańcucha i obejmuje wszystkie pozostałe znaki, należy zastosować następującą instrukcję: strReturn = Mid$(strMyString, 2)
Podczas korzystania z tablic należy używać tablic dynamicznych oraz stosować instrukcje Erase i ReDim, aby odzyskać pamięć. Poprzez dynamiczne dopasowywanie rozmiaru tablic można zyskać pewność, że dla tablicy przydzielono tylko tyle pamięci, ile potrzeba.
1080
Dodatki Tam, gdzie jest to możliwe, oprócz stosowania zoptymalizowanych zmiennych warto rozważyć używanie stałych. Dzięki zastosowaniu stałych kod będzie czytelniejszy. Ponadto zastosowanie stałych nie spowoduje spowolnienia aplikacji.
Pisanie szybszych procedur Jest wiele sposobów przyspieszania procedur poprzez zoptymalizowanie podprogramów, które zawierają. Jeżeli podczas projektowania pamiętasz o wydajności, z pewnością natrafisz na sytuacje opisane poniżej i wykorzystasz opisane techniki. Niektóre funkcje programu Access wykonują podobne zadania, ale różnią się znacznie szybkością. Wiele osób regularnie wykorzystuje jedną lub więcej takich funkcji. Znajomość najbardziej efektywnego sposobu wykonania tych operacji może znacznie wpłynąć na szybkość działania aplikacji:
Funkcja IIF() jest znacznie wolniejsza niż zestaw instrukcji If/Then/Else.
Zastosowanie funkcji With i For Each pozwala na przyspieszenie wykonywania działań z wieloma obiektami i ich właściwościami.
Zmienne lepiej modyfikować za pomocą instrukcji Not zamiast instrukcji If...Then (na przykład lepiej użyć instrukcji x = Not(y) zamiast If y = true then x = false).
Zamiast porównywania zmiennej z wartością True, lepiej wykorzystać wartość zmiennej (na przykład zamiast pisania If X = true then..., korzystniej jest napisać If X then...).
Lepiej wykorzystać metodę Requery zamiast akcji Requery. Metoda jest znacznie szybsza niż akcja. Na przykład akcja DoCmd.Requery "txtField" jest wolniejsza od metody Me.txtField.Requery.
Zmienne odpowiadające formantom
Przy wskazywaniu formantów z formularza w kodzie istnieją pewne bardzo wolne i pewne bardzo szybkie techniki. Najwolniejszym możliwym sposobem jest jawne wskazywanie każdego formantu. W takim przypadku następuje sekwencyjne wyszukiwanie przez Access nazwy formantu w formularzu. Oto przykład: Forms![frmSales]![SaleDate] = coś Forms![frmSales]![InvoiceDate] = coś Forms![frmSales]![SalespersonID] = coś
Jeżeli kod znajduje się w module formularza frmSales, można zastosować odwołanie Me. Odwołanie to zastępuje zapis Forms![nazwa_formularza]. Jest to znacznie szybsza metoda, ponieważ pozwala przejść od razu do formularza: Me![SaleDate] = coś Me![InvoiceDate] = coś Me![SalespersonID] = coś
Jeżeli kod nie jest zapisany w module klasy formularza, ale w procedurze modułu, można wykorzystać zmienną formantu w następujący sposób:
Dodatek B Optymalizowanie aplikacji Accessa
1081
Dim frm as Form set frm = Forms![frmSales] frm![SaleDate] = coś frm![InvoiceDate] = coś frm![SalespersonID] = coś
W ten sposób nazwa formularza jest wyszukiwana tylko raz. Jeszcze szybszym sposobem jest zastosowanie konstrukcji With, np.: With Forms![frmSales] ![SaleDate] = coś ![InvoiceDate] = coś ![SalespersonID] = coś End With
Można też wykorzystać wskaźnik Me, aby odrobinę zwiększyć wydajność: With Me ![SaleDate] = coś ![InvoiceDate] = coś ![SalespersonID] = coś End With
Wykorzystywanie zmiennych pól
Poprzednia technika znajduje zastosowanie również w kontekście manipulowania danymi pola przy pracy z danymi typu Recordset w kodzie VBA. Na przykład można zdefiniować pętlę, która wykonuje poniższą operację: ... Do Until tbl.EOF MyTotal = MyTotal + tbl![OrderTotal] tbl.MoveNext Loop
Jeżeli pętla ta działa dla wielu rekordów, należy użyć zamiast tego następującego fragmentu kodu: Dim MyField as Field ... Set MyField = tbl![OrderTotal] Do Until tbl.EOF MyTotal = MyTotal + MyField tbl.MoveNext Loop
Ten kod wykonuje się znacznie szybciej niż kod, który jawnie wskazuje pole w każdym powtórzeniu pętli. Zwiększenie szybkości znajdowania danych w kodzie
Dla zaindeksowanych pól można wykorzystać metody FindRecord i FindNext. Metody te są znacznie wydajniejsze, kiedy są stosowane dla zaindeksowanych pól. Kiedy jest to możliwe, warto również korzystać z zakładek. Powrót do zakładki jest znacznie szybszy niż zastosowanie metody Find do zlokalizowania danych.
1082
Dodatki
Procedura pokazana na listingu B.1 jest przykładem wykorzystania zakładki. Zmienna zakładki zawsze musi być zadeklarowana jako zmienna typu variant. Ponadto można utworzyć wiele zakładek przez zadeklarowanie wielu zmiennych typu variant. Poniższy kod otwiera tabelę tblContacts, przechodzi do pierwszego rekordu w bazie danych, ustawia zakładkę, przechodzi do ostatniego rekordu i ostatecznie przechodzi z powrotem do rekordu z zakładką. W każdym kroku wykorzystywane jest polecenie debug.print, co pozwala pokazać względne położenie rekordu w bazie danych. Listing B.1. Zastosowanie zakładki do zaznaczenia rekordu Public Sub BookmarkExample() Dim rs As DAO.Recordset, Dim bk As Variant Set rs = Workspaces(0).Databases(0).OpenRecordset( _ "tblContacts", dbOpenTable) ' Przejście do pierwszego rekordu w bazie danych rs.MoveFirst ' Wyświetlenie pozycji w bazie danych Debug.Print rs.PercentPosition ' Ustawienie zakładki na bieżący rekord bk = rs.Bookmark ' Przejście do ostatniego rekordu w bazie danych rs.MoveLast ' Wyświetlenie pozycji w bazie danych Debug.Print rs.PercentPosition ' Przejście do rekordu zaznaczonego zakładką rs.Bookmark = bk ' Wyświetlenie pozycji w bazie danych Debug.Print rs.PercentPosition rs.Close Set rs = Nothing End Sub
Usuwanie kodu biernego i nieużywanych zmiennych Przed dystrybucją aplikacji, należy usunąć z niej cały kod bierny — kod, który nie jest wykorzystywany. Często będą to całe procedury lub nawet moduły, które kiedyś służyły jakiemuś celowi, ale nie są już więcej wywoływane. Ponadto nierzadko w kodzie pozostają deklaracje zmiennych, po tym jak cały kod, który korzysta z tych zmiennych, został usunięty. Dzięki wyeliminowaniu kodu biernego i nieużywanych zmiennych można ograniczyć ilość pamięci wykorzystywanej przez aplikację oraz czasu wymaganego do skompilowania kodu w czasie wykonywania programu.
Dodatek B Optymalizowanie aplikacji Accessa
1083
Dodatkowymi czynnościami, które można wykonać, aby zwiększyć szybkość modułów, są otwieranie wszystkich wykorzystywanych przez aplikację dodatków w trybie tylko do odczytu i zastąpienie wywołań procedury w pętlach kodem wewnątrzwierszowym. Nie należy również zapominać o jednej z najważniejszych rzeczy — aplikację należy dostarczać użytkownikom ze skompilowanymi modułami.
Zwiększenie wydajności działania w sieci Zdecydowanie najważniejszą czynnością, jaką można wykonać, aby zapewnić działanie aplikacji sieciowej z najwyższą możliwą wydajnością, jest uruchamianie programu Access i bazy danych aplikacji na komputerze użytkownika i podłączenie się do wspólnej, sieciowej bazy danych. Uruchamianie programu Access w sieci jest znacznie wolniejsze niż używanie go lokalnie. Gdy używanym silnikiem bazy danych jest ACE, maksymalna szybkość działania aplikacji Accessa jest ograniczona. ACE sprawia, że przy każdym otwarciu tabeli, uruchomieniu kwerendy lub wykonaniu operacji na danych wszystkie informacje używane w procesie lub kwerendzie trzeba przenieść z bazy danych (przy założeniu, że pliki programu i bazy danych są rozdzielone) na komputer, w którym program działa. Może to wymagać przesyłania dużych ilości danych przez sieć. W projekcie Accessa opartym na bazach Microsoft SQL Server lub SQL Server Express Edition można wykorzystać procedury składowane, aby zminimalizować ruch w sieci. Znacznie przyspiesza to pracę większości aplikacji Accessa. Jeśli pracujesz z dużą ilością danych, rozważ wykorzystanie na zapleczu bazy danych SQL Server.
Praca z dużymi bazami danych Accessa Kiedy ktoś mówi o dużych bazach danych w Accessie, zwykle myśli o bazie danych z tabelami, które zawierają setki tysięcy rekordów danych. Chociaż takie bazy są duże, istnieje też inna definicja; według niej duża jest baza danych, która zawiera setki lub tysiące obiektów — tabel, kwerend, formularzy, raportów i modułów w języku VBA. Chociaż czasami można rozwiązać problemy z wydajnością korzystania z danych, zmieniając silnik bazy danych na SQL Server, to jeżeli tworzy się aplikacje z wieloma kwerendami, formularzami, raportami i modułami, zwykle trzeba zmagać się ze znacznie bardziej złożonymi problemami. Jeśli w bazie danych znajdują się setki obiektów, a zwłaszcza formularzy i raportów, mogą wystąpić problemy, które spowodują, że baza danych będzie się dziwnie zachowywać. Oto przykłady:
Nie będzie pozostawać w stanie skompilowanym.
Jej rozmiar będzie ciągle wzrastał — nawet po skompilowaniu i scaleniu.
Będzie działać coraz wolniej.
W powiązanych podformularzach będą się wyświetlać błędne rekordy.
1084
Dodatki
Będą się wyświetlały błędy kompilacji w sytuacjach, kiedy programista będzie mieć pewność, że kod jest poprawny.
Będą występować przekłamania.
Scalanie bazy danych nie zawsze działa tak, jak twierdzi producent. Kompilacja i zapisywanie wszystkich modułów przedłuża się w nieskończoność. Po scaleniu i otwarciu bazy danych okazuje się, że jest ona ponownie nieskompilowana. Osoby, które pracują z dużymi bazami danych, prawdopodobnie dobrze znają te problemy. W tym podrozdziale poznasz sposoby rozwiązania problemów z bazą danych i przywrócenia jej normalnego działania.
Jak zwiększa się rozmiar baz danych? Rozrastanie się bazy danych może wynikać z wielu czynników. Za każdym razem, kiedy dodajesz obiekt do pliku bazy danych programu Access (do pliku .accdb), staje się on większy. To oczywiste. Z pewnością potrzeba więcej miejsca do zdefiniowania właściwości i metod obiektu. Raporty i formularze zajmują najwięcej miejsca, ponieważ duża liczba właściwości skojarzonych z każdym formularzem lub raportem i każdym formantem na formularzu lub raporcie zajmuje pamięć. Załączniki tabel (łącza) i kwerendy zajmują bardzo mało przestrzeni, ale kod VBA rośnie proporcjonalnie do liczby formularzy i raportów. Jeżeli zapisujesz dane w bazie programu (a nie na zapleczu), również zajmujesz miejsce. Jest wiele powodów rozrastania się baz danych. Za każdym razem, kiedy dodajesz kolejny, nowy formularz lub raport, zużywasz coraz więcej miejsca. Zawsze podczas dodawania nowych formantów i definiowania nowych właściwości zużywasz go jeszcze więcej. Gdy w module formularza lub raportu definiujesz dowolne zdarzenie, które zawiera choćby jeden wiersz kodu VBA, jest to związane z większym kosztem, ponieważ formularz lub raport nie jest już prostym obiektem. Wymaga to więcej pamięci i zasobów niż w przypadku prostego formularza lub raportu, który nie zawiera kodu VBA. Także obrazy osadzane w formularzach i raportach zajmują pamięć. Osadzanie danych OLE, takich jak zdjęcia i dźwięk, wymaga więcej miejsca niż używanie niezwiązanych obiektów lub obrazów. Za każdym razem, kiedy wprowadzasz nawet proste zmiany w dowolnym obiekcie, powstaje jego kopia, która pozostaje w bazie do czasu jej scalenia. W ciągu zaledwie kilku godzin pracy bazy danych programu Access mogą rozrosnąć się do dużych rozmiarów. Jeżeli baza zawiera tysiące wierszy kodu VBA, może bardzo szybko wzrosnąć dwu- lub trzykrotnie względem pierwotnego rozmiaru, zwłaszcza kiedy zostanie skompilowana, a przed tym scalona.
Ograniczenie się do kompilowania i scalania może nie wystarczyć W miarę dodawania, usuwania i modyfikowania obiektów Access nie zawsze wykonuje operacje porządkowo. Jak wiadomo, po wprowadzeniu zmian w obiektach, zwłaszcza kodzie VBA, należy otworzyć dowolny moduł i wybrać opcję Debug/Compile [nazwa bazy danych], zapisać moduł i zamknąć okno edytora kodu VBA. Następnie należy kliknąć
Dodatek B Optymalizowanie aplikacji Accessa
1085
przycisk PLIK, otworzyć zakładkę Informacje i wybrać polecenie Kompaktuj i napraw bazę danych. Ta operacja scala bazę danych w tym samym pliku i na nowo ją otwiera. Kompilowanie i scalanie mogą nie wystarczyć do rozwiązania niektórych problemów wspomnianych na początku rozdziału. Znane są przypadki rozrastania się baz danych po skompilowaniu i scaleniu nawet bez dodawania nowych obiektów, kodu lub danych. Czasami w bazach danych dzieją się dziwne rzeczy, które trudno wytłumaczyć. Jeśli baza danych jest zbyt duża, mogą być kłopoty z jej prawidłową kompilacją. Mogą też wystąpić błędy kompilacji w całkowicie prawidłowo napisanym kodzie. Baza danych może działać wolno nawet wtedy, gdy nie ma w niej niczego błędnego. Istnieje kilka sposobów, które można zastosować w takich sytuacjach, nawet wtedy, gdy wydaje się, że wszystkie możliwości zostały wyczerpane. Ponowne uruchomienie komputera skutkuje czystą mapą pamięci Można łatwo zauważyć, że dziwne zachowanie w dowolnym programie poprawia się po ponownym uruchomieniu komputera. Access jest szczególnie kiepski, jeżeli chodzi o wyciekanie pamięci (zjawisko to ma miejsce, gdy aplikacja nie potrafi zwolnić zajętej pamięci; system operacyjny nie może wtedy wykorzystać jej w innym celu), zwłaszcza jeżeli wchodzi się i wychodzi z projektu formularza, raportu i modułu oraz używa wielu obiektów z danymi (przede wszystkim zbiorów rekordów). Jeżeli ktoś nie chce ponownie uruchamiać komputera, powinien przynajmniej zamknąć bazę danych i wyjść z Accessa, zanim rozpocznie analizowanie problemu.
Naprawa błędnie działającego formularza poprzez usunięcie źródła rekordów Czasami w bazie danych występuje formularz, który nie działa właściwie. Aby go naprawić, można spróbować otworzyć formularz w widoku projektu i usunąć źródło rekordów. Następnie należy zamknąć i zapisać formularz. Po tej czynności trzeba otworzyć formularz jeszcze raz w widoku projektu i ponownie wprowadzić pierwotne źródło rekordów. Kiedy źródło rekordu formularza lub raportu w Accessie się zmieni, wymusza to zmianę różnych części wewnętrznego kodu modułu formularza. Czasami pozwala to rozwiązać problem. Tworzenie nowej bazy danych i importowanie wszystkich obiektów Ważne jest, aby mieć bazę danych tak czystą, jak tylko jest to możliwe. Chociaż nigdy nie mamy pewności, czy „gremliny nie wkradają się” do jakiegoś zakamarka w pliku bazy danych, to jesteśmy pewni, że nie można ich importować lub eksportować. Technika, która zwykle okazuje się skuteczna, polega na utworzeniu nowej bazy danych, a następnie zaimportowaniu wszystkich obiektów z bazy pierwotnej. W programie Access importowanie wszystkich obiektów z pierwotnej bazy danych jest łatwe: 1. Otwórz nową pustą bazę danych. 2. Otwórz zakładkę DANE ZEWNĘTRZNE na wstążce.
1086
Dodatki
Sześć kroków wiodących do sukcesu przy pracy z dużą bazą danych Bezpośrednio przed przekazaniem aplikacji do testowania przez użytkowników należy wykonać poniższe kroki, aby zagwarantować poprawne działanie systemu: 1. Ponownie uruchom komputer, aby wyczyścić pamięć. 2. Utwórz nową bazę danych Accessa i zaimportuj wszystkie obiekty. 3. Ponownie uruchom Accessa z opcją /decompile, trzymając jednocześnie wciśnięty klawisz Shift. Po wyświetleniu się okna bazy danych zamknij Accessa. 4. Ponownie uruchom Accessa, tym razem normalnie, trzymając jednocześnie wciśnięty przycisk Shift. 5. Skompiluj bazę danych. 6. Wykonaj polecenie Kompaktuj i napraw bazę danych. Dzięki przekazaniu czystego, w pełni skompilowanego i scalonego systemu aplikacja będzie działać szybciej i będzie z nią mniej problemów technicznych lub problemów z eksploatacją.
3. Kliknij opcję Access w grupie Importowanie i łączenie. 4. Wybierz bazę danych, z którą masz problemy. 5. Upewnij się, że zaznaczona jest opcja Importuj tabele, kwerendy, formularze, raporty, makra i moduły do bieżącej bazy danych. 6. Kliknij przycisk OK. 7. Kliknij przycisk Zaznacz wszystkie przy odpowiednich typach obiektów. 8. Kliknij przycisk OK. Jeżeli zdefiniowałeś niestandardowe menu i paski narzędzi, specyfikacje importowania i eksportowania lub grupy okienka nawigacji, zaznacz odpowiednie elementy w oknie dialogowym Importowanie obiektów. Jeżeli zdefiniowano niestandardowe właściwości bieżącej bazy danych, trzeba utworzyć je ponownie, ponieważ nie można ich importować. Trzeba też ponownie wskazać biblioteki używane w kodzie VBA.
Wprowadzanie małych zmian w dużych bazach danych W przypadku wprowadzania wielu zmian w bazie ciągle otwiera się i zamyka obiekty. Należy pracować z kopią bazy danych, a następnie po dokonaniu żądanych zmian można wyeksportować zmodyfikowane obiekty z testowej do rzeczywistej bazy danych. Dowolny obiekt, który eksportujesz z taką samą nazwą, jaka już występuje w docelowej bazie danych, zostanie wyeksportowany z cyfrą 1 na końcu nazwy. Następnie można otworzyć docelową bazę danych, usunąć pierwotne obiekty i zmienić nazwę dla obiektów, które posiadają 1 na końcu nazwy. Nowe obiekty będą oczywiście eksportowane ze swoimi niezmienionymi nazwami. Im mniej zmian w dużych bazach danych, tym lepiej. Przestrzegając wskazówek i technik podanych w tym rozdziale, unikniesz niepotrzebnych problemów i zyskasz na wydajności.
Dodatek C
Wydajność kwerend i uszkodzenia baz danych W tym dodatku:
Optymalizowanie wydajności kwerend
Radzenie sobie z uszkodzeniami baz danych
Jednym z najważniejszych aspektów korzystania z Accessa jest zapewnianie poprawności bazy danych. W tym dodatku poznasz wybrane z najlepszych praktyk z zakresu tworzenia i konserwowania baz danych. Opisane tu techniki pozwalają zagwarantować wydajne i bezbłędne działanie baz.
Optymalizowanie wydajności kwerend Przy analizowaniu kilku tysięcy rekordów wydajność kwerend nie ma większego znaczenia. Procesy analityczne przebiegają wtedy szybko i płynnie bez większych problemów. Jeśli jednak trzeba przetwarzać setki tysięcy rekordów, wydajność staje się bardzo istotna. Nie da się zmienić tego, że im więcej danych, tym wolniej działają kwerendy. Można jednak podjąć pewne kroki, aby zoptymalizować wydajność kwerend i przyspieszyć przebieg rozbudowanych procesów analitycznych.
Normalizowanie projektu bazy danych Wielu początkujących użytkowników Accessa tworzy jedną dużą tabelę i nazywa ją bazą danych. To rozwiązanie wydaje się atrakcyjne, ponieważ nie trzeba zarządzać złączeniami, a w kwerendach wystarczy wskazywać jedną tabelę. Jeśli jednak w bazie o takiej strukturze wzrośnie ilość danych, wydajność kwerend będzie bardzo niska.
1088
Dodatki
Optymalizator kwerend w Accessie W większości systemów do obsługi relacyjnych baz danych działa wbudowany optymalizator, który gwarantuje wydajną pracę baz, nawet jeśli zawierają dużą ilość danych. Taki optymalizator dostępny jest także w Accessie. Czy zauważyłeś, że czasem po utworzeniu kwerendy, zamknięciu jej i ponownym otwarciu Access zmienia kryteria i wyrażenia? To efekt działania wbudowanego optymalizatora kwerend. Optymalizator kwerend odpowiada za opracowanie strategii wykonywania kwerendy. Taka strategia to zestaw instrukcji przekazywanych silnikowi ACE. Określają one, jak wykonać kwerendę w najszybszy i najwydajniejszy sposób. Optymalizator kwerend Accessa dobiera strategię na podstawie następujących czynników:
Wielkość tabel używanych w kwerendzie.
Czy tabele używane w kwerendzie mają indeksy.
Liczba tabel i złączeń używanych w kwerendzie.
Obecność i zasięg kryteriów i wyrażeń w kwerendzie.
Strategia wykonania jest tworzona przy pierwszym uruchomieniu kwerendy, a następnie rekompilowana przy każdym zapisywaniu kwerendy lub kompaktowaniu bazy danych. Po opracowaniu strategii silnik ACE korzysta z niej przy uruchamianiu danej kwerendy, co prowadzi do optymalizacji jej pracy. Prawdopodobnie zetknąłeś się już z powiedzeniem „śmieci na wejściu, śmieci na wyjściu”. Związane jest ono z tym, że wyniki działania bazy danych zależą od jakości zapisanych w niej danych. Powiedzenie to dotyczy także optymalizatora kwerend Accessa. Ponieważ działanie optymalizacji w Accessie zależy w dużym stopniu od struktury i przydatności tabel i kwerend, źle zaprojektowane tabele i kwerendy mogą ograniczyć skuteczność optymalizatora kwerend.
Przy normalizowaniu bazy danych w celu nadania jej struktury relacyjnej dane są umieszczane w kilku mniejszych tabelach. Ma to dwa skutki:
Prowadzi do usunięcia zbędnych danych, przez co kwerenda ma mniej danych do sprawdzenia.
Pozwala na uwzględnienie w kwerendzie tylko tabel zawierających potrzebne informacje. Dzięki temu nie trzeba sprawdzać całej bazy danych przy każdym uruchomieniu kwerendy.
Stosowanie indeksów dla odpowiednich pól Wyobraź sobie szafkę na akta zawierającą 1000 dokumentów, które nie są uporządkowane alfabetycznie. Ile czasu zajmie znalezienie wszystkich dokumentów zaczynających się od litery S? Z pewnością łatwiej będzie wyszukiwać dokumenty uporządkowane alfabetycznie. Indeksowanie pól w tabeli Accessa to odpowiednik alfabetycznego porządkowania dokumentów w szafce. Gdy uruchamiasz kwerendę, w której dane są sortowane i filtrowane na podstawie niepoindeksowanego pola, Access przed zwróceniem wyników musi przejrzeć i wczytać cały zbiór danych. Łatwo się domyślić, że w dużych zbiorach danych może to zajmować sporo czasu. Natomiast kwerendy sortujące i filtrujące poindeksowane dane działają dużo szybciej, ponieważ Access korzysta z indeksu do sprawdzania pozycji i ograniczeń.
Dodatek C Wydajność kwerend i uszkodzenia baz danych
1089
Aby utworzyć indeks dla pola tabeli, otwórz tabelę w widoku projektu i ustaw właściwość Indeksowane. Informacje o indeksach znajdziesz w rozdziale 3.
Zanim jednak zaczniesz dodawać indeksy dla wszystkich pól bazy danych, zwróć uwagę na pewną kwestię: choć indeksy znacznie przyspieszają wykonywanie kwerend wybierających, to wyraźnie spowalniają kwerendy funkcjonalne (aktualizujące, usuwające i dołączające). Wynika to z tego, że gdy uruchamiasz kwerendę funkcjonalną z poindeksowanymi polami, Access oprócz zmian w tabeli musi zaktualizować każdy indeks. Dlatego ważne jest, aby indeksować tylko odpowiednie pola. Najlepszą praktyką jest stosowanie indeksów tylko dla następujących typów pól:
Pola, według których często będziesz filtrować dane z wykorzystaniem kryteriów.
Pola, które prawdopodobnie będziesz używać w złączeniach z innymi tabelami.
Pola, według których często będziesz sortować wartości.
Optymalizowanie kwerend przez ulepszenie ich projektu Zaskakujące jest to, że kilka niewielkich zmian w projekcie kwerendy może spowodować poprawę jej wydajności. Poświęć chwilę na zapoznanie się z czynnościami, które pozwalają przyspieszyć pracę kwerend i zoptymalizować przebieg procesów analitycznych:
Unikaj sortowania i filtrowania niepoindeksowanych pól.
Unikaj tworzenia kwerend pobierających z tabeli wszystkie pola za pomocą gwiazdki (*). Na przykład kwerenda SELECT * FROM Tabela wymaga, aby Access przy każdym jej uruchomieniu sprawdzał nazwy pól w tabelach systemowych.
W kwerendach podsumowujących stosuj tylko pola potrzebne do osiągnięcia celu. Im więcej pól występuje w klauzuli GROUP BY, tym dłużej trwa wykonywanie kwerendy.
Czasem w projekcie kwerendy pola są potrzebne tylko do sprawdzania kryteriów. Pól, które nie są potrzebne w wynikach, nie należy wyświetlać. Oznacza to, że należy usunąć zaznaczenie w polu Pokaż w okienku QBE.
Unikaj stosowania otwartych przedziałów (z operatorami > lub <). Zamiast tego stosuj instrukcję Between…And.
W procesach analitycznych stosuj mniejsze tabele tymczasowe zamiast dużych podstawowych tabel. Zamiast złączać dwie duże tabele, spróbuj utworzyć mniejsze tabele tymczasowe zawierające tylko potrzebne rekordy, a następnie złącz tylko tabele tymczasowe. Często się okazuje, że proces przebiega wtedy szybciej mimo dodatkowych kroków w postaci tworzenia i usuwania tabel tymczasowych.
Kiedy to możliwe, stosuj stałe nagłówki kolumn w kwerendach krzyżowych. Dzięki temu Access nie musi wykonywać dodatkowych operacji w celu ustalenia nagłówków kolumn w takich kwerendach.
1090
Dodatki
Unikaj stosowania pól obliczeniowych w podkwerendach i funkcjach agregujących domeny. Podkwerendy i funkcje agregujące domeny same w sobie są mało wydajne. Jeśli zastosujesz w nich pola obliczeniowe, spadek wydajności będzie jeszcze większy. Szczegółowy opis podkwerend i funkcji agregujących domeny znajdziesz w rozdziale 15.
Regularne kompaktowanie i naprawianie bazy danych Z czasem baza danych się zmienia z uwagi na wymogi związane z jej użytkowaniem. Liczba tabel może się zwiększyć lub zmniejszyć, programista może dodać lub usunąć tabele tymczasowe albo kwerendy, użytkownicy mogą w niestandardowy sposób zamknąć bazę danych itd. Wszystkie te sytuacje powodują zmiany w statystykach dotyczących tabeli, a plan wykonania skompilowanych wcześniej kwerend staje się nieprecyzyjny. Kompaktowanie i naprawianie bazy danych wymusza na Accessie odtworzenie statystyk dotyczących tabeli i ponowne zoptymalizowanie kwerend (są one jeszcze raz kompilowane przy następnym uruchomieniu). Dzięki temu Access może uruchamiać kwerendy z wykorzystaniem najbardziej precyzyjnych i wydajnych planów wykonania. Aby skompaktować i naprawić bazę danych, otwórz zakładkę NARZĘDZIA BAZY DANYCH na wstążce i wybierz opcję Kompaktuj i napraw bazę danych. Można skonfigurować bazę danych, aby automatycznie uruchamiała proces kompaktowania i naprawiania przy każdym zamknięciu. W tym celu wykonaj następujące czynności: 1. Wybierz zakładkę PLIK na wstążce. 2. Kliknij Opcje. Pojawi się okno dialogowe Opcje programu Access. 3. Otwórz kartę Bieżąca baza danych, aby wyświetlić konfigurację bieżącej bazy. 4. Zaznacz pole wyboru Kompaktuj przy zamknięciu i kliknij przycisk OK, aby zatwierdzić zmiany.
Radzenie sobie z uszkodzeniami baz danych Uszkodzenie ma miejsce, gdy w bazie danych Accessa wystąpił błąd, który powoduje jej nieprzewidywalne działanie, a w najgorszych przypadkach uniemożliwia korzystanie z niej. Aby zrozumieć, dlaczego baza danych może zostać uszkodzona, należy zapoznać się ze sposobem zarządzania danymi przez silnik bazodanowy ACE. ACE zarządza danymi podzielonymi na bloki. Gdy otwierasz tabelę w bazie danych, widzisz jeden obiekt, jednak w rzeczywistości składa się on ze zbioru bloków. W zależności od wielkości tabela może obejmować jeden blok danych lub wiele bloków powiązanych ze sobą. Uszkodzenia są zwykle wynikiem błędów zachodzących przy zapisie danych w jednym lub kilku blokach. Niewielkie uszkodzenia powstają nieustannie. Użytkownicy o tym nie wiedzą, ponieważ silnik ACE naprawia usterki w trakcie wczytywania i zapisywania danych. Czasem jednak silnik nie potrafi samodzielnie rozwiązać problemu. Wtedy bazę danych można uznać za uszkodzoną.
Dodatek C Wydajność kwerend i uszkodzenia baz danych
1091
Wykrywanie uszkodzonych baz danych Baza danych może zostać uszkodzona z wielu powodów. Możliwe, że wystąpiły błędy przy zapisie danych, definicje tabel stały się nieaktualne, kod VBA lub makra spowodował poważny błąd itd. Ponieważ uszkodzenie może być wynikiem rozmaitych trudnych do wykrycia problemów, oznaki i symptomy uszkodzenia są równie zróżnicowane i niejasne. Nigdy nie pojawi się komunikat bezpośrednio informujący, że baza jest uszkodzona. Jak więc stwierdzić, że nastąpiło uszkodzenie bazy? Uszkodzone bazy można podzielić na dwie kategorie: bazy, które można otworzyć i stosować, oraz bazy, które w ogóle się nie otwierają. Niebezpieczną cechą otwierających się uszkodzonych baz danych jest to, że użytkownicy mogą nie wiedzieć, iż korzystają z nieprawidłowej bazy. Wykrycie oznak uszkodzenia bywa w takiej sytuacji trudne. Mimo to występują pewne sygnały, które jednoznacznie wskazują na problemy:
Pojawia się komunikat Invalid field data type (błędny typ danych pola) przy próbie otwarcia tabeli w widoku arkusza danych, w widoku projektu lub przy wyświetlaniu okna relacji.
Pojawia się komunikat Could not find field Description (nie można znaleźć pola Description) przy próbie skompaktowania i naprawienia bazy danych.
Przy próbie otwarcia tabeli, kwerendy, formularza, raportu lub strony dostępu do danych pojawia się jeden z poniższych komunikatów: MSAccess can’t open the table in Datasheet view
(Access nie może
otworzyć tabeli w widoku arkusza danych). Record is deleted
(rekord został usunięty).
Unable to carry out the command
(nie można wykonać polecenia).
There was an error executing the command
(w trakcie wykonywania
polecenia wystąpił błąd).
Przy próbie skompaktowania i naprawienia bazy danych pojawia się komunikat Table 'TempMSysAccessObjects' already exists (tabela TempMSysAccessObjects już istnieje).
Przy próbie otwarcia lub usunięcia połączonej tabeli nic się nie dzieje.
Access nieoczekiwanie kończy pracę, a następnie próbuje wysłać raport o błędzie.
Pojawia się komunikat o błędzie z nieprawdziwą informacją The changes you requested to the table were not successful because they would create duplicate values in the index, primary key, or relationship (nie udało się
wprowadzić żądanych zmian w tabeli, ponieważ spowodowałyby utworzenie powtarzających się wartości w indeksie, kluczu głównym lub relacji).
W tabelach pojawiają się wpisy #DELETED#.
Access zaczyna usuwać losowe rekordy.
1092
Dodatki
Po kliknięciu rekordu pojawia się komunikat o błędzie Invalid argument (nieprawidłowy argument).
We wszystkich polach danego rekordu pojawia się wartość #Error przy próbie uruchomienia kwerendy dla tego rekordu lub wyświetlenia go w formularzu.
Przywracanie uszkodzonej bazy danych Jeśli ustaliłeś, że baza danych rzeczywiście jest uszkodzona, możesz spróbować wykonać pewne czynności, aby przywrócić ją do poprawnego stanu. Pamiętaj, że to, czy bazę uda się naprawić, zależy od charakteru i zasięgu uszkodzeń. Metoda polega na kolejnym wykonywaniu poniższych czynności aż do rozwiązania problemu: 1. Utwórz kopię uszkodzonej bazy danych. Wszelkie próby przywrócenia bazy mogą prowadzić do jej trwałego zniszczenia, dlatego warto przygotować jej kopię zapasową. 2. Spróbuj uruchomić bazę w innym środowisku. Spróbuj otworzyć i zastosować bazę na kilku lokalnych komputerach (zwłaszcza jeśli używasz bazy przez sieć). Jeżeli to rozwiąże problem, prawdopodobnie nie wynika on z uszkodzenia bazy. Poszukaj wtedy usterek sprzętowych lub programowych. 3. Usuń plik .laccdb powiązany z bazą danych. Gdy otwierasz bazę danych Accessa, tworzony jest plik .laccdb. Umożliwia on jednoczesne korzystanie z bazy przez wielu użytkowników. Usunięcie pliku .laccdb daje gwarancję, że żaden powodujący problemy egzemplarz bazy nie pozostanie otwarty. Jeśli nie możesz usunąć tego pliku, uruchom menedżer zadań systemu Windows i zamknij wszystkie egzemplarze Accessa oraz procesy, które mogą logować się do bazy. Czasem operacja ta pozwala rozwiązać problem. 4. Zaimportuj bazę do nowego pliku .accdb. Otwórz nową bazę i spróbuj zaimportować do niej tabele, kwerendy, formularze, raporty, makra, strony dostępu do danych i moduły z uszkodzonej bazy. Zwykle metoda ta pozwala uratować wszystkie dane i cały kod. 5. Przywróć bazę danych za pomocą kopii zapasowej. Jeśli masz kopię zapasową bazy, możesz wykorzystać ją do przywrócenia części utraconych danych. 6. Skorzystaj z usług firm naprawiających bazy Accessa. Ostatnią deską ratunku jest skorzystanie z usług firm naprawiających bazy Accessa. Korzystają one ze specjalistycznego oprogramowania do przywracania baz danych. Skuteczność takich narzędzi sięga 99%. Usługi tego typu kosztują około kilkuset złotych (zależy to od firmy i złożoności problemu). Aby znaleźć taką firmę, wystarczy w wyszukiwarce wpisać wyrażenie „naprawa baz danych”.
Zapobieganie uszkodzeniom baz danych Niestety nie istnieje jednoznaczny zbiór objawów ostrzegających przed możliwym uszkodzeniem bazy danych. Gdy odkryjesz uszkodzenie, będzie już za późno. Dlatego warto nawykowo stosować kilka prostych środków, które zminimalizują możliwość wystąpienia uszkodzenia i przygotują Cię na ewentualność wystąpienia problemów.
Dodatek C Wydajność kwerend i uszkodzenia baz danych
1093
Regularnie twórz kopię zapasową bazy danych Kopia zapasowa bazy danych jest jak koło zapasowe w samochodzie. Nie ma lepszego zabezpieczenia przed utratą danych niż niezależnie przechowywana kopia zapasowa. Przy wyborze strategii tworzenia kopii należy udzielić sobie odpowiedzi na dwa następujące pytania:
Kiedy należy archiwizować bazę danych? Zastosuj plan archiwizacji bezpośrednio dostosowany do poziomu tolerancji na utratę danych. Jeśli nie możesz utracić danych z więcej niż jednego dnia, twórz kopię zapasową codziennie. Jeżeli codzienne kopie są zbędne, twórz je co tydzień. Nigdy nie należy archiwizować bazy w trakcie jej używania. Grozi to tym, że kopia będzie niekompletna.
Gdzie należy przechowywać kopię? Wybierz bezpieczną, łatwo dostępną lokalizację. Nie przechowuj kopii w tym samym katalogu, w którym znajduje się oryginalna wersja bazy.
Regularnie kompaktuj i naprawiaj bazę W trakcie korzystania z bazy danych następują pewne zmiany. Na przykład bloki danych w bazie stają się pofragmentowane, statystyki dotyczące tabeli przestają być aktualne, a baza się rozrasta. Choć żadna z tych zmian nie prowadzi bezpośrednio do uszkodzenia bazy, to jeśli nic z nimi nie zrobisz, mogą one przyczynić się do wystąpienia problemów. Wielu użytkowników Accessa uważa, że mechanizm kompaktowania i naprawiania bazy jedynie zwalnia miejsce na dysku. Jednak mechanizm ten prowadzi do wykonania kilku ważnych operacji. Mechanizm kompaktowania i naprawiania bazy:
odzyskuje miejsce na dysku i zapobiega rozrastaniu się bazy;
defragmentuje bloki danych tworzące strony tabeli, dzięki czemu zwiększa wydajność i umożliwia sprawne wykorzystanie bufora odczytu z wyprzedzeniem;
resetuje pola typu Autonumerowanie, dzięki czemu następna przydzielana wartość będzie o 1 większa od najwyższej w istniejących rekordach;
odtwarza dotyczące tabel statystyki używane przez optymalizator kwerend do tworzenia strategii wykonania;
oznacza wszystkie kwerendy jako wymagające ponownej kompilacji przy następnym uruchomieniu.
Operacje te znacznie pomagają zachować sprawność i wydajność bazy. Aby skompaktować i naprawić bazę danych, wykonaj czynności opisane w punkcie „Regularnie kompaktuj i naprawiaj bazę” we wcześniejszej części rozdziału.
1094
Dodatki
Unikaj zakłóceń w trakcie zapisywania danych w bazie Najczęstszą przyczyną uszkodzeń są zakłócenia w trakcie zapisu danych w bazie. Zakłócenia w czasie zapisu mogą prowadzić do wielu problemów — od niekompletnych definicji tabel po utracone indeksy. Dlatego należy unikać niestandardowego i nagłego zamykania Accessa. Zastosowanie się do poniższych wskazówek pomoże Ci uniknąć uszkodzeń wynikających z przerwania pracy:
Zawsze zamykaj Accessa dopiero po zakończeniu działania przez wszystkie kwerendy, makra i procedury.
Unikaj zamykania Accessa za pomocą menedżera zadań systemu Windows.
Nigdy nie umieszczaj baz danych Accessa na serwerze plików, który jest regularnie zamykany lub restartowany.
Unikaj utraty zasilania w czasie pracy z bazą danych. Jeśli baza znajduje się na serwerze plików, upewnij się, czy serwer jest zabezpieczony przed skokami napięcia lub utratą zasilania.
Nigdy nie pracuj z bazą zapisaną na nośniku wymiennym Gdy pracujesz z bazą danych Accessa, potrzebne jest dodatkowe miejsce na dysku na plik .laccdb i na standardowe powiększanie się bazy w trakcie używania Accessa. Jeśli otworzysz bazę Accessa zapisaną na nośniku wymiennym (np. na pendrivie lub dysku ZIP), narażasz ją na uszkodzenie w wyniku problemów z brakiem pamięci. Dobrym zwyczajem jest kopiowanie bazy danych na dysk twardy, używanie jej na dysku i kopiowanie z powrotem na nośnik wymienny po zakończeniu pracy.
Dodatek D
Przegląd funkcji dla analityków danych W tym dodatku:
Przegląd funkcji często używanych w analizach danych
Poznawanie różnorodnych funkcji
Ten dodatek ma być solidnym źródłem wiedzy na temat najważniejszych funkcji używanych przy analizowaniu danych. Niektóre z tych funkcji szczegółowo opisaliśmy w innych miejscach książki. Więcej informacji na temat funkcji, które nie są opisane w tej książce, znajdziesz w systemie pomocy Accessa.
Abs Przeznaczenie: Abs to funkcja matematyczna. Zwraca wartość bezwzględną liczby (czyli wartość liczby bez znaku plus lub minus). Na przykład wywołanie Abs(-5) zwraca 5. Argumenty: Abs(Liczba)
Liczba (wymagany) — przetwarzane wyrażenie liczbowe. W kontekście kwerendy można podać nazwę pola, aby przetworzyć wartości z tego pola z wszystkich wierszy.
Asc Przeznaczenie: Asc to funkcja przekształcająca łańcuchy znaków na odpowiadające im kody ASCII. Na przykład wywołanie Asc("A") zwraca 65, ponieważ 65 to kod ASCII dla dużej litery A. Jeśli przekażesz do funkcji Asc całe słowo, otrzymasz kod ASCII tylko pierwszej litery.
1096
Dodatki
Argumenty: Asc(Łańcuch znaków)
Łańcuch znaków (wymagany) — przetwarzany łańcuch znaków. Jeśli nie zawiera on żadnych znaków, wywołanie funkcji kończy się niepowodzeniem i zwraca ona błąd czasu wykonania.
Atn Przeznaczenie: Atn to funkcja matematyczna. Oblicza arcus tangens na podstawie liczby. Argumenty: Atn(Liczba)
Liczba (wymagany) — przetwarzane wyrażenie liczbowe.
Choose Przeznaczenie: Choose to funkcja sterowania przepływem programu. Umożliwia zwrócenie wartości z listy na podstawie pozycji. Na przykład wywołanie Choose(3, "Microsoft", "Access", "analiza", "danych") zwraca analiza, ponieważ słowo to znajduje się na trzeciej pozycji na liście. Argumenty: Choose(Pozycja, Lista wartości rozdzielonych przecinkami)
Pozycja (wymagany) — wyrażenie liczbowe lub pole o wartości między 1 a liczbą elementów na liście. Jeśli wartość tego argumentu jest mniejsza niż 1 lub większa niż liczba elementów, zwracana jest wartość Null. Argument musi być liczbą całkowitą. Lista wartości rozdzielonych przecinkami (wymagany) — wyrażenie typu Variant z listą zawierającą przynajmniej jedną wartość.
Chr Przeznaczenie: Chr to funkcja przekształcająca kody ASCII na odpowiadające im łańcuchy znaków. Na przykład wywołanie Chr(65) zwraca A. Argumenty: Chr(Liczba)
Liczba (wymagany) — liczba reprezentująca kod ASCII znaku. Jeśli przekazana liczba nie jest poprawnym kodem ASCII, wywołanie funkcji kończy się niepowodzeniem i zgłasza ona błąd czasu wykonania.
Dodatek D Przegląd funkcji dla analityków danych
1097
Cos Przeznaczenie: Cos to funkcja matematyczna. Oblicza cosinus kąta. Argumenty: Cos(Liczba)
Liczba (wymagany) — wyrażenie liczbowe reprezentujące kąt w radianach.
Date Przeznaczenie: Funkcja Date zwraca bieżącą datę systemową ustawioną w komputerze. Funkcja ta jest bardzo potrzebna przy wykonywaniu analiz wymagających porównania bieżącej daty z inną. Argumenty: Funkcja ta nie ma wymaganych argumentów. Aby ją zastosować, wystarczy wywołanie Date().
DateAdd Przeznaczenie: Funkcja DateAdd zwraca datę, do której dodano pewien okres. Pozwala obliczyć datę po dodaniu do innej 30 dni, odjęciu 3 tygodni, dodaniu 4 miesięcy itd. Oto przykłady: DateAdd("ww",1,#11/30/2004#) DateAdd("m",2,#11/30/2004#)
— dodaje 1 tydzień, zwraca 12/7/2004.
— dodaje 2 miesiące, zwraca 1/30/2005.
DateAdd("yyyy",-1,#11/30/2004#)
— odejmuje 1 rok, zwraca 11/30/2003.
Argumenty: DateAdd(Okres, Jednostek, Data)
Okres (wymagany) — używany przedział czasu. Dostępne okresy to: "yyyy"
— rok,
"q"
— kwartał,
"m"
— miesiąc,
"y"
— dzień roku,
"d"
— dzień,
"w"
— dzień tygodnia,
"ww"
— tydzień,
"h"
— godzina,
"n"
— minuta,
"s"
— sekunda.
1098
Dodatki Jednostek (wymagany) — liczba dodawanych (lub odejmowanych) okresów. Wartość dodatnia powoduje zwrócenie daty z przyszłości, a wartość ujemna — daty z przeszłości. Data (wymagany) — wyjściowa data. W kwerendzie można podać nazwę pola, aby określić, że aplikacja ma przetworzyć wartości z tego pola z wszystkich wierszy.
DateDiff Przeznaczenie: Funkcja DateDiff zwraca różnicę między dwiema datami wyrażoną w określonych jednostkach czasu. Na przykład wywołanie DateDiff('yyyy', #5/16/1972#, #5/16/2005#) zwraca 33, ponieważ między dwiema podanymi datami są 33 lata różnicy. Argumenty: DateDiff(Okres, Data1, Data2, PierwszyDzieńTygodnia, PierwszyTydzieńRoku)
Okres (wymagany) — używany przedział czasu. Dostępne okresy to: "yyyy"
— rok,
"q"
— kwartał,
"m"
— miesiąc,
"y"
— dzień roku,
"d"
— dzień,
"w"
— dzień tygodnia,
"ww"
— tydzień,
"h"
— godzina,
"n"
— minuta,
"s"
— sekunda.
Data1 (wymagany) — jest to jedna z dwóch dat, na podstawie których obliczana
jest różnica. W kwerendzie można podać nazwę pola, aby określić, że aplikacja ma przetworzyć wartości z tego pola z wszystkich wierszy. Data2 (wymagany) — jest to jedna z dwóch dat, na podstawie których obliczana
jest różnica. W kwerendzie można podać nazwę pola, aby określić, że aplikacja ma przetworzyć wartości z tego pola z wszystkich wierszy. PierwszyDzieńTygodnia (opcjonalny) — określa, który dzień tygodnia jest uznawany za pierwszy. Wartość 1 oznacza, że pierwszym dniem jest niedziela, 2 to poniedziałek, 3 to wtorek itd. Jeśli pominiesz ten argument, domyślnie jako
pierwszy dzień tygodnia ustawiana jest niedziela. PierwszyTydzieńRoku (opcjonalny) — określa, który tydzień roku jest uznawany
za pierwszy. Zwykle argument ten jest pomijany. Wtedy jako pierwszy uznawany jest tydzień z dniem 1 stycznia. Można jednak zmienić to ustawienie na jedno z następujących:
Dodatek D Przegląd funkcji dla analityków danych
1099
0
— wykorzystanie ustawienia z API NLS (ang. National Language Support);
1
— pierwszy tydzień z dniem 1 stycznia;
2
— pierwszy tydzień, który w nowym roku ma przynajmniej 4 dni;
3
— pierwszy tydzień, który w nowym roku ma 7 dni.
DatePart Przeznaczenie: Funkcja DatePart zwraca określony aspekt daty. Na przykład wywołanie DatePart("q",#6/4/2004#) zwraca 2, ponieważ podana data wypada w drugim kwartale. Argumenty: DateDiff(Okres, PoprawnaData, PierwszyDzieńTygodnia, PierwszyTydzieńRoku)
Okres (wymagany) — używana jednostka czasu. Dostępne okresy to: "yyyy"
— rok,
"q"
— kwartał,
"m"
— miesiąc,
"y"
— dzień roku,
"d"
— dzień,
"w"
— dzień tygodnia,
"ww"
— tydzień,
"h"
— godzina,
"n"
— minuta,
"s"
— sekunda.
PoprawnaData (wymagany) — jest to używana data. W kwerendzie można podać
nazwę pola, aby określić, że aplikacja ma przetworzyć wartości z tego pola z wszystkich wierszy. PierwszyDzieńTygodnia (opcjonalny) — określa, który dzień tygodnia jest uznawany za pierwszy. Wartość 1 oznacza, że pierwszym dniem jest niedziela, 2 to poniedziałek, 3 to wtorek itd. Jeśli pominiesz ten argument, domyślnie jako pierwszy dzień tygodnia ustawiana jest niedziela. PierwszyTydzieńRoku (opcjonalny) — określa, który tydzień roku jest uznawany
za pierwszy. Zwykle argument ten jest pomijany. Wtedy jako pierwszy uznawany jest tydzień z dniem 1 stycznia. Można jednak zmienić to ustawienie na jedno z następujących: 0
— wykorzystanie ustawienia z API NLS (ang. National Language Support);
1
— pierwszy tydzień z dniem 1 stycznia;
2
— pierwszy tydzień, który w nowym roku ma przynajmniej 4 dni;
3
— pierwszy tydzień, który w nowym roku ma 7 dni.
1100
Dodatki
DateSerial Przeznaczenie: Funkcja DateSerial umożliwia utworzenie daty na podstawie jej składników (roku, miesiąca i dnia). Funkcja ta doskonale nadaje się do przekształcania odrębnych łańcuchów znaków reprezentujących części daty w gotową datę. Na przykład wywołanie DateSerial(2004, 4, 3) zwraca 2004-04-03. Argumenty: DateSerial(Rok, Miesiąc, Dzień)
Rok (wymagany) — dowolna liczba lub wyrażenie liczbowe o wartości z przedziału od 100 do 9999. Miesiąc (wymagany) — dowolna liczba lub wyrażenie liczbowe. Dzień (wymagany) — dowolna liczba lub wyrażenie liczbowe.
DateValue Przeznaczenie: Funkcja DateValue umożliwia przekształcenie dowolnego łańcucha znaków lub wyrażenia reprezentującego poprawną datę, godzinę lub oba te elementy w datę zapisaną za pomocą wartości liczbowych. Na przykład wywołanie DateValue("31 października 2004") zwraca 2004-10-31. Argumenty: DateValue(Wyrażenie)
Wyrażenie (wymagany) — dowolny łańcuch znaków lub wyrażenie reprezentujące datę, czas lub oba te elementy.
Day Przeznaczenie: Funkcja Day przekształca poprawną datę na liczbę z przedziału od 1 do 31 reprezentującą dzień miesiąca odpowiadający podanej dacie. Na przykład wywołanie Day(#5/16/1972#) zwraca 16. Argumenty: Day(PoprawnaData)
PoprawnaData (wymagany) — dowolna wartość reprezentująca poprawną datę.
W kwerendzie można podać nazwę pola, aby określić, że aplikacja ma przetworzyć wartości z tego pola z wszystkich wierszy.
DDB Przeznaczenie: DDB to funkcja finansowa, która oblicza wartość amortyzacji aktywów w podanym okresie, używając metody podwójnie malejącego salda (ang. double-declining method) lub innej techniki.
Dodatek D Przegląd funkcji dla analityków danych
1101
Argumenty: DDB(Koszt, Odzysk, Okres użytkowania, Okres, Współczynnik)
Koszt (wymagany) — początkowy koszt aktywów (musi być liczbą dodatnią). Odzysk (wymagany) — wartość aktywów pod koniec okresu użytkowania (musi być liczbą dodatnią). Okres użytkowania (wymagany) — okres użytkowania aktywów. Okres (wymagany) — okres, dla którego liczona jest amortyzacja. Współczynnik (opcjonalny) — współczynnik zmniejszania się wartości salda. Ustawieniem domyślnym tego argumentu jest wartość dla metody podwójnie malejącego salda (współczynnik równy 2).
Funkcje agregujące domeny Przeznaczenie: Funkcje agregujące domeny umożliwiają obliczanie i podsumowywanie informacji statystycznych na temat całego zbioru danych (domeny). Funkcje te różnią się od kwerend podsumowujących, ponieważ kwerendy podsumowujące grupują dane przed obliczeniem wartości, natomiast funkcje agregujące domeny dotyczą całego zbioru danych. Istnieje 12 funkcji agregujących domeny, przy czym wszystkie mają te same argumenty. — zwraca sumę wartości z określonego pola dla domeny. Na przykład wywołanie DSum("[Kwota_transakcji]", "[Tabela_transakcji]") zwraca łączną wartość transakcji z tabeli.
DSum
— zwraca średnią wartości z określonego pola dla domeny. Na przykład wywołanie DAvg("[Kwota_transakcji]", "[Tabela_transakcji]") zwraca średnią wartość transakcji z tabeli Tabela_transakcji.
DAvg
— zwraca liczbę rekordów z domeny. Wywołanie DCount("*", "[Tabela_transakcji]") zwraca łączną liczbę rekordów z tabeli Tabela_transakcji.
DCount
— zwraca pierwszą wartość z określonego pola, która spełnia podane kryteria. Jeśli nie podasz kryteriów, funkcja zwróci losową wartość z domeny. Funkcja ta jest przydatna zwłaszcza przy pobieraniu wartości z zewnętrznego zbioru danych. Na przykład wywołanie DLookup("[Nazwisko]", "[Tabela_ pracowników]", "[Numer_pracownika]='42620' ") zwraca wartość pola Nazwisko z rekordu, w którym pole Numer_pracownika ma wartość '42620'.
DLookup
DMin, DMax
— zwracają minimalną i maksymalną wartość z domeny. Wywołanie
DMin("[Kwota_transakcji]", "[Tabela_transakcji]") zwraca najmniejszą kwotę transakcji z tabeli Tabela_transakcji, natomiast wywołanie DMax("[Kwota_transakcji]", "[Tabela_transakcji]") zwraca największą
wartość z tej tabeli. DFirst, DLast
— zwracają pierwszą i ostatnią wartość z domeny. Wywołanie
DFirst("[Kwota_transakcji]", "[Tabela_transakcji]") zwraca pierwszą kwotę transakcji z tabeli Tabela_transakcji, natomiast wywołanie
1102
Dodatki DLast("[Kwota_transakcji]", "[Tabela_transakcji]") zwraca ostatnią wartość
z tej tabeli. DStdev, DStdevp, DVar i DVarp
— funkcje DStdev i DStdevp zwracają odchylenie standardowe dla próbki z populacji i dla całej populacji, natomiast funkcje DVar i DVarp zwracają wariancję dla próbki z populacji i dla całej populacji.
Argumenty: Wszystkie funkcje agregujące domeny mają te same argumenty. Oto one: ("[Nazwa pola]","[Zbiór danych]","[Kryteria]")
Nazwa pola (wymagany) — określa przetwarzane pole z danymi. Argument ten należy ująć w cudzysłów. Zbiór danych (wymagany) — określa domenę (wyznaczaną przez tabelę lub kwerendę). Argument ten należy ująć w cudzysłów. Kryteria (opcjonalny) — służy do ograniczania zakresu danych, którego dotyczy wywoływana funkcja agregująca domeny. Jeśli pominiesz ten argument, funkcja zostanie wykonana dla całego zbioru danych. Argument ten należy ująć w cudzysłów.
Exp Przeznaczenie: Exp to funkcja matematyczna podnosząca podstawę logarytmu naturalnego (2,718282) do podanej potęgi. Argumenty: Exp(Liczba)
Liczba (wymagany) — wyrażenie liczbowe określające potęgę, do której
podnoszona jest wartość 2,718282.
FormatCurrency Przeznaczenie: FormatCurrency to funkcja, która przekształca wyrażenie na wartość pieniężną obejmującą symbol waluty zdefiniowany w ustawieniach regionalnych komputera. Argumenty: FormatCurrency(Liczba, Końcowych cyfr, Początkowe zero, Nawiasy dla ujemnych, Grupy)
Liczba (wymagany) — przekształcana liczba. W kwerendzie można podać nazwę
pola, aby określić, że aplikacja ma przetworzyć wartości z tego pola z wszystkich wierszy. Końcowych cyfr (opcjonalny) — liczba wyświetlanych cyfr po przecinku. Początkowe zero (opcjonalny) — określa, czy dla wartości ułamkowych aplikacja ma wyświetlać początkowe zero. Wartość -1 powoduje wyświetlanie zera, wartość 0 prowadzi do ukrycia go, a wartość -2 powoduje zastosowanie
ustawień domyślnych (ustawień regionalnych z komputera).
Dodatek D Przegląd funkcji dla analityków danych
1103
Nawiasy dla ujemnych (opcjonalny) — określa, czy wartości ujemne aplikacja ma wyświetlać w nawiasach. Wartość -1 powoduje dodawanie nawiasów, wartość 0 prowadzi do ich pominięcia, a wartość -2 powoduje zastosowanie
ustawień regionalnych z komputera. Grupy (opcjonalny) — określa, czy aplikacja ma grupować cyfry przy użyciu ogranicznika wybranego w ustawieniach regionalnych komputera. Wartość -1 powoduje grupowanie, wartość 0 oznacza brak grupowania, a wartość -2
powoduje zastosowanie ustawień regionalnych z komputera.
FormatDateTime Przeznaczenie: FormatDateTime to funkcja, która przekształca wyrażenie na datę lub godzinę. Argumenty: FormatDateTime(Data, Nazwa formatu)
Data (wymagany) — przekształcana data lub godzina. W kwerendzie można
podać nazwę pola, aby określić, że aplikacja ma przetworzyć wartości z tego pola z wszystkich wierszy. Nazwa formatu (opcjonalny) — kod formatu określająca używany format daty
lub godziny. Oto możliwe wartości tego argumentu: 0
— daty są wyświetlane w postaci skróconej, a godzina w postaci pełnej;
— daty są wyświetlane w postaci pełnej zgodnie z ustawieniami regionalnymi z komputera;
1
— daty są wyświetlane w postaci skróconej zgodnie z ustawieniami regionalnymi z komputera;
2
— godziny są wyświetlane za pomocą formatu określonego w ustawieniach regionalnych komputera;
3 4
— godziny sortowania wyświetlane w formacie 24-godzinnym (gg:mm).
FormatNumber Przeznaczenie: FormatNumber to funkcja, która przekształca wyrażenie liczbowe na sformatowaną liczbę. Argumenty: FormatNumber(Liczba, Końcowych cyfr, Początkowe zero, Nawiasy dla ujemnych, Grupy)
Liczba (wymagany) — przekształcana liczba. W kwerendzie można podać
nazwę pola, aby określić, że aplikacja ma przetworzyć wartości z tego pola z wszystkich wierszy. Końcowych cyfr (opcjonalny) — liczba wyświetlanych cyfr po przecinku.
1104
Dodatki Początkowe zero (opcjonalny) — określa, czy dla wartości ułamkowych aplikacja ma wyświetlać początkowe zero. Wartość -1 powoduje wyświetlanie zera, wartość 0 prowadzi do ukrycia go, a wartość -2 powoduje zastosowanie
ustawień domyślnych (ustawień regionalnych z komputera). Nawiasy dla ujemnych (opcjonalny) — określa, czy wartości ujemne aplikacja ma wyświetlać w nawiasach. Wartość -1 powoduje dodawanie nawiasów, wartość 0 prowadzi do ich pominięcia, a wartość -2 powoduje zastosowanie
ustawień regionalnych z komputera. Grupy (opcjonalny) — określa, czy aplikacja ma grupować cyfry przy użyciu ogranicznika wybranego w ustawieniach regionalnych komputera. Wartość -1 powoduje grupowanie, wartość 0 oznacza brak grupowania, a wartość -2
powoduje zastosowanie ustawień regionalnych z komputera.
FormatPercent Przeznaczenie: FormatPercent to funkcja, która przekształca wyrażenie liczbowe na sformatowaną wartość procentową zakończoną symbolem procentów (%). Argumenty: FormatPercent(Liczba, Końcowych cyfr, Początkowe zero, Nawiasy dla ujemnych, Grupy)
Liczba (wymagany) — przekształcana liczba. W kwerendzie można podać nazwę
pola, aby określić, że aplikacja ma przetworzyć wartości z tego pola z wszystkich wierszy. Końcowych cyfr (opcjonalny) — liczba wyświetlanych cyfr po przecinku. Początkowe zero (opcjonalny) — określa, czy dla wartości ułamkowych aplikacja ma wyświetlać początkowe zero. Wartość -1 powoduje wyświetlanie zera, wartość 0 prowadzi do ukrycia go, a wartość -2 powoduje zastosowanie
ustawień regionalnych z komputera. Nawiasy dla ujemnych (opcjonalny) — określa, czy wartości ujemne aplikacja ma wyświetlać w nawiasach. Wartość -1 powoduje dodawanie nawiasów, wartość 0 prowadzi do ich pominięcia, a wartość -2 powoduje zastosowanie
ustawień regionalnych z komputera. Grupy (opcjonalny) — określa, czy aplikacja ma grupować cyfry przy użyciu ogranicznika wybranego w ustawieniach regionalnych komputera. Wartość -1 powoduje grupowanie, wartość 0 oznacza brak grupowania, a wartość -2 powoduje
zastosowanie ustawień regionalnych z komputera.
FV Przeznaczenie: FV to funkcja, która umożliwia obliczenie przyszłej wartości raty annuitetowej. Annuitet to szereg stałych płatności gotówkowych (zwykle rat pożyczki spłacanych przez określony czas).
Dodatek D Przegląd funkcji dla analityków danych
Oprocentowanie (wymagany) — średnie oprocentowanie dla okresu. Okresy (wymagany) — łączna liczba okresów płatności. Kwota (wymagany) — kwota płatności (zwykle obejmuje część kapitałową
i odsetkową). Obecna wartość (opcjonalny) — obecna wartość przyszłych płatności. Jeśli pominiesz ten argument, zastosowana zostanie wartość 0. Typ (opcjonalny) — określa, kiedy należy dokonać płatności. Wartość 0 oznacza, że płatności są dokonywane pod koniec okresu, a przy wartości 1 płatności należy
dokonywać na początku okresu. Jeśli pominiesz ten argument, zastosowana zostanie wartość 0.
Hour Przeznaczenie: Hour to funkcja, która przekształca czas na liczbę z przedziału od 0 do 23 reprezentującą godzinę. Na przykład wywołanie Hour(#9:30:00 PM#) zwraca 21. Argumenty: Hour(Poprawny czas)
Poprawny czas (wymagany) — kombinacja wartości, które reprezentują poprawny
czas. W kwerendzie można podać nazwę pola, aby określić, że aplikacja ma przetworzyć wartości z tego pola z wszystkich wierszy.
IIf Przeznaczenie: IIf to funkcja sterowania przepływem programu, która umożliwia tworzenie instrukcji If…Then…Else. Funkcja ta zwraca jedną wartość, jeśli warunek jest spełniony, a inną, jeżeli nie jest spełniony. Argumenty: IIf(Wyrażenie, Wartość dla true, Wartość dla false)
Wyrażenie (wymagany) — sprawdzane wyrażenie. Wartość dla true (wymagany) — wartość zwracana, jeśli wyrażenie ma wartość True. Wartość dla false (wymagany) — wartość zwracana, jeśli wyrażenie ma
wartość False.
1106
Dodatki
InStr Przeznaczenie: InStr to funkcja tekstowa, która wyszukuje w łańcuchu znaków inny łańcuch i zwraca jego pozycję. Na przykład wywołanie InStr("Aleksander, Michał","k") zwraca 4, ponieważ k to czwarty znak w łańcuchu znaków. Argumenty: InStr(Początek, Przeszukiwany łańcuch, Szukany łańcuch, Porównywanie)
Początek (opcjonalny) — numer znaku, od którego rozpoczynane jest wyszukiwanie. Wartość domyślna to 1. Przeszukiwany łańcuch (wymagany) — przeszukiwany łańcuch znaków. Szukany łańcuch (wymagany) — szukany łańcuch znaków. Porównywanie (opcjonalny) — określa sposób porównywania łańcuchów znaków.
Argument ten przyjmuje następujące wartości: -1
— porównania są przeprowadzane zgodnie z wartością ustawienia Option
Compare; 0
— przeprowadzane są porównania binarne;
1
— przeprowadzane są porównania tekstowe;
— porównania są przeprowadzane na podstawie informacji z bazy danych (dotyczy tylko Accessa).
2
InStrRev Przeznaczenie: InStrRev to funkcja tekstowa, która wyszukuje w łańcuchu znaków inny łańcuch i zwraca jego pozycję, licząc od końca przeszukiwanego łańcucha. Argumenty: InStrRev(Przeszukiwany łańcuch, Szukany łańcuch, Początek, Porównywanie)
Przeszukiwany łańcuch (wymagany) — przeszukiwany łańcuch znaków. Szukany łańcuch (wymagany) — szukany łańcuch znaków. Początek (opcjonalny) — numer znaku, od którego rozpoczynane jest wyszukiwanie. Wartość domyślna to 1. Porównywanie (opcjonalny) — określa sposób porównywania łańcuchów znaków.
Argument ten przyjmuje następujące wartości: -1
— porównania są przeprowadzana zgodnie z wartością ustawienia Option
Compare; 0
— przeprowadzane są porównania binarne;
1
— przeprowadzane są porównania tekstowe;
— porównania są przeprowadzane na podstawie informacji z bazy danych (dotyczy tylko Accessa).
2
Dodatek D Przegląd funkcji dla analityków danych
1107
IPmt Przeznaczenie: IPmt to funkcja finansowa, która umożliwia obliczenie odsetek dla raty annuitetowej w danym okresie. Annuitet to szereg stałych płatności gotówkowych dokonywanych w pewnym okresie. Argumenty: IPmt(Oprocentowanie, Okres, Okresy, Wartość bieżąca, Wartość przyszła, Typ)
Oprocentowanie (wymagany) — średnie oprocentowanie dla okresu. Okres (wymagany) — uwzględniany okres płatności. Okresy (wymagany) — łączna liczba płatności dla annuitetu. Wartość bieżąca (wymagany) — bieżąca wartość przyszłych płatności. Wartość przyszła (opcjonalny) — przyszła wartość lub ostateczne saldo pożyczki albo inwestycji po dokonaniu ostatniej płatności. Jeśli pominiesz ten argument, przyjęta zostanie wartość 0. Typ (opcjonalny) — określa termin płatności. Wartość 0 oznacza, że płatności należy dokonać na końcu okresu, natomiast wartość 1 informuje, że płatności są dokonywane na początku okresu. Wartością domyślną jest 0.
IRR Przeznaczenie: IRR to funkcja finansowa, która umożliwia obliczenie wewnętrznej stopy zwrotu dla serii okresowych przepływów pieniężnych, wydatków i dochodów. Argumenty: IRR(Wartości, Oszacowanie)
Wartości (wymagany) — wartości tworzą tablicę reprezentującą wysokość okresowych przepływów pieniężnych. Tablica ta musi zawierać przynajmniej po jednej wartości ujemnej i dodatniej. Oszacowanie (opcjonalny) — pozwala oszacować procentowy zwrot z całej
inwestycji. Jeśli pominiesz ten argument, przyjęta zostanie wartość 10%.
IsError Przeznaczenie: IsError to funkcja kontrolna sprawdzająca, czy wynik wykonania wyrażenia to błąd. Funkcja ta zwraca wartość True lub False. Argumenty: IsError(Wyrażenie)
Wyrażenie (wymagany) — dowolna wartość lub wyrażenie. W kwerendzie można
podać nazwę pola, aby określić, że aplikacja ma przetworzyć wartości z tego pola z wszystkich wierszy.
1108
Dodatki
IsNull Przeznaczenie: IsNull to funkcja kontrolna sprawdzająca, czy wartość jest pusta. Funkcja ta zwraca wartość True lub False. Argumenty: IsNull(Wyrażenie)
Wyrażenie (wymagany) — dowolna wartość lub wyrażenie. W kwerendzie można
podać nazwę pola, aby określić, że aplikacja ma przetworzyć wartości z tego pola z wszystkich wierszy.
IsNumeric Przeznaczenie: IsError to funkcja kontrolna sprawdzająca, czy wartość wyrażenia to liczba. Funkcja ta zwraca wartość True lub False. Argumenty: IsNumeric(Wyrażenie)
Wyrażenie (wymagany) — dowolna wartość lub wyrażenie. W kwerendzie
można podać nazwę pola, aby określić, że aplikacja ma przetworzyć wartości z tego pola z wszystkich wierszy.
LCase Przeznaczenie: Funkcja LCase zmienia wszystkie litery łańcucha znaków na małe. Argumenty: LCase(Łańcuch znaków)
Łańcuch znaków (wymagany) — przekształcany łańcuch znaków. W kwerendzie
można podać nazwę pola, aby określić, że aplikacja ma przetworzyć wartości z tego pola z wszystkich wierszy.
Left Przeznaczenie: Funkcja Left zwraca określoną liczbę znaków, począwszy od pierwszego znaku łańcucha. Na przykład wywołanie Left("Niechęć", 3) zwraca Nie. Argumenty: Left(Łańcuch znaków, Liczba znaków)
Łańcuch znaków (wymagany) — przetwarzany łańcuch znaków. W kwerendzie można podać nazwę pola, aby określić, że aplikacja ma przetworzyć wartości z tego pola z wszystkich wierszy. Liczba znaków (wymagany) — liczba zwracanych znaków. Jeśli wartość tego
argumentu jest równa lub większa względem liczby znaków łańcucha, zwracany jest cały łańcuch.
Dodatek D Przegląd funkcji dla analityków danych
1109
Len Przeznaczenie: Funkcja Len zwraca liczbę znaków łańcucha. Jest przydatna, gdy trzeba dynamicznie określić długość łańcucha. Na przykład wywołanie Len("Aleksander") zwraca 10. Argumenty: Len(Łańcuch znaków lub zmienna)
Łańcuch znaków lub zmienna (wymagany) — przetwarzany łańcuch znaków lub
zmienna. W kwerendzie można podać nazwę pola, aby określić, że aplikacja ma przetworzyć wartości z tego pola z wszystkich wierszy.
Liczba (wymagany) — przetwarzane wyrażenie liczbowe. Musi mieć wartość większą od zera.
Mid Przeznaczenie: Funkcja Mid zwraca określoną liczbę znaków, począwszy od podanej pozycji. Oto wymagane argumenty tej funkcji:
przetwarzany tekst,
początkowa pozycja,
liczba zwracanych znaków.
Na przykład wywołanie Mid("Stonka", 2, 3) zwraca ton — trzy znaki, począwszy od drugiego znaku. Argumenty: Mid(Łańcuch znaków, Początek, Liczba znaków)
Łańcuch znaków (wymagany) — przetwarzany łańcuch znaków. W kwerendzie można podać nazwę pola, aby określić, że aplikacja ma przetworzyć wartości z tego pola z wszystkich wierszy. Początek (wymagany) — pozycja znaku, od którego funkcja ma rozpocząć pobieranie. Liczba znaków (wymagany) — liczba pobieranych znaków. Jeśli argument ten
jest większy lub równy względem liczby znaków w łańcuchu, zwracany jest cały łańcuch od pozycji Początek. Jeżeli pominiesz ten argument (lub podasz wartość większą niż długość łańcucha), funkcja pobierze wszystkie znaki od pozycji Początek do końca łańcucha.
1110
Dodatki
Minute Przeznaczenie: Minute to funkcja, która przekształca czas na liczbę z przedziału od 0 do 59 reprezentującą minutę. Na przykład wywołanie Minute(#9:30:00 PM#) zwraca 30. Argumenty: Minute(Poprawny czas)
Poprawny czas (wymagany) — kombinacja wartości, które reprezentują poprawny czas. W kwerendzie można podać nazwę pola, aby określić, że aplikacja ma przetworzyć wartości z tego pola z wszystkich wierszy.
MIRR Przeznaczenie: MIRR to funkcja finansowa, która umożliwia obliczenie wewnętrznej stopy zwrotu dla serii okresowych przepływów pieniężnych, wydatków i dochodów z różną stopą procentową. Argumenty: MIRR(Wartości, Stopa finansowania, Stopa reinwestycji)
Wartości (wymagany) — wartości tworzące tablicę, która reprezentuje okresowe
przepływy pieniężne. Tablica ta musi zawierać przynajmniej po jednej wartości ujemnej i dodatniej. Stopa finansowania (wymagany) — oprocentowanie kosztów inwestycji.
Wartości tego argumentu trzeba podawać jako liczby dziesiętne. Stopa reinwestycji (wymagany) — oprocentowanie zysków z reinwestycji
pieniężnych. Wartości tego argumentu trzeba podawać jako liczby dziesiętne.
Month Przeznaczenie: Month to funkcja, która przekształca poprawną datę na liczbę z przedziału od 1 do 12 reprezentującą miesiąc. Na przykład wywołanie Month(#5/16/1972#) zwraca 5. Argumenty: Month(Poprawna data)
Poprawna data (wymagany) — dowolna wartość reprezentująca poprawną datę.
W kwerendzie można podać nazwę pola, aby określić, że aplikacja ma przetworzyć wartości z tego pola z wszystkich wierszy.
MonthName Przeznaczenie: MonthName to funkcja, która przekształca numer miesiąca (z przedziału od 1 do 12) na jego nazwę. Na przykład wywołanie MonthName(8) zwraca sierpień. Wartości mniejsze niż 1 i większe niż 12 powodują błąd.
Dodatek D Przegląd funkcji dla analityków danych
1111
Argumenty: MonthName(Numer miesiąca, Skrót)
Numer miesiąca (wymagany) — liczba z przedziału od 1 do 12 reprezentująca
miesiąc. 1 to styczeń, 2 to luty itd. Skrót (opcjonalny) — określa, czy funkcja ma zwrócić skróconą nazwę miesiąca. Jeśli nie podasz argumentu, funkcja zwróci pełną nazwę. Aby otrzymać skrót, podaj argument 1.
Now Przeznaczenie: Funkcja Now zwraca bieżącą datę i godzinę na podstawie daty i godziny systemowej. Argumenty: Funkcja ta nie przyjmuje argumentów. Aby ją wywołać, napisz Now().
NPer Przeznaczenie: NPer to funkcja finansowa, która określa liczbę okresów dla raty annuitetowej opartej na okresowych, stałych płatnościach i stałym oprocentowaniu. Annuitet to szereg stałych płatności gotówkowych (zwykle rat pożyczki spłacanych przez określony czas). Argumenty: NPer(Oprocentowanie, Kwota, Obecna wartość, Przyszła wartość, Typ)
Oprocentowanie (wymagany) — średnie oprocentowanie dla okresu. Kwota (wymagany) — kwota płatności (zwykle obejmuje część kapitałową
i odsetkową). Obecna wartość (wymagany) — obecna wartość przyszłych płatności i wpływów. Przyszła wartość (opcjonalny) — przyszła wartość lub ostateczne saldo dla pożyczki albo inwestycji po dokonaniu ostatniej płatności. Jeśli pominiesz ten argument, przyjęta zostanie wartość 0. Typ (opcjonalny) — określa, kiedy należy dokonywać płatności. Wartość 0 oznacza, że płatności są dokonywane pod koniec okresu, a przy wartości 1
płatności należy dokonywać na początku okresu. Jeśli pominiesz ten argument, zastosowana zostanie wartość 0.
NPV Przeznaczenie: NPV to funkcja finansowa, która oblicza obecną wartość netto lub obecną wartość szeregu przyszłych wartości i wpływów na podstawie serii okresowych przepływów pieniężnych, płatności, wpływów oraz stopy dyskonta.
1112
Dodatki
Argumenty: NPV(Stopa dyskonta, Wartości)
Stopa dyskonta (wymagany) — stopa dyskonta dla całego okresu. Wartości tego argumentu muszą być liczbami dziesiętnymi. Wartości (wymagany) — wartości tworzące tablicę, która reprezentuje okresowe
przepływy pieniężne. Tablica ta musi zawierać przynajmniej po jednej wartości ujemnej i dodatniej.
NZ Przeznaczenie: Funkcja NZ pozwala nakazać Accessowi, aby podstawiał za Null inną wartość. Zapobiega to stosowaniu wartości Null w wyrażeniach. Argumenty: NZ(Dane, Wartość zamiast Null)
Dane (wymagany) — przetwarzane dane. Wartość zamiast Null (wymagany) — wartość zwracana, jeśli Dane to Null.
Partition Przeznaczenie: Partition to funkcja bazodanowa. Określa przedział, do którego należy dana liczba, i zwraca łańcuch znaków z nazwą tego przedziału. Funkcja ta przydaje się do szybkiego i łatwego tworzenia rozkładu częstości. Argumenty: Partition(Liczba, Początek, Koniec, Krok)
Liczba (wymagany) — sprawdzana liczba. W kwerendzie można podać nazwę
pola, aby określić, że aplikacja ma przetworzyć wartości z tego pola z wszystkich wierszy. Początek (wymagany) — liczba całkowita określająca początek wszystkich
przedziałów. Nie może być mniejsza od zera. Koniec (wymagany) — liczba całkowita określająca koniec wszystkich przedziałów. Musi być większa niż Początek. Krok (wymagany) — liczba całkowita określająca wielkość przedziałów w zakresie od Początek do Koniec. Nie może być mniejsza niż 1.
Pmt Przeznaczenie: Pmt to funkcja finansowa, która oblicza wartość raty annuitetowej opartej na stałych, okresowych płatnościach i stałym oprocentowaniu. Annuitet to szereg stałych płatności gotówkowych (zwykle rat pożyczki spłacanych przez określony czas).
Dodatek D Przegląd funkcji dla analityków danych
1113
Argumenty: Pmt(Oprocentowanie, Okresy, Wartość bieżąca, Wartość przyszła, Typ)
Oprocentowanie (wymagany) — średnie oprocentowanie dla okresu. Okresy (wymagany) — łączna liczba płatności dla annuitetu. Wartość bieżąca (wymagany) — bieżąca wartość przyszłych płatności i wpływów. Wartość przyszła (opcjonalny) — przyszła wartość lub ostateczne saldo pożyczki albo inwestycji po dokonaniu ostatniej płatności. Jeśli pominiesz ten argument, przyjęta zostanie wartość 0. Typ (opcjonalny) — określa termin płatności. Wartość 0 oznacza, że płatności należy dokonywać na końcu okresu, natomiast wartość 1 informuje, że płatności są dokonywane na początku okresu. Wartością domyślną jest 0.
PPmt Przeznaczenie: PPmt to funkcja finansowa, która oblicza spłaty kapitału w podanym okresie z annuitetu. Annuitet to szereg stałych płatności gotówkowych (zwykle rat pożyczki spłacanych przez określony czas). Argumenty: PPmt(Oprocentowanie, Okres, Okresy, Wartość bieżąca, Wartość przyszła, Typ)
Oprocentowanie (wymagany) — średnie oprocentowanie dla okresu. Okres (wymagany) — uwzględniany okres płatności. Okresy (wymagany) — łączna liczba płatności dla annuitetu. Wartość bieżąca (wymagany) — bieżąca wartość przyszłych płatności i wpływów. Wartość przyszła (opcjonalny) — przyszła wartość lub ostateczne saldo pożyczki albo inwestycji po dokonaniu ostatniej płatności. Jeśli pominiesz ten argument, przyjęta zostanie wartość 0. Typ (opcjonalny) — określa termin płatności. Wartość 0 oznacza, że płatności należy dokonywać na końcu okresu, natomiast wartość 1 informuje, że płatności są dokonywane na początku okresu. Wartością domyślną jest 0.
PV Przeznaczenie: PV to funkcja finansowa, która umożliwia obliczenie bieżącej wartości raty annuitetowej. Annuitet to szereg stałych płatności gotówkowych (zwykle rat pożyczki spłacanych przez określony czas). Argumenty: PV(Oprocentowanie, Okresy, Kwota, Wartość przyszła, Typ)
Oprocentowanie (wymagany) — średnie oprocentowanie dla okresu.
1114
Dodatki Okresy (wymagany) — łączna liczba płatności dla annuitetu. Kwota (wymagany) — kwota płatności (zwykle obejmuje część kapitałową
i odsetkową). Wartość przyszła (opcjonalny) — przyszła wartość lub ostateczne saldo pożyczki albo inwestycji po dokonaniu ostatniej płatności. Jeśli pominiesz ten argument, przyjęta zostanie wartość 0. Typ (opcjonalny) — określa termin płatności. Wartość 0 oznacza, że płatności należy dokonywać na końcu okresu, natomiast wartość 1 informuje, że płatności są dokonywane na początku okresu. Wartością domyślną jest 0.
Rate Przeznaczenie: Rate to funkcja finansowa, która umożliwia obliczenie oprocentowania dla jednego okresu raty annuitetowej. Annuitet to szereg stałych płatności gotówkowych (zwykle rat pożyczki spłacanych przez określony czas). Argumenty: Rate(Okresy, Kwota, Wartość bieżąca, Wartość przyszła, Typ, Oszacowanie)
Okresy (wymagany) — łączna liczba okresów dla annuitetu. Kwota (wymagany) — kwota płatności (zwykle obejmuje część kapitałową
i odsetkową). Wartość bieżąca (wymagany) — bieżąca wartość przyszłych płatności i wpływów. Wartość przyszła (opcjonalny) — przyszła wartość lub ostateczne saldo
pożyczki albo inwestycji po dokonaniu ostatniej płatności. Jeśli pominiesz ten argument, przyjęta zostanie wartość 0. Typ (opcjonalny) — określa termin płatności. Wartość 0 oznacza, że płatności należy dokonywać na końcu okresu, natomiast wartość 1 informuje, że płatności są dokonywane na początku okresu. Wartością domyślną jest 0. Oszacowanie (opcjonalny) — pozwala oszacować procentowy zwrot z całej
inwestycji. Jeśli pominiesz ten argument, przyjęta zostanie wartość 10%.
Replace Przeznaczenie: Funkcja Replace zastępuje określony podłańcuch innym podłańcuchem. Działa tak samo jak mechanizm Znajdź i zastąp. Na przykład wywołanie Replace("Byk", "y", "a") zwraca Bak. Argumenty: Replace(Łańcuch znaków, Szukany, Zastępnik, Początek, Ile, Porównywanie)
Łańcuch znaków (wymagany) — cały przetwarzany łańcuch znaków. W kwerendzie
można podać nazwę pola, aby określić, że aplikacja ma przetworzyć wartości z tego pola z wszystkich wierszy.
Dodatek D Przegląd funkcji dla analityków danych
1115
Szukany (wymagany) — podłańcuch, który funkcja ma znaleźć i zastąpić. Zastępnik (wymagany) — podstawiany podłańcuch. Początek (opcjonalny) — pozycja, od której funkcja ma zacząć szukanie podłańcucha (wartość domyślna to 1). Ile (opcjonalny) — liczba zastępowanych wystąpień podłańcucha. Domyślnie zastępowane są wszystkie wystąpienia. Porównywanie (opcjonalny) — określa sposób porównywania łańcuchów znaków.
Argument ten przyjmuje następujące wartości: -1
— porównania są przeprowadzana zgodnie z wartością ustawienia Option
Compare; 0
— przeprowadzane są porównania binarne;
1
— przeprowadzane są porównania tekstowe;
— porównania są przeprowadzane na podstawie informacji z bazy danych (dotyczy tylko Accessa).
2
Right Przeznaczenie: Funkcja Right zwraca określoną liczbę znaków, począwszy od ostatniego znaku łańcucha. Na przykład wywołanie Right("Niechęć", 3) zwraca chęć. Argumenty: Right(Łańcuch znaków, Liczba znaków)
Łańcuch znaków (wymagany) — przetwarzany łańcuch znaków. W kwerendzie można podać nazwę pola, aby określić, że aplikacja ma przetworzyć wartości z tego pola z wszystkich wierszy. Liczba znaków (wymagany) — liczba zwracanych znaków. Jeśli wartość tego
argumentu jest równa lub większa względem liczby znaków łańcucha, zwracany jest cały łańcuch.
Rnd Przeznaczenie: Rnd to funkcja matematyczna generująca i zwracająca liczbę losową większą lub równą 0, ale mniejszą niż 1. Argumenty: Rnd(Liczba)
Liczba (opcjonalny) — wyrażenie liczbowe określające sposób generowania liczby losowej. Funkcja Rnd działa według następujących reguł:
Jeśli argument Liczba nie jest podany, generowana jest następna liczba losowa z sekwencji.
1116
Dodatki
Jeśli argument Liczba ma wartość mniejszą niż zero, za każdym razem generowana jest ta sama liczba.
Jeśli argument Liczba ma wartość większą niż zero, generowana jest następna liczba losowa z sekwencji.
Jeśli argument Liczba to zero, zwracana jest ostatnio wygenerowana wartość.
Round Przeznaczenie: Round to funkcja matematyczna, która zaokrągla wartość do określonej liczby miejsc po przecinku. Na przykład wywołanie Round(456.7276) zwraca 456. Argumenty: Round(Liczba, Miejsc po przecinku)
Liczba (wymagany) — przetwarzane wyrażenie liczbowe. W kwerendzie można
podać nazwę pola, aby określić, że aplikacja ma przetworzyć wartości z tego pola z wszystkich wierszy. Miejsc po przecinku (opcjonalny) — liczba miejsc po przecinku zwracanych w zaokrąglonej wartości. Jeśli nie podasz tego argumentu, funkcja Round zwróci
liczbę całkowitą (bez miejsc po przecinku).
Second Przeznaczenie: Second to funkcja, która przekształca czas na liczbę z przedziału od 0 do 59 reprezentującą sekundę. Na przykład wywołanie Second(#9:30:35 PM#) zwraca 35. Argumenty: Second(Poprawny czas)
Poprawny czas (wymagany) — kombinacja wartości, które reprezentują poprawny
czas. W kwerendzie można podać nazwę pola, aby określić, że aplikacja ma przetworzyć wartości z tego pola z wszystkich wierszy.
Sgn Przeznaczenie: Sgn to funkcja matematyczna, która zwraca całkowitoliczbowy kod określający znak danej liczby. Jeśli liczba jest mniejsza od zera (jest liczbą ujemną), funkcja Sgn zwraca -1. Jeżeli liczba jest równa zero, funkcja zwraca 0. Dla liczb większych od zera (dodatnich) funkcja zwraca 1. Argumenty: Sgn(Liczba)
Liczba (wymagany) — przetwarzane wyrażenie liczbowe.
Dodatek D Przegląd funkcji dla analityków danych
1117
Sin Przeznaczenie: Sin to funkcja matematyczna, która oblicza sinus kąta. Argumenty: Sin(Liczba)
Liczba (wymagany) — wyrażenie liczbowe określające kąt w radianach.
SLN Przeznaczenie: SLN to funkcja finansowa, która oblicza amortyzację środka trwałego, obliczoną metodą liniową dla pojedynczego okresu. Argumenty: SLN(Koszt, Odzysk, Okres użytkowania)
Koszt (wymagany) — początkowy koszt środka trwałego (musi być liczbą dodatnią). Odzysk (wymagany) — wartość środka trwałego pod koniec okresu użytkowania
(musi być liczbą dodatnią). Okres użytkowania (wymagany) — okres użytkowania środka trwałego.
Space Przeznaczenie: Funkcja Space umożliwia utworzenie łańcucha znaków z dołączoną określoną liczbą spacji. Jest przydatna, gdy trzeba utworzyć łańcuchy znaków o stałej długości. Można ją zastosować na przykład w wyrażeniu Space(5) & "Access", Access". aby przekształcić "Access" na " Argumenty: Space(Liczba)
Liczba (wymagany) — liczba odstępów dodawanych do łańcucha znaków.
Funkcje agregujące SQL-a Przeznaczenie: Funkcje agregujące SQL-a to najczęściej stosowane funkcje w Accessie. Wykonują obliczenia matematyczne lub wyznaczają wartości na podstawie danego wyrażenia. Zwykle stosuje się je w kwerendach, gdzie argument Wyrażenie określa pole tabeli. Funkcja przetwarza wtedy wartości z tego pola z wszystkich wierszy. oblicza sumę wartości z określonego pola dla wszystkich rekordów lub dla grupy. Działa dla następujących typów danych: Autonumerowanie, Waluta, Data/Godzina i Liczba.
Sum(Wyrażenie) —
1118
Dodatki
oblicza średnią wartości z określonego pola dla wszystkich rekordów lub dla grupy. Działa dla następujących typów danych: Autonumerowanie, Waluta, Data/Godzina i Liczba.
Avg(Wyrażenie) —
zwraca liczbę elementów z określonego pola lub grupy. Działa dla wszystkich typów danych.
Count(Wyrażenie) —
oblicza odchylenie standardowe wartości z określonego pola dla wszystkich rekordów lub dla grupy. Działa dla następujących typów danych: Autonumerowanie, Waluta, Data/Godzina i Liczba.
StDev(Wyrażenie) —
oblicza wariancję wartości z określonego pola dla wszystkich rekordów lub dla grupy. Działa dla następujących typów danych: Autonumerowanie, Waluta, Data/Godzina i Liczba.
Var(Wyrażenie) —
zwraca najmniejszą wartość określonego pola dla wszystkich rekordów lub dla grupy. Działa dla następujących typów danych: Autonumerowanie, Waluta, Data/Godzina, Liczba i Krótki tekst.
Min(Wyrażenie) —
zwraca największą wartość określonego pola dla wszystkich rekordów lub dla grupy. Działa dla następujących typów danych: Autonumerowanie, Waluta, Data/Godzina, Liczba i Krótki tekst.
Max(Wyrażenie) —
zwraca pierwszy rekord spośród wszystkich rekordów lub dla grupy. Działa dla wszystkich typów danych.
First(Wyrażenie) —
zwraca ostatni rekord spośród wszystkich rekordów lub dla grupy. Działa dla wszystkich typów danych.
Last(Wyrażenie) —
Sqr Przeznaczenie: Sqr to funkcja matematyczna obliczająca pierwiastek kwadratowy z danej liczby. Argumenty: Sqr(Liczba)
Liczba (wymagany) — przetwarzane wyrażenie liczbowe.
Str Przeznaczenie: Str to funkcja przekształcająca liczbę na jej łańcuchową reprezentację. Na przykład wywołanie Str(2304) zwraca " 2304". Liczby dodatnie przekształcane za pomocą tej funkcji zawsze mają na początku spację. Odpowiada ona znakowi plus. Początkowym znakiem dla liczb ujemnych jest minus. Argumenty: Str(Liczba)
Liczba (wymagany) — liczba przekształcana na łańcuch znaków. W kwerendzie
można podać nazwę pola, aby określić, że aplikacja ma przetworzyć wartości z tego pola z wszystkich wierszy.
Dodatek D Przegląd funkcji dla analityków danych
1119
StrConv Przeznaczenie: StrConv to funkcja przekształcająca litery łańcucha na wielkie, małe lub na notację z wielkimi literami na początkach słów. Na przykład wywołanie StrConv("to tekst", 3) przekształca pierwsze litery słów na wielkie, dlatego zwraca "To Tekst". Argumenty: StrConv(Łańcuch znaków, Typ konwersji, LCID)
Łańcuch znaków (wymagany) — przekształcany łańcuch znaków. W kwerendzie
można podać nazwę pola, aby określić, że aplikacja ma przetworzyć wartości z tego pola z wszystkich wierszy. Typ konwersji (wymagany) — typ konwersji określa sposób przekształcania łańcucha znaków. Określa się go za pomocą poniższych stałych: 1
— litery łańcucha znaków są przekształcane na wielkie;
2
— litery łańcucha znaków są przekształcane na małe;
— pierwsza litera każdego słowa łańcucha znaków jest przekształcana na wielką;
3
— łańcuch znaków jest przekształcany na format Unicode za pomocą domyślnego kodowania systemowego;
64
— łańcuch znaków jest przekształcany z formatu Unicode na domyślne kodowanie systemowe.
128
LCID (opcjonalny) — wybrany identyfikator LocaleID. Domyślnie używany jest
Długość łańcucha (wymagany) — liczba powtórzeń znaku Znak. Znak (wymagany) — znak powielany w łańcuchu. Jeśli wpiszesz kilka znaków,
funkcja wykorzysta tylko pierwszy z nich.
StrReverse Przeznaczenie: Funkcja StrReverse zwraca wyrażenie w odwrotnej kolejności. Na przykład wywołanie StrReverse("sok") zwraca kos. Funkcja ta działa także dla liczb — wywołanie StrReverse(5432) zwraca 2345.
1120
Dodatki
Argumenty: StrReverse(Wyrażenie)
Wyrażenie (wymagany) — wyrażenie zawierające znaki, których kolejność funkcja ma odwrócić.
Switch Przeznaczenie: Switch to funkcja sterowania przepływem programu. Sprawdza listę wyrażeń i zwraca wartość powiązaną z wyrażeniem o wartości True. W funkcji tej należy umieścić przynajmniej jedno wyrażenie i jedną wartość. Argumenty: Switch(Wyrażenie, Wartość)
Wyrażenie (wymagany) — sprawdzane wyrażenie. Wartość (wymagany) — wartość zwracana, jeśli wyrażenie ma wartość True.
Aby sprawdzić zestaw wyrażeń, wystarczy dodać do funkcji kolejne pary wyrażenie – wartość (np. Switch(Wyrażenie1, Wartość1, Wyrażenie2, Wartość2, Wyrażenie3, Wartość3)). Po wywołaniu funkcji Switch sprawdzane jest każde wyrażenie. Jeśli dane wyrażenie ma wartość True, funkcja zwraca wartość powiązaną z tym wyrażeniem. Jeżeli kilka wyrażeń ma wartość True, zwracana jest wartość powiązana z pierwszym takim wyrażeniem.
SYD Przeznaczenie: SYD to funkcja finansowa zwracająca amortyzację środka trwałego w podanym okresie metodą sumy cyfr wszystkich lat amortyzacji. Argumenty: SYD(Koszt, Odzysk, Okres użytkowania, Okres)
Koszt (wymagany) — początkowy koszt środka trwałego (musi być liczbą
dodatnią). Odzysk (wymagany) — wartość środka trwałego pod koniec okresu użytkowania
(musi być liczbą dodatnią). Okres użytkowania (wymagany) — okres użytkowania środka trwałego. Okres (wymagany) — okres, dla którego obliczana jest amortyzacja środka trwałego.
Dodatek D Przegląd funkcji dla analityków danych
1121
Tan Przeznaczenie: Tan to funkcja matematyczna obliczająca tangens kąta. Argumenty: Tan(Liczba)
Liczba (wymagany) — wyrażenie liczbowe określające kąt w radianach.
Time Przeznaczenie: Funkcja Time zwraca bieżący czas na podstawie czasu systemowego komputera. Doskonale nadaje się do dodawania znaczników czasu do transakcji. Argumenty: Funkcja ta nie ma argumentów. Aby ją wywołać, wystarczy napisać Time().
TimeSerial Przeznaczenie: Funkcja TimeSerial tworzy godzinę na podstawie jej komponentów (godziny, minuty i sekundy). Warto pamiętać, że funkcja ta działa w systemie 24-godzinnym, dlatego wywołanie TimeSerial(18, 30, 0) zwraca 18:30:00. Funkcja ta doskonale nadaje się do przekształcania w godzinę odrębnych łańcuchów reprezentujących czas. Argumenty: TimeSerial(Godzina, Minuta, Sekunda)
Godzina (wymagany) — liczba lub wyrażenie liczbowe o wartości z przedziału od 0 do 23. W kwerendzie można podać nazwę pola, aby określić, że aplikacja ma przetworzyć wartości z tego pola z wszystkich wierszy (to samo dotyczy wszystkich argumentów funkcji). Minuta (wymagany) — liczba lub wyrażenie liczbowe. Jeśli podana wartość wykracza poza liczbę minut w godzinie, funkcja zwiększa godzinę. Na przykład wywołanie TimeSerial(7, 90, 00) zwraca 8:30:00. Sekunda (wymagany) — liczba lub wyrażenie liczbowe. Jeśli podana wartość wykracza poza liczbę sekund w minucie, funkcja zwiększa minutę. Na przykład wywołanie TimeSerial(7, 10, 75) zwraca 7:11:15.
TimeValue Przeznaczenie: Funkcja TimeValue przekształca łańcuchową reprezentację czasu w godzinę. Na przykład wywołanie TimeValue("16:20:37 PM") zwraca 16:20:37. Funkcja ta działa w systemie 24-godzinnym. Argumenty: TimeValue(Łańcuch znaków)
1122
Dodatki Łańcuch znaków (wymagany) — dowolny łańcuch znaków lub wyrażenie reprezentujące godzinę z przedziału od 0:00:00 do 23:59:59. Można podać godzinę w systemie 12- lub 24-godzinnym. W kwerendzie można podać nazwę pola, aby określić, że aplikacja ma przetworzyć wartości z tego pola z wszystkich wierszy.
Trim, LTrim, RTrim Przeznaczenie: Funkcja Trim usuwa początkowe i końcowe spacje z łańcucha znaków. Funkcja LTrim usuwa tylko spacje początkowe, a funkcja RTrim — tylko końcowe. Funkcje te są przydatne przy porządkowaniu danych z systemu mainframe. Argumenty: Trim(Łańcuch znaków) LTrim(Łańcuch znaków) RTrim(Łańcuch znaków)
Łańcuch znaków (wymagany) — używany łańcuch znaków. W kwerendzie można podać nazwę pola, aby określić, że aplikacja ma przetworzyć wartości z tego pola z wszystkich wierszy.
TypeName Przeznaczenie: TypeName to funkcja kontrolna zwracająca informacje o typie zmiennej. Na przykład wywołanie TypeName("Michał") zwraca String. Argumenty: TypeName(Zmienna)
Zmienna (wymagany) — sprawdzana zmienna. W kwerendzie można podać nazwę pola, aby określić, że aplikacja ma przetworzyć wartości z tego pola z wszystkich wierszy.
— dla liczb zmiennoprzecinkowych pojedynczej precyzji;
Double
— dla liczb zmiennoprzecinkowych podwójnej precyzji;
Currency Decimal Date
— dla wartości pieniężnych;
— dla wartości dziesiętnych;
— dla dat;
String
— dla łańcuchów znaków;
Dodatek D Przegląd funkcji dla analityków danych Boolean
— dla wartości logicznych;
Error
— dla błędów;
Empty
— dla niezainicjowanych zmiennych;
Null
1123
— dla zmiennych bez poprawnych danych (dla wartości Null);
Object
— dla obiektów;
Unknown
— dla danych nieznanego typu;
Nothing
— dla zmiennych obiektowych niepowiązanych z żadnym obiektem.
UCase Przeznaczenie: Funkcja UCase zmienia wszystkie litery łańcucha znaków na wielkie. Argumenty: UCase(Łańcuch znaków)
Łańcuch znaków (wymagany) — przekształcany łańcuch znaków. W kwerendzie
można podać nazwę pola, aby określić, że aplikacja ma przetworzyć wartości z tego pola z wszystkich wierszy.
Val Przeznaczenie: Funkcja Val służy do przekształcania danych. Pobiera część liczbową z łańcucha znaków. Na przykład wywołanie Val("5400 złotych") zwraca 5400. Warto pamiętać o pewnym zastrzeżeniu: funkcja Val przestaje wczytywać łańcuch znaków po napotkaniu tekstu. Dlatego pobierana liczba musi znajdować się na początku łańcucha. Argumenty: Val(Łańcuch znaków)
Łańcuch znaków (wymagany) — przetwarzany łańcuch znaków. W kwerendzie można podać nazwę pola, aby określić, że aplikacja ma przetworzyć wartości z tego pola z wszystkich wierszy.
VarType Przeznaczenie: VarType to funkcja kontrolna zwracająca kod podtypu powiązany z typem danych w zmiennej Variant. Na przykład wywołanie VarType("Michał") zwraca 8, ponieważ jest to kod podtypu dla łańcuchów znaków. Argumenty: VarType(Zmienna typu Variant)
Zmienna typu Variant (wymagany) — sprawdzana zmienna typu Variant.
W kwerendzie można podać nazwę pola, aby określić, że aplikacja ma przetworzyć wartości z tego pola z wszystkich wierszy.
1124
Dodatki
Poniższa lista przedstawia kody podtypów zwracane przez funkcję VarType: 0
— pusta (niezainicjowana) zmienna;
1
— Null (bez poprawnych danych);
2
— liczba całkowita;
3
— długa liczba całkowita;
4
— liczba zmiennoprzecinkowa pojedynczej precyzji;
5
— liczba zmiennoprzecinkowa podwójnej precyzji;
6
— wartość pieniężna;
7
— data;
8
— łańcuch znaków;
9
— obiekt;
10
— błąd;
11
— wartość logiczna;
12
— wartość typu Variant (używana tylko dla tablic elementów typu Variant);
13
— obiekt dostępu do danych;
14
— liczba dziesiętna;
17
— wartość bajtowa;
36
— wartość typu Variant z obiektem typu zdefiniowanego przez użytkownika;
8192
— tablica.
Weekday Przeznaczenie: Funkcja Weekday zwraca liczbę z przedziału od 1 do 7 reprezentującą dzień tygodnia z podanej daty. Liczba 1 odpowiada niedzieli, 2 to poniedziałek itd. Na przykład wywołanie Weekday(#12/31/1997#) zwraca 4. Argumenty: Weekday(Poprawna data, Pierwszy dzień tygodnia)
Poprawna data (wymagany) — dowolna wartość reprezentująca poprawną datę. W kwerendzie można podać nazwę pola, aby określić, że aplikacja ma przetworzyć wartości z tego pola z wszystkich wierszy. Pierwszy dzień tygodnia (opcjonalny) — określa, który dzień funkcja ma przyjąć za pierwszy dzień tygodnia. Wpisz 1, aby pierwszym dniem była niedziela, 2, aby jako pierwszy dzień ustawić poniedziałek, 3, by wybrać wtorek itd. Jeśli
nie podasz żadnej wartości, domyślnie pierwszym dniem tygodnia będzie niedziela. Jeżeli w danej części świata niedziela nie jest pierwszym dniem tygodnia, można zastosować ten opcjonalny argument.
Dodatek D Przegląd funkcji dla analityków danych
1125
WeekdayName Przeznaczenie: Funkcja WeekdayName przekształca numer dnia tygodnia (od 1 do 7) na nazwę dnia. Na przykład wywołanie WeekdayName(7) zwraca niedziela. Wartości mniejsze niż 1 lub większe niż 7 powodują błąd. Argumenty: WeekdayName(Numer dnia, Skrót, Pierwszy dzień tygodnia)
Numer dnia (wymagany) — liczba od 1 do 7 reprezentująca dzień tygodnia. 1 to poniedziałek, 2 to wtorek itd. Skrót (opcjonalny) — określa, czy funkcja ma zwrócić skrót nazwy tygodnia.
Jeśli pominiesz ten argument, funkcja zwróci pełną nazwę. Aby uzyskać skrót, podaj 1. Pierwszy dzień tygodnia (opcjonalny) — określa, który dzień funkcja ma przyjąć za pierwszy dzień tygodnia. Wpisz 1, aby pierwszym dniem była niedziela, 2, aby jako pierwszy dzień ustawić poniedziałek, 3, by wybrać wtorek
itd. Jeśli nie podasz żadnej wartości, domyślnie pierwszym dniem tygodnia będzie poniedziałek.
Year Przeznaczenie: Funkcja Year zwraca liczbę całkowitą reprezentującą rok z podanej daty. Na przykład wywołanie Year(#5/16/1972#) zwraca 1972. Argumenty: Year(Poprawna data)
Poprawna data (wymagany) — dowolna wartość reprezentująca poprawną datę. W kwerendzie można podać nazwę pola, aby określić, że aplikacja ma przetworzyć wartości z tego pola z wszystkich wierszy.
L linia sprzężenia, 268 linie pionowe, 633 lista rozwijana, 541 Typ danych, 76 wartości, 306 listy SharePointa, 996, 1002 lokalizacja bazy danych, 243 losowe próbki danych, 454
Ł ładowanie modułu, 1066 łamanie reguł, 128 łańcuch połączeniowy, 900 łącza do tabel, 239 łączenie parametrów z operatorami, 396 parametrów z symbolami wieloznacznymi, 397 tabel, 222 z ODBC, 228
zmiana projektu tabeli, 83 rozmiaru formantu, 484 formularza, 474 kolumn, 257 pola, 84, 594 sekcji, 590, 604 typu formantu, 489 układu formularza, 523 wielkości liter, 361 właściwości etykiet, 598 właściwości formantu, 494 właściwości pól tekstowych, 598
Access 2013 Keyboard ShortcutsAccess app shortcut keys Design-time shortcut keys These shortcut keys are available when you are customizing an app in Access. Many of the shortcuts listed under Desktop database shortcut keys are also available when cu