---
title: "XML w chmurze"
date: "2011-01-07"
categories: 
  - "hardware"
tags: 
  - "cloud-services"
  - "databasespy"
  - "missionkit"
description: Odkryj, jak połączyć narzędzia Altova z Amazon RDS, jak utworzyć bazę danych MySQL i jak wykorzystać funkcje XML do tworzenia aplikacji bazodanowych działających w chmurze.
---
Status: #blog

Tags:  #cloud-services #databasespy #missionkit

Categories: [xml](/blog/pl/category/xml.md) [cloud](/blog/pl/category/cloud.md)
# XML w chmurze

## Praca z narzędziami Altova oraz z usługą Amazon Relational Database Service (Amazon RDS)

Coraz więcej firm odkrywa zalety wdrażania aplikacji bazodanowych w chmurze:

- Wysoka dostępność i niezawodność
- Automatyczne skalowanie
- Brak kosztów związanych z zakupem sprzętu oraz eliminacja kosztów utrzymania

W tym wpisie na blogu pokazujemy, jak połączyć się z usługą Amazon Relational Database Service (Amazon RDS) i utworzyć małą bazę danych za pomocą programu Altova [DatabaseSpy](https://www.altova.com/pl/databasespy.html). Ponieważ kreator połączenia z bazą danych jest spójny we wszystkich produktach [Altova MissionKit](https://www.altova.com/pl/missionkit/software-development-tools.html), można się połączyć w ten sam sposób, korzystając z programów [XMLSpy](https://www.altova.com/pl/xmlspy.html), [MapForce](https://www.altova.com/pl/mapforce.html) lub [StyleVision](https://www.altova.com/pl/stylevision.html). 

Jeśli chcieliby Państwo samodzielnie wykonać kroki opisane poniżej, konieczne będzie założenie konta w Amazon Web Services (AWS) na stronie: [http://aws.amazon.com/rds/](http://aws.amazon.com/rds/). Można również pobrać w pełni funkcjonalną wersję próbną pakietu Altova MissionKit lub dowolnej pojedynczej aplikacji Altova na stronie: [https://www.altova.com/download-trial/](https://www.altova.com/pl/download-trial/)

##### Stwórz lokalny prototyp

Amazon RDS opiera się na systemie MySQL, dlatego najpierw stworzymy małą, lokalną bazę danych w wersji Community Edition systemu MySQL, a następnie przeniesiemy ją do Amazon RDS i przetestujemy w chmurze. Chociaż MySQL nie obsługuje XML jako typu danych dla kolumn baz danych, wersje 5.1 i 6.0 obsługują niektóre operacje na danych XML przechowywanych jako tekst. W tym ćwiczeniu wykorzystamy i rozbudujemy niektóre przykłady użycia XML w MySQL, dostępne w dokumentacji MySQL, pod adresemi:
[http://dev.mysql.com/doc/refman/5.1/en/xml-functions.html](http://dev.mysql.com/doc/refman/5.1/en/xml-functions.html) [http://dev.mysql.com/tech-resources/articles/xml-in-mysql5.1-6.0.html](http://dev.mysql.com/tech-resources/articles/xml-in-mysql5.1-6.0.html) [http://dev.mysql.com/tech-resources/articles/mysql-5.1-xml.html](http://dev.mysql.com/tech-resources/articles/mysql-5.1-xml.html)
Najpierw uruchomiliśmy program DatabaseSpy i połączyliśmy się z lokalną instalacją MySQL Community Edition. Stworzyliśmy nowe źródło danych o nazwie LocalPrototype oraz nową strukturę bazy danych, którą nazwaliśmy XMLtest. Poniżej przedstawiono okna przeglądarki online i okno właściwości DatabaseSpy: 

[![Okna projektu i właściwości DatabaseSpy](https://lh3.ggpht.com/_REdrfeVqYdU/TSYvog3-1xI/AAAAAAAAAQc/FmMFHyM0-yc/blogSnap1_thumb%5B1%5D.png?imgmax=800 "DatabaseSpy Project and Properties windows")](http://lh6.ggpht.com/_REdrfeVqYdU/TSYvoDdXvWI/AAAAAAAAAQU/qEea5H03j3U/s1600-h/blogSnap1%5B3%5D.png) 

Następnie utworzyliśmy dwie tabele o nazwach "books" (książki) i "cities" (miasta) oraz wstawiliśmy dane, kierując się przykładami zawartymi w dokumentacji MySQL. Poniżej przedstawiamy widok projektowy naszych tabel w programie DatabaseSpy: 

[![Widok projektowania bazy danych w DatabaseSpy](https://lh5.ggpht.com/_REdrfeVqYdU/TSYvpYyta6I/AAAAAAAAAQk/3oJcRfcVafs/blogSnap2_thumb%5B1%5D.png?imgmax=800 "DatabaseSpy Design View")](http://lh5.ggpht.com/_REdrfeVqYdU/TSYvpNqGrlI/AAAAAAAAAQg/m15NZt1yLgU/s1600-h/blogSnap2%5B3%5D.png) 

Możemy wykonywać określone zapytania i wyświetlać zawartość naszych tabel w oknach wyświetlających wyniki w formie ułożonej w kolumnach

[![Okna wyświetlające wyniki w formie ułożonej w stos](https://lh6.ggpht.com/_REdrfeVqYdU/TSYvxCJz7BI/AAAAAAAAAQs/KrKbkgW_cKc/blogSnap3_thumb%5B1%5D.png?imgmax=800 "DatabaseSpy stacked results windows")](http://lh5.ggpht.com/_REdrfeVqYdU/TSYvqaOVCqI/AAAAAAAAAQo/sDFsYLrNi7k/s1600-h/blogSnap3%5B3%5D.png)

Należy pamiętać, że kolumna "doc" w tabeli "books" zawiera dane w formacie XML, mimo że została zdefiniowana jako varchar(150). MySQL obsługuje dwie funkcje do pracy z XML w polach tekstowych: ExtractValue() i UpdateXML(), które mogą operować na poszczególnych elementach za pomocą wyrażeń XPath. Poniżej znajduje się proste zapytanie ExtractValue(), które zwraca tylko inicjały autora z każdego wiersza w tabeli "books": 

[![Funkcja `ExtractValue()`](https://lh3.ggpht.com/_REdrfeVqYdU/TSYvyNUEhfI/AAAAAAAAAQ0/JOPn0w1ZAOA/blogSnap4_thumb%5B1%5D.png?imgmax=800 "ExtractValue( ) function")](http://lh4.ggpht.com/_REdrfeVqYdU/TSYvxiQrogI/AAAAAAAAAQw/rlT5OA5cB-M/s1600-h/blogSnap4%5B3%5D.png) 

Funkcja UpdateXML() może być używana do modyfikowania zawartości poszczególnych elementów XML za pomocą wyrażenia SQL. Na poniższym zrzucie ekranu, zapytanie na linii 1 aktualizuje wszystkie wiersze w naszej tabeli "books", a zapytanie na linii 2 zwraca nowe wartości: 

[![Funkcja `UpdateXML()`](https://lh4.ggpht.com/_REdrfeVqYdU/TSYvyzem2KI/AAAAAAAAAQ8/BCW9ZEzc77k/blogSnap5_thumb%5B1%5D.png?imgmax=800 "UpdateXML( ) function")](http://lh5.ggpht.com/_REdrfeVqYdU/TSYvyTiRDNI/AAAAAAAAAQ4/qna29a6Bw6o/s1600-h/blogSnap5%5B3%5D.png)

Możemy również użyć funkcji Concat(), aby dodawać elementy XML do danych, które nie są w formacie XML, takich jak tabela miast, jak pokazano poniżej: 

[![Funkcja `Concat()`](https://lh3.ggpht.com/_REdrfeVqYdU/TSYvz4jJO8I/AAAAAAAAARE/GECrInoROUM/blogSnap6_thumb%5B1%5D.png?imgmax=800 "Concat( ) function")](http://lh4.ggpht.com/_REdrfeVqYdU/TSYvzdA02MI/AAAAAAAAARA/IHlT_sKpzAk/s1600-h/blogSnap6%5B3%5D.png)

Dotychczas nasze zapytania XML operowały na wszystkich wierszach każdej tabeli. Aby ułatwić wyszukiwanie pojedynczych wierszy, warto dodać do tabeli kolumnę zawierającą unikalny indeks wiersza. Możemy utworzyć kopię naszej tabeli "books" i dodać kolumnę o nazwie "id", która będzie przechowywać indeks wiersza. Kolumna "id" może również służyć jako wygodny klucz obcy, umożliwiający odniesienie się do konkretnego dokumentu XML w naszej tabeli z wiersza w innej tabeli. 

Na przykład, można zdefiniować jedną tabelę zawierającą nazwiska kandydatów do pracy, z kluczem obcym odwołującym się do życiorysu każdego kandydata, zapisanego w formacie XML i przechowywanego w oddzielnej tabeli. Można użyć [Edytor SQL](https://www.altova.com/pl/databasespy/sql-editor.html) w programie DatabaseSpy, aby wygenerować instrukcję CREATE dla istniejącej tabeli "books" i edytować ją bezpośrednio, lub można użyć DatabaseSpy do [Redaktor projektów](https://www.altova.com/pl/databasespy/database-design.html) aby utworzyć tabelę w sposób graficzny. (Więcej informacji można znaleźć w sekcji...) [DatabaseSpy](https://www.altova.com/pl/databasespy.html) część [Altova](https://www.altova.com/pl/) (Strona internetowa.) 

Ponieważ planujemy później uruchomić te same zapytania w Amazon RDS, połączyliśmy instrukcję SQL CREATE oraz instrukcje SQL INSERT w jeden skrypt dla tabeli "books2". Poniższy zrzut ekranu pokazuje fragment tego skryptu dla tabeli "books2": 

[![Utwórz skrypt tworzenia tabeli](https://lh5.ggpht.com/_REdrfeVqYdU/TSYwOm9o6qI/AAAAAAAAARM/DRJQIGyrS7M/blogSnap6a_thumb%5B3%5D.png?imgmax=800 "Create table script")](http://lh5.ggpht.com/_REdrfeVqYdU/TSYv0JrSNhI/AAAAAAAAARI/T4-ylo2HPaY/s1600-h/blogSnap6a%5B7%5D.png) 

Możemy wykonać zapytanie do tabeli "books2", które wyświetli kolumnę "id" (identyfikator) dla każdego wiersza 

[![Zapytanie SQL typu SELECT](https://lh6.ggpht.com/_REdrfeVqYdU/TSYwQHmnPoI/AAAAAAAAARU/Mi1mEaTUMU4/blogSnap7_thumb%5B4%5D.png?imgmax=800 "SQL SELECT query")](http://lh3.ggpht.com/_REdrfeVqYdU/TSYwPEtwIdI/AAAAAAAAARQ/gPgwsQX94Ak/s1600-h/blogSnap7%5B8%5D.png) 

Teraz możemy rozszerzyć nasze zapytania UpdateXML() i ExtractValue(), aby działały na pojedynczych wierszach: 

[![blogSnap8](https://lh5.ggpht.com/_REdrfeVqYdU/TSYyzesZA8I/AAAAAAAAARc/Le1Qs6k4GMY/blogSnap8_thumb%5B2%5D.png?imgmax=800 "blogSnap8")](http://lh4.ggpht.com/_REdrfeVqYdU/TSYwQfREjtI/AAAAAAAAARY/sUtXyDoOq7A/s1600-h/blogSnap8%5B6%5D.png) [![blogSnap9](https://lh5.ggpht.com/_REdrfeVqYdU/TSYy0nw8n2I/AAAAAAAAARk/hRPWhnmcudI/blogSnap9_thumb%5B1%5D.png?imgmax=800 "blogSnap9")](http://lh6.ggpht.com/_REdrfeVqYdU/TSYy0LgjvmI/AAAAAAAAARg/yh-JtXmQR2U/s1600-h/blogSnap9%5B3%5D.png) 

To daje nam dobry zestaw przykładów, które możemy przenieść do chmury i przetestować w Amazon RDS.

## Połącz DatabaseSpy z usługą Amazon RDS w chmurze

Po wykonaniu instrukcji znajdujących się na [Panel zarządzania AWS](http://aws.amazon.com/console/) Aby utworzyć instancję bazy danych na platformie Amazon RDS, kreator połączenia ułatwia rozpoczęcie pracy z programem DatabaseSpy. Po prostu wybierz opcję MySQL, jak pokazano poniżej: 

[![Asystent konfiguracji połączenia DatabaseSpy](https://lh5.ggpht.com/_REdrfeVqYdU/TSYy1HzeX7I/AAAAAAAAARs/OV62tBUdU1g/blogSnap10_thumb%5B1%5D.png?imgmax=800 "DatabaseSpy Connection Wizard")](http://lh4.ggpht.com/_REdrfeVqYdU/TSYy04hWtSI/AAAAAAAAARo/ePZmjb3wIbM/s1600-h/blogSnap10%5B3%5D.png) 

Po pierwszym połączeniu, konieczne będzie utworzenie nowego źródła danych (DSN). Po pierwszym połączeniu, będzie można wybrać DSN z listy, korzystając z opcji "Użyj istniejącego źródła danych". Można nawet użyć oryginalnego DSN, gdy ponownie nawiązywane jest połączenie z programów XMLSpy, MapForce lub StyleVision.

[![Łączenie z bazą danych MySQL](https://lh5.ggpht.com/_REdrfeVqYdU/TSYy2KLWVjI/AAAAAAAAAR0/P_SfoWqNqmk/blogSnap11_thumb%5B1%5D.png?imgmax=800 "Connecting to MySQL")](http://lh5.ggpht.com/_REdrfeVqYdU/TSYy1s8cwkI/AAAAAAAAARw/Vo8A8G5y5k4/s1600-h/blogSnap11%5B3%5D.png) 

W oknie dialogowym konfiguracji połączenia, wypełnij następujące informacje:

- **Nazwa źródła danych:** Jest to nazwa, która zostanie wyświetlona w oknie projektu DatabaseSpy oraz na liście istniejących źródeł danych, gdy ponownie się połączysz.
- **Opis:** Informacje do celów informacyjnych.
- **Serwer:** Jest to nazwa punktu końcowego, wyświetlana na panelu kontrolnym konta Amazon RDS.
- **Port:** 3306 – upewnij się, że dział IT nie blokuje tego portu za pomocą firewalla!
- **Nazwa użytkownika / Hasło**: To jest użytkownik, którego utworzyliście w Amazon RDS.
- **Baza danych:** Domyślna nazwa bazy danych, którą skonfigurowano podczas uruchamiania instancji RDS.

[![Sterownik ODBC dla MySQL](https://lh4.ggpht.com/_REdrfeVqYdU/TSYy3A4BZNI/AAAAAAAAAR8/MQ-j5h1PdMQ/blogSnap12_thumb%5B1%5D.png?imgmax=800 "MySQL Connector/ODBC")](http://lh6.ggpht.com/_REdrfeVqYdU/TSYy2g81jPI/AAAAAAAAAR4/yz8-Isp-rCY/s1600-h/blogSnap12%5B3%5D.png) 

Podłączyliśmy się do naszej chmurowej bazy danych Amazon RDS w tym samym projekcie DatabaseSpy, który stworzyliśmy dla lokalnego prototypu. Poniżej znajduje się zrzut ekranu okna projektu, który pokazuje nazwy źródeł danych oraz pliki SQL, które dodaliśmy do projektu: 

[![Okno projektu DatabaseSpy z połączeniem do chmury](https://lh6.ggpht.com/_REdrfeVqYdU/TSYy4Z2yQAI/AAAAAAAAASE/jjkGuAVBZYY/blogSnap15_thumb%5B1%5D.png?imgmax=800 "DatabaseSpy Project window with cloud connection")](http://lh5.ggpht.com/_REdrfeVqYdU/TSYy3qGsQpI/AAAAAAAAASA/hC99hBGpc3Y/s1600-h/blogSnap15%5B3%5D.png) 

Zanim utworzymy tabele i uruchomimy zapytania, warto sprawdzić wersje każdego systemu. Zrzuty ekranu poniżej pokazują zapytanie, które pobiera informacje o wersji dla każdego systemu. Należy zauważyć, że szary pasek bezpośrednio nad każdym zapytaniem wskazuje, do którego połączenia z bazą danych przypisane jest polecenie SQKL. 

[![Wersja zgłoszona przez lokalny serwer](https://lh3.ggpht.com/_REdrfeVqYdU/TSYy5G-k3SI/AAAAAAAAASM/WwjShCXN8NM/blogSnap16_thumb%5B1%5D.png?imgmax=800 "Version reported by the local server")](http://lh5.ggpht.com/_REdrfeVqYdU/TSYy4w4Lt3I/AAAAAAAAASI/7HQFtTCam7g/s1600-h/blogSnap16%5B3%5D.png) 

[![Wersja zgłoszona przez serwer chmurowy](https://lh5.ggpht.com/_REdrfeVqYdU/TSYy6bIVXoI/AAAAAAAAASU/-JyDD32Kp2g/blogSnap17_thumb%5B1%5D.png?imgmax=800 "Version reported by the cloud server")](http://lh3.ggpht.com/_REdrfeVqYdU/TSYy6A4UeJI/AAAAAAAAASQ/G1YLJDmUqrQ/s1600-h/blogSnap17%5B3%5D.png) 

Zgodnie z raportami Amazon RDS, serwer MySQL Community Server, na którym działa, jest w wersji 5.1, dokładnie tak jak nasz lokalny prototyp – to bardzo obiecujące!

## Przenieś lokalny projekt do chmury

Możemy otworzyć każdy z naszych oryginalnych skryptów tworzenia tabel i uruchomić je w bazie danych w chmurze, zmieniając cel wykonania w oknie właściwości 

[![Wybór źródła danych w oknie właściwości DatabaseSpy](https://lh5.ggpht.com/_REdrfeVqYdU/TSYy7_iTcXI/AAAAAAAAASc/q0X1LX25ZVI/blogSnap19_thumb%5B1%5D.png?imgmax=800 "Data Source selection in the DatabaseSpy Properties window")](http://lh6.ggpht.com/_REdrfeVqYdU/TSYy7SFih4I/AAAAAAAAASY/u2ciH6xLgA4/s1600-h/blogSnap19%5B3%5D.png) 

Pasek "Cel wykonywania" w kolorze szarym, znajdujący się u góry okna edytora SQL, wskazuje bazę danych Amazon RDS w chmurze jako cel zapytania

[![Okno edytora SQL w programie DatabaseSpy](https://lh6.ggpht.com/_REdrfeVqYdU/TSYy8UqW2LI/AAAAAAAAASk/f8LxhxA5KVE/blogSnap18_thumb%5B1%5D.png?imgmax=800 "DatabaseSpy SQL Editor window")](http://lh6.ggpht.com/_REdrfeVqYdU/TSYy8HAL2UI/AAAAAAAAASg/rrrnJEP-cZ8/s1600-h/blogSnap18%5B3%5D.png) 

Po utworzeniu tabel "books" i "books2" w podobny sposób, możemy uruchomić każde z zapytań SQL w bazie danych w chmurze. Przykład użycia funkcji ExtractValue() dla wszystkich wierszy: 

[![Funkcja `ExtractValue()`](https://lh6.ggpht.com/_REdrfeVqYdU/TSYy9LMPvLI/AAAAAAAAASs/ELCuIt6yr6A/blogSnap20_thumb%5B2%5D.png?imgmax=800 "ExtractValue( ) function")](http://lh6.ggpht.com/_REdrfeVqYdU/TSYy8xnwAYI/AAAAAAAAASo/ZiXvT3Dpt3M/s1600-h/blogSnap20%5B6%5D.png) 

Zapytanie `Concat()` służy do generowania danych XML na podstawie danych niebędących w formacie XML, znajdujących się w tabeli 

[![Użycie funkcji Concat() do dodawania elementów XML do danych pochodzących z tabeli, która nie jest w formacie XML](https://lh4.ggpht.com/_REdrfeVqYdU/TSYy-KZdIUI/AAAAAAAAAS0/tBjejnmSxt8/blogSnap21_thumb%5B1%5D.png?imgmax=800 "Using the Concat( ) function to add XML elements to data from a non-XML table")](http://lh5.ggpht.com/_REdrfeVqYdU/TSYy9ozYo3I/AAAAAAAAASw/hiDcxS51Fg8/s1600-h/blogSnap21%5B3%5D.png)

Przykład użycia funkcji UpdateXML() dla pojedynczego wiersza w tabeli.

[![Używanie funkcji UpdateXML() w chmurze Amazon RDS](https://lh6.ggpht.com/_REdrfeVqYdU/TSYy-5p4W0I/AAAAAAAAAS8/S-IU7BoJrc4/blogSnap22_thumb%5B1%5D.png?imgmax=800 "Using the UpdateXML( ) function in the Amazon RDS cloud")](http://lh5.ggpht.com/_REdrfeVqYdU/TSYy-egtAMI/AAAAAAAAAS4/bEza7pRhyTs/s1600-h/blogSnap22%5B3%5D.png) 

Funkcja `ExtractValue()` dla pojedynczego wiersza: 

[![blogSnap23](https://lh5.ggpht.com/_REdrfeVqYdU/TSYy_qnwgsI/AAAAAAAAATE/gRjQHwNgX3w/blogSnap23_thumb%5B1%5D.png?imgmax=800 "blogSnap23")](http://lh5.ggpht.com/_REdrfeVqYdU/TSYy_ePFw3I/AAAAAAAAATA/gc3yssi4DvI/s1600-h/blogSnap23%5B3%5D.png)

## Podsumowanie

W każdym przeprowadzonym teście, Amazon RDS zachowywał się identycznie jak lokalna, darmowa wersja MySQL. Takie działanie jest znacznie bardziej efektywne dla programistów, ponieważ umożliwia im tworzenie i testowanie nowych aplikacji baz danych w chmurze, a także wprowadzanie ulepszeń do istniejących aplikacji, bez ponoszenia kosztów związanych z zasobami chmurowymi podczas faz testowych. 

Sprawdziliśmy również działanie funkcji XML w MySQL, przeznaczonych do obsługi danych XML przechowywanych w kolumnach tekstowych w bazach danych w chmurze. Nasze dane XML były bardzo ograniczone – kolumna tekstowa w tabeli "książki" była ograniczona do 150 znaków. Jednak MySQL umożliwia przechowywanie znacznie większych dokumentów XML w jednej kolumnie. Każda tabela ma maksymalny rozmiar wiersza wynoszący 65 535 bajtów. Nawet jeśli tabela korzysta z kolumny indeksu, oznacza to, że kolumna varchar przechowująca jeden wpis XML może mieć ponad 64 000 bajtów. Jeśli potrzebujesz przechowywać jeszcze większe dokumenty XML, MySQL oferuje typy danych MediumText i LongText, podobne do BLOB. MediumText może przechowywać ponad 16 milionów pojedynczych znaków, a LongText może przechowywać do 4 GB. Chociaż nie zostało to zilustrowane w tym wpisie na blogu, z powodzeniem przetestowaliśmy funkcje ExtractValue() i UpdateXML() z typami danych MediumText i LongText.

Kiedy trzeba przechowywać bardzo duże pliki danych XML, tworzenie wyrażeń XPath do identyfikacji poszczególnych elementów może stanowić wyzwanie programistyczne. Analizator XPath, który jest częścią programu XMLSpy, to niezwykle przydatne narzędzie, które ułatwia [Testowanie i debugowanie wyrażeń XPath 1.0 i 2.0](https://www.altova.com/pl/xmlspy/xpath-analyzer.html). Podczas wpisywania wyrażenia XPath w analizatorze, program XMLSpy ocenia je w czasie rzeczywistym i wyświetla wynikowy zestaw węzłów. Dzięki temu można zaoszczędzić wiele godzin spędzonych na debugowaniu i próbach zrozumienia oraz rozwiązywania problemów związanych z wyrażeniami XPath. 

W przyszłych wpisach na blogu przyjrzymy się innym sposobom, w jakie narzędzia XMLSpy, MapForce, DiffDog i DatabaseSpy mogą pomóc programistom przyspieszyć tworzenie aplikacji chmurowych z wykorzystaniem Amazon RDS. Czekamy na Was! Jeśli chcielibyście przekonać się, jak dobrze narzędzia Altova współpracują z Amazon RDS, [pobierz bezpłatną wersję próbną](https://www.altova.com/pl/download/missionkit/software_development_tools_enterprise.html) [Altova MissionKit](https://www.altova.com/pl/missionkit/software-development-tools.html).
