Definiowanie typów dokumentów DTD, XML Schema

Tematyka Struktura XML DTD XML Schema

Struktura XML Deklaracja XML Element główny Atrybut Element Znacznik początkowy Zawartość tekstowa Slajd przedstawia jedynie podstawowe elementy składni dokumentu XML. Każdy dokument XML zaczyna się od deklaracji XML, określającej wersję składni XML-a, kodowanie znaków, itp. Cała zawartość dokumentu zawarta jest w jednym elemencie – elemencie głównym. On dopiero zawiera inne elementy oraz tekst. Elementy mogą posiadać atrybuty, opisujące pewne właściwości elementów. Element jest kodowany przy pomocy znacznika początkowego oraz znacznika końcowego. Znacznik końcowy

Struktura logiczna dokumentu XML zeznanie-sprawcy nr="1313/2001" autor miejsce tresc Jan Leski Sopot ... Wypadek dnia data o godzinie godzina ( dzienTygodnia … 22.10.2007 środa 13:13

Składnia XML Deklaracja XML: Znaczniki: Znaczniki elementu pustego: <?xml version="1.0" encoding="UTF-8" standalone="yes"?> Znaczniki: <tag attributename="attribute value"> </tag> Znaczniki elementu pustego: <br></br> <br/> Komentarz: <!-- komentarz --> Instrukcja przetwarzania: <?target processing-instruction-body?> Sekcja CDATA: <![CDATA[dowolny <tekst " nieprzetwarzany & przez [ parser]]>

Encje predefiniowane & & < < > > &apos; ' " "

Unicode Światowy standard kodowania znaków. Odmiany: UTF-7 (korzysta tylko z 7-bitowego zestawu znaków ASCII) UTF-8 (pierwsze 128 – ASCII, znak zajmuje od 1 do 6 bajtów) UTF-16 (każdy znak to 16-bitów) UTF-32 (każdy znak 32-bity) UCS-4 (znak zajmuje zawsze 4 bajty) Obowiązkowy standard dla dokumentów XML: każde narzędzie XML-owe musi wspierać przynajmniej UTF-8 Sposób użycia w dokumentach XML: jako odpowiedni ciąg bajtów &#kod; - kod dziesiętny znaku &#xkod; - kod szesnastkowy znaku

Definiowanie języków XML, SGML Definiowanie języków (zastosowań, struktury dokumentów, typów dokumentów): określanie zestawu dopuszczalnych elementów, atrybutów definiowanie dopuszczalnej zawartości elementów (tekst, inne elementy) przypisywanie atrybutów do elementów inne części Metody definiowania struktury: dokument XML bez formalnej definicji struktury DTD – Document Type Definition XML Schema (rekomendacja W3C z 2 maja 2001)

Poprawność struktury dokumentu Dokument XML poprawny składniowo każdy element musi być zamknięty: nie ma nakładających się elementów wartości atrybutów w apostrofach lub cudzysłowach Dokument XML poprawny strukturalnie struktura dokumentu zgodna ze strukturą zdefiniowaną w definicji typu dokumentu, obecne wszystkie wymagane atrybuty Drugi stopień poprawności (poprawność strukturalna) wymaga, aby spełniony był także pierwszy. Ma on sens jedynie dla dokumentów z określoną strukturą. Dokument, który nie jest poprawny składniowo, nie jest dokumentem XML.

Modelowanie typów dokumentów Wieloetapowy proces: analiza struktury modelowanych bytów, analiza przykładowych dokumentów, analiza potencjalnych zastosowań dokumentów oraz przypadków użycia, abstrakcyjny projekt struktury, kodowanie projektu struktury np. przy pomocy DTD lub XML Schema, testowanie, stała adaptacja. Podobnie jak implementacja (kodowanie) jest tylko jedną z wielu faz budowy systemu informatycznego, tak zapisywanie definicji języka przy pomocy DTD lub XML Schema jest jedynie jednym z etapów modelowania języka. Etap ten powinien być poprzedzony przez analizę oraz projektowanie struktury języka w sposób abstrakcyjny. Stosowanie pełnego cyklu modelowania ma sens w przypadku skomplikowanych języków, wykorzystywanych np. w systemach zarządzania aktami prawnymi czy zasobami encyklopedycznymi. Proces modelowania takich języków właściwie się nie kończy, ponieważ żyją i zmieniają się same reguły biznesowe będące podstawą modelu języka, lub pojawiają się nowe zależności, które trzeba zamodelować. Dlatego w profesjonalnych zastosowaniach, typy dokumentów muszą podlegać pielęgnacji. Oczywiście w prostych przypadkach (np. modelowanie komunikatu z klienta do serwera aplikacji), "rozgarnięty" projektant poradzi sobie od razu kodując definicję przy pomocy DTD lub XML Schema.

Projektowanie struktury dokumentów autor ? wiersz tytuł Podczas abstrakcyjnego, niezależnego od notacji zapisu (DTD lub XML Schema), projektowania struktury dokumentów, używa się z reguły notacji graficznych. Istnieją specjalne programy, które pozwalają na takie graficzne projektowanie, np. XML Authority. * * zwrotka wers

DTD – prosty przykład <!DOCTYPE wiersz [ <!ELEMENT wiersz (autor, tytul?, zwrotka*)> <!ATTLIST wiersz bialy (tak|nie) "nie"> <!ELEMENT autor (#PCDATA)> <!ELEMENT tytul (#PCDATA)> <!ELEMENT zwrotka (wers)*> <!ELEMENT wers (#PCDATA)> ]> Definicja typu dokumentu jest zawarta w deklaracji DOCTYPE, po której następuje nazwa elementu głównego. Pozycje ELEMENT określają dopuszczalną zawartość poszczególnych elementów przy pomocy wyrażeń regularnych. #PCDATA (Parsed Characters Data) oznacza "czysty" tekst, bez podelementów. DTD określa także atrybuty elementów. zawartość elementów element główny atrybuty wyrażenia regularne

Braki DTD Zastosowania XML w integracji aplikacji – struktury danych: Przeniesienie zadania sprawdzania poprawności tworzonej aplikacji przez narzędzie walidujące 60% tworzonego kodu dotyczy weryfikacji poprawności danych Cechy DTD: Mała kontrola nad tekstową zawartością elementów i wartościami atrybutów Ogólne metody definiowania częstości wystąpień Nieobiektowe, nierozszerzalne modele struktury Taką kontrolę poprawności możemy oczywiście zaimplementować sami w kodzie naszej aplikacji (ewentualnie parametryzując aplikację przy pomocy atrybutów #FIXED), jest to jednak dość pracochłonne. Dobrze byłoby zrzucić walidację na parser XML. Standard XML Schema pozwala na definiowanie struktur dokumentów z dużo bardziej niż w DTD zaawansowaną kontrolą zawartości.

DTD vs XML Schema Wywodzi się z SGML-a Zaprojektowany na potrzeby XML Specyficzna składnia Składnia XML 10 typów danych 44 wbudowane typy proste Brak kontroli tekstowej zawartości elementów Zaawansowana kontrola tekstowej zawartości elementów Typowy mieszany model zawartości Możliwość definiowania własnych typów danych

XML Schema 15 lutego 1999: Dokument W3C opisujący wymagania stawiane przed nowym formatem: mechanizmy tworzenia struktury typy proste reguły przetwarzania Przestrzeń nazw XML Schema: http://www.w3.org/2001/XMLSchema

Elementy i atrybuty <xsd:element name="osoba"> <xsd:complexType> <xsd:sequence> <xsd:element name="imie" type="xsd:string"/> <xsd:element name="nazwisko" type="xsd:string"/> <xsd:element name="plec" type="xsd:string"/> <xsd:element name="wiek" type="xsd:string"/> </xsd:sequence> <xsd:attribute name="id" type="xsd:ID"/> <xsd:attribute name="NIP" type="NIPTyp"/> </xsd:complexType> </xsd:element>

Kontrola użycia elementów i atrybutów <xsd:element name="osoba"> <xsd:complexType> <xsd:sequence> <xsd:element name="imie" type="xsd:string" minOccurs="1" maxOccurs="2"/> <xsd:element name="nazwisko" type="xsd:string"/> <xsd:element name="plec" type="xsd:string"/> <xsd:element name="wiek" type="xsd:string"/> </xsd:sequence> <xsd:attribute name="id" type="xsd:ID" use="required"/> <xsd:attribute name="NIP" type="NIPTyp"/> </xsd:complexType> </xsd:element>

Typy Typy wg zasięgu definicji: typy nazwane typy anonimowe Typy wg zawartości: typy proste typy złożone o zawartości: prostej elementowej mieszanej pustej Typy wg pochodzenia: typy wbudowane typy zdefiniowane w schemacie: rozszerzenia innych typów ograniczenia innych typów listy i unie

Typy nazwane i anonimowe Typy nazwane: <xsd:complexType name="OsobaTyp"> <xsd:sequence> <xsd:element name="imie" type="xsd:string"/> <xsd:element name="nazwisko" type="xsd:string"/> </xsd:sequence> </xsd:complexType> <xsd:element name="osoba" type="OsobaTyp"/> Typy anonimowe: <xsd:element name="osoba"> <xsd:complexType> <xsd:sequence> <xsd:element name="imie" type="xsd:string"/> <xsd:element name="nazwisko" type="xsd:string"/> </xsd:sequence> </xsd:complexType> </xsd:element>

Typy proste i złożone Typy proste: <xsd:simpleType name="NIPTyp"> <xsd:restriction base="xsd:string"> <xsd:pattern value="\d{3}-\d{3}-\d{2}-\d{2}"/> </xsd:restriction> </xsd:simpleType> Typy złożone: <xsd:complexType name="OsobaTyp"> <xsd:sequence> <xsd:element name="imie" type="xsd:string"/> <xsd:element name="nazwisko" type="xsd:string"/> </xsd:sequence> </xsd:complexType> Element może mieć typ prosty lub złożony Atrybut może mieć wyłącznie typ prosty

Typy złożone – typy zawartości Zawartość elementowa: <osoba PESEL="12345678901"> <imie>Jan</imie> <nazwisko>Kowalski</nazwisko> </osoba> Zawartość prosta: <masa jm="kg">10.55</masa>

Typy złożone – typy zawartości Zawartość mieszana: Zawartość pusta: <osoba PESEL="12345678901"/>

Definiowanie zawartości elementowej Grupy deklaracji elementów: sequence, choice, all Zagnieżdżanie grup: <xsd:complexType name="OsobaTyp"> <xsd:sequence> <xsd:element name="imie" type="xsd:string"/> <xsd:element ref="nazwisko"/> <xsd:choice> <xsd:element name="nr-dowodu" type="DowódTyp"/> <xsd:element name="nr-paszportu" type="PaszportTyp"/> </xsd:choice> </xsd:sequence> </xsd:complexType>

Grupa all – ograniczenia Nie może zawierać innych grup (tylko deklaracje elementów i odwołania do elementów) Każdy element może wystąpić co najwyżej raz Grupa all nie może być zagnieżdżona w innej grupie Zagnieżdżanie grup <xsd:complexType name="OsobaTyp"> <xsd:all> <xsd:element name="imie" type="xsd:string"/> <xsd:element name="drugie-imie" type="xsd:string" minOccurs="0"/> <xsd:element ref="nazwisko"/> </xsd:all> </xsd:complexType>

Definiowanie zawartości prostej <xsd:complexType name="MasaTyp"> <xsd:simpleContent> <xsd:extension base="xsd:decimal"> <xsd:attribute name="jm" type="xsd:string"/> </xsd:extension> </xsd:simpleContent> </xsd:complexType>

Definiowanie zawartości mieszanej <xsd:complexType name="ZeznanieTyp" mixed="true"> <xsd:sequence> <xsd:element name="data" type="xsd:string"/> <xsd:element name="godzina" type="xsd:string"/> <xsd:element name="dzien-tygodnia" type="xsd:string"/> <xsd:element name="poszkodowany" type="xsd:string"/> </xsd:sequence> </xsd:complexType>

Definiowanie zawartości pustej <xsd:complexType name="OsobaTyp"> <xsd:attribute name="PESEL" type="PESELTyp"/> </xsd:complexType>

Globalne i lokalne deklaracje elementów i atrybutów - lokalne Deklaracje lokalne <xsd:complexType name="OsobaTyp"> <xsd:sequence> <xsd:element name="imie" type="xsd:string" minOccurs="1" maxOccurs="2"/> <xsd:element name="nazwisko" type="xsd:string"/> </xsd:sequence> <xsd:attribute name="NIP" type="NIPTyp" use="required"/> </xsd:complexType>

Globalne i lokalne deklaracje elementów i atrybutów - globalne Deklaracje globalne i odwołania <xsd:element name="imie" type="xsd:string"/> <xsd:element name="nazwisko" type="xsd:string"/> <xsd:attribute name="NIP" type="NIPTyp"/> <xsd:complexType name="OsobaTyp"> <xsd:sequence> <xsd:element ref="imie" minOccurs="1" maxOccurs="2"/> <xsd:element ref="nazwisko"/> </xsd:sequence> <xsd:attribute ref="NIP" use="required"/> </xsd:complexType>

Elementy a atrybuty Informacje modelowane zwykle w elementach: zawartość - np. nazwisko, wiek struktura – np. akt prawny, rozdział wyszukiwanie - indeks, słowo kluczowe odesłania – odnośniki, przypisy Informacje modelowane zwykle w atrybutach: metainformacje – język, format liczb identyfikatory wartości i odwołania do nich

Elementy vs atrybuty Zalety elementów: Zalety atrybutów: mogą zawierać inne elementy i atrybuty mogą się powtarzać można bezpiecznie rozszerzać ich model zawartości można dokładnie sterować sposobem ich występowania - kolejność, liczba wystąpień Zalety atrybutów: szybsze do definiowania mogą mieć wartości domyślne

Wartości domyślne i ustalone <xsd:element name="ilość" type="xsd:positiveInteger" default="1"/> <xsd:element name="cena" type="xsd:positiveInteger" fixed="5"/> <xsd:attribute name="waluta" type="xsd:string" default="PLN"/> <xsd:attribute name="VAT" type="xsd:string" fixed="22%"/> Przykład <kwota waluta="EUR" VAT="16%">20</kwota> powinno być bez VAT

Przestrzenie nazw Wykorzystanie Koncepcja Historia Analogiczna nazwa określająca te same elementy w różnych powiązanych dokumentach - wspólnie przetwarzane, zagnieżdżenie jednego w drugim Koncepcja grupa nazw oddzielona (składniowo i semantycznie) od innych nazw Historia rekomendacja W3C ze stycznia 1999 r XML 1.0 (również DTD) nie wspierają przestrzeni nazw standardy XML Schema, XSL, XLink wspierają przestrzenie nazw

Nazwy przestrzeni nazw Identyfikatory URI, np: http://www.w3.org/XSLT/Transform/1.0 http://zajecia.edu.pl/osoby urn:szz:mimuw Nazwy przestrzeni nazw: nie muszą wskazywać konkretnych zasobów pełnią funkcję unikatowych identyfikatorów są porównywane jako napisy - istotna wielkości liter Wykorzystanie w dokumentach XML: odwzorowanie na kilkuznakowy prefiks poprzedzanie nazw prefiksem

Użycie przestrzeni nazw XML <os:osoba xmlns:os="http://zajecia.edu.pl/osoby" xmlns:inst="http://zajecia.edu.pl/instytucje" xmlns:xhtml="http://www.w3.org/1999/xhtml"> <os:imie>Adam</os:imie> <os:nazwisko>Leski</os:nazwisko> <os:NIP>123-456-78-90</os:NIP> <os:opis><xhtml:b>Prezes firmy</xhtml:b> </os:opis> <os:pracuje-w> <inst:firma> <inst:nazwa>WinPol</inst:nazwa> <inst:NIP>987-654-32-10</inst:NIP> </inst:firma> </os:pracuje-w> </os:osoba>

Domyślna przestrzeń nazw <osoba xmlns="http://zajecia.edu.pl/osoby" xmlns:inst="http://zajecia.edu.pl/instytucje" xmlns:xhtml="http://www.w3.org/1999/xhtml"> <imie>Adam</imie> <nazwisko>Leski</nazwisko> <NIP>123-456-78-90</NIP> <opis><xhtml:b>Prezes firmy</xhtml:b> <pracuje-w> <inst:firma> <inst:nazwa>WinPol</inst:nazwa> <inst:NIP>987-654-32-10</inst:NIP> </inst:firma> </pracuje-w> </osoba>

Widoczność przestrzeni nazw <os:osoba xmlns:os="http://zajecia.edu.pl/osoby"> <os:imie>Adam</os:imie> <os:nazwisko>Leski</os:nazwisko> <os:NIP>123-456-78-90</os:NIP> <os:pracuje-w> <os:firma xmlns:os="http://zajecia.edu.pl/instytucje"> <os:nazwa>WinPol</os:nazwa> <os:NIP>987-654-32-10</os:NIP> </os:firma> </os:pracuje-w> </os:osoba>

Nazwy z prefiksem i bez Nazwy atrybutów: Nazwy elementów: kwalifikowane – należą do pewnej przestrzeni nazw poprzedzone prefiksem nie poprzedzone prefiksem, jeśli są w zasięgu deklaracji domyślnej niekwalifikowane – nie należą do żadnej przestrzeni nazw nie poprzedzone prefiksem, poza zasięgiem deklaracji domyślnej przestrzeni nazw Nazwy atrybutów: poprzedzone prefiksem – należą do pewnej przestrzeni nazw nie poprzedzone prefiksem – nie należą do żadnej przestrzeni nazw

Nazwy elementów bez prefiksów <osoba xmlns="http://zajecia.edu.pl/osoby"> <imie>Adam</imie> <nazwisko>Leski</nazwisko> <NIP>123-456-78-90</NIP> <pracuje-w> <firma xmlns=""> <nazwa>WinPol</nazwa> <NIP>987-654-32-10</NIP> </firma> </pracuje-w> </osoba>

Nazwy atrybutów <osoba xmlns="http://zajecia.edu.pl/osoby" xmlns:xlink="http://www.w3.org/1999/xlink"> <imie>Jan</imie> <nazwisko>Kowalski</nazwisko> <NIP>123-456-78-90</NIP> <pracuje-w xlink:type="simple" xlink:href="..." rodzaj="etat">Business Consulting</pracuje-w> </osoba>

Atrybuty - analiza Poprawne <x xmlns:n1="http://zajecia.edu.pl/n1"     xmlns:n2="http://zajecia.edu.pl/n2">    <good n1:a="1" n2:a="2"/> </x> Niepoprawne <x xmlns:n1="http://zajecia.edu.pl/n1"     xmlns:n2="http://zajecia.edu.pl/n1">   <bad n1:a="1" n2:a="2"/> </x> Poprawne <x xmlns:n1="http://zajecia.edu.pl/n1"     xmlns="http://zajecia.edu.pl/n1">   <good n1:a="1" a="2"/> </x>

Przestrzenie nazw a schematy Schemat zapisuje się przy pomocy jednego lub więcej dokumentów schematów Schemat deklaruje nazwy należące do zero lub więcej przestrzeni nazw Dokument schematu deklaruje nazwy należące do zera lub jednej przestrzeni nazw Przestrzeń nazw zawiera nazwy zadeklarowane w zero lub więcej schematach

Przestrzenie nazw a schematy import osoba imię nazwisko NIP osoby.xsd firma http://zajecia.edu.pl/osoby nazwa NIP inst.xsd http://zajecia.edu.pl/instytucje

Dokument schematu <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns="http://zajecia.edu.pl/osoby" targetNamespace="http://zajecia.edu.pl/osoby"> <xsd:complexType name="OsobaTyp"> ... </xsd:complexType> <xsd:element name="osoba" type="OsobaTyp"/> <xsd:element name="numer" type="xsd:integer"/> ... </xsd:schema>

Łączenie schematów Schemat zapisuje się przy pomocy jednego lub więcej dokumentów schematów Metody budowania schematu z dokumentów schematów instrukcje include, import i redefine lokalizacje dokumentów schematów są określone w egzemplarzu procesor łączy dokumenty schematów znajdujące się w zdefiniowanych lokalizacjach lokalizacje dokumentów schematów są przekazywane jako parametry wiersza poleceń

include Dołączanie dokumentu schematu do docelowej przestrzeni nazw głównego dokumentu schematu <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns="http://zajecia.edu.pl/osoby" targetNamespace="http://zajecia.edu.pl/osoby"> <xsd:include schemaLocation="inst.xsd"/> ... </xsd:schema> Dołączany dokument musi: mieć taką samą docelową przestrzeń nazw jak dokument główny, lub nie mieć docelowej przestrzeni nazw osoby.xsd inst.xsd osoba imię nazwisko NIP firma nazwa REGON http://zajecia.edu.pl/osoby

redefine Dołączanie dokumentu schematu do docelowej przestrzeni nazw głównego dokumentu schematu z możliwością przedefiniowania: typów prostych i złożonych nazwanych grup modeli grup atrybutów <xsd:redefine schemaLocation="inst.xsd"/> osoby.xsd inst.xsd osoba imię nazwisko NIP NIPTyp firma nazwa REGON NIPTyp http://zajecia.edu.pl/osoby

import Odwołanie do komponentów w innej przestrzeni nazw <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns="http://zajecia.edu.pl/osoby" xmlns:inst="http://zajecia.edu.pl/instytucje" targetNamespace="http://zajecia.edu.pl/osoby"> <xsd:import schemaLocation="inst.xsd" namespace="http://zajecia.edu.pl/instytucje"/> ... </xsd:schema> osoby.xsd osoba imię nazwisko NIP inst.xsd firma nazwa NIP http://zajecia.edu.pl/osoby http://zajecia.edu.pl/instytucje

Wbudowane typy proste

Podstawowe typy proste Poprawne wartości decimal 12.3 +000012.300 float, double +24.3e-3 12 string osoba Date 1968-04-02 1968-04-02-05:00 1968-04-02Z -0045-02-02 time 13:20:00.887 13:30:00-05:00 dateTime 1968-04-02T13:20:00.887

Wyprowadzanie typów Wyprowadzanie typów prostych: ograniczanie tworzenie list tworzenie unii Wyprowadzanie typów złożonych: rozszerzanie: typów prostych typów złożonych

Ograniczanie typów prostych Aspekty minExclusive, minInclusive maxExclusive, maxInclusive length, minLength, maxLength totalDigits, fractionDigits enumeration pattern Tylko pattern i enumeration można użyć wielokrotnie w jednej definicji typu

Ograniczanie typów prostych – przykłady <xsd:simpleType name="OcenaTyp"> <xsd:restriction base="xsd:integer"> <xsd:minInclusive value="2"/> <xsd:maxInclusive value="5"/> </xsd:restriction> </xsd:simpleType> <xsd:simpleType name="OrganizacjaTyp"> <xsd:restriction base="xsd:token"> <xsd:enumeration value="Firma"/> <xsd:enumeration value="Instytucja publiczna"/> </xsd:restriction> </xsd:simpleType> <xsd:simpleType name="NIPTyp"> <xsd:restriction base="xsd:string"> <xsd:pattern value="\d{3}-\d{3}-\d{2}-\d{2}"/> <xsd:pattern value="\d{3}-\d{2}-\d{2}-\d{3}"/> </xsd:restriction> </xsd:simpleType>

Ograniczanie typów prostych Przestrzeń wartości typu wyprowadzonego musi być podzbiorem przestrzeni wartości typu bazowego Typy wbudowane mają określone niektóre aspekty, byte: minInclusive: -128, maxInclusive: 127. Przykład – niepoprawne wyprowadzenie <xsd:simpleType name="ExtendedByte"> <xsd:restriction base="xsd:byte"> <xsd:minInclusive value="-256"/> <xsd:maxInclusive value="255"/> </xsd:restriction> </xsd:simpleType>

Listy <xsd:simpleType name="OcenaTyp"> <xsd:restriction base="xsd:integer"> <xsd:minInclusive value="2"/> <xsd:maxInclusive value="5"/> </xsd:restriction> </xsd:simpleType> <xsd:simpleType name="OcenySTDTyp"> <xsd:list itemType="OcenaTyp"/> </xsd:simpleType> <xsd:simpleType name="StudentSTDTyp"> <xsd:restriction base=„OcenySTDTyp"> <xsd:length value="2"/> </xsd:restriction> </xsd:simpleType>

Unie <xsd:simpleType name="RozmiarLiczbowyTyp"> <xsd:restriction base="xsd:integer"> <xsd:minInclusive value="2"/> <xsd:maxInclusive value="18"/> </xsd:restriction> </xsd:simpleType> <xsd:simpleType name="RozmiarSMLTyp"> <xsd:restriction base="xsd:token"> <xsd:enumeration value="S"/> <xsd:enumeration value="M"/> <xsd:enumeration value="L"/> </xsd:restriction> </xsd:simpleType> <xsd:simpleType name="RozmiarTyp"> <xsd:union memberTypes="RozmiarLiczbowyTyp RozmiarSMLTyp"/> </xsd:simpleType>

Rozszerzenia Rozszerzanie zawartości złożonej Wartości typu bazowego nie muszą być poprawnymi wartościami typu wyprowadzonego Rozszerzanie zawartości prostej – dodawanie atrybutów do: typu prostego typu złożonego o zawartości prostej Rozszerzanie zawartości złożonej dodawanie do typu bazowego dodatkowych elementów i/lub atrybutów elementy dodawane w rozszerzeniu występują zawsze na końcu, po elementach zadeklarowanych w typie bazowym

Rozszerzanie zawartości prostej <xsd:complexType name="CenaTyp"> <xsd:simpleContent> <xsd:extension base="xsd:decimal"> <xsd:attribute name="waluta" type="xsd:string"/> </xsd:extension> </xsd:simpleContent> </xsd:complexType> <xsd:complexType name="CenaKlientWaznyTyp"> <xsd:simpleContent> <xsd:extension base="CenaKlientTyp"> <xsd:attribute name="rabat" type="xsd:decimal"/> </xsd:extension> </xsd:simpleContent> </xsd:complexType>

Rozszerzanie zawartości złożonej <xsd:complexType name="pracownikTyp"> <xsd:sequence> <xsd:element name="imieNazwisko" type="xsd:string"/> <xsd:element name="stanowisko" type="xsd:string"/> </xsd:sequence> </xsd:complexType> <xsd:complexType name="pracownikTymczasowyTyp"> <xsd:complexContent> <xsd:extension base="pracownikTyp"> <xsd:choice> <xsd:element name="kontrakt" type="KontraktTyp"/> <xsd:element name="zlecenie" type="ZlecenieTyp"/> </xsd:choice> </xsd:extension> </xsd:complexContent> </xsd:complexType>

Ograniczanie typów złożonych Przestrzeń wartości typu wyprowadzonego musi być podzbiorem przestrzeni wartości typu bazowego Dozwolone operacje: ograniczenie zawartości prostej ograniczenie atrybutu ograniczenie typu atrybutu zmiana atrybutu opcjonalnego na wymagany (required) lub zabroniony (prohibited) dodanie, zmiana lub usunięcie wartości domyślnej dodanie wartości ustalonej, jeśli jej nie było ograniczenie modelu zawartości ściślejsze ograniczenia liczebności (minOccurs, maxOccurs) usunięcie elementów opcjonalnych w grupach sequence i all wybranie podzbioru elementów w grupie choice ograniczenie typu poszczególnych podelementów

Ograniczanie zawartości prostej i atrybutów <xsd:complexType name="MasaNiedokladnaTyp"> <xsd:simpleContent> <xsd:extension base="xsd:decimal"> <xsd:attribute name="jm" type="xsd:string"/> <xsd:attribute name="dokładność" type="xsd:decimal"/> </xsd:extension> </xsd:simpleContent> </xsd:complexType> <xsd:complexType name="MasaDoUniesieniaTyp"> <xsd:simpleContent> <xsd:restriction base="MasaNiedokladnaTyp"> <xsd:minInclusive value="0"/> <xsd:maxInclusive value="50"/> <xsd:attribute name="dokładność" use="prohibited"/> <xsd:attribute name="jm" fixed="kg"/> </xsd:restriction> </xsd:simpleContent> </xsd:complexType>

Ograniczanie zawartości złożonej <xsd:complexType name="BazowyTyp"> <xsd:sequence> <xsd:element name="a" type="xsd:string" minOccurs="3" maxOccurs="7"/> <xsd:element name="b" type="xsd:string" minOccurs="0"/> <xsd:element name="c" type="xsd:string"/> </xsd:sequence> </xsd:complexType> <xsd:complexType name="OgraniczonyTyp"> <xsd:complexContent> <xsd:restriction base="BazowyTyp"> <xsd:sequence> <xsd:element name="a" type="xsd:string" minOccurs="4" maxOccurs="6"/> <xsd:element name="c" type="xsd:string"/> </xsd:sequence> </xsd:restriction> </xsd:complexContent> </xsd:complexType>

Metody modularyzacji schematów Grupy do wielokrotnego wykorzystania nazwane grupy modeli grupy atrybutów Grupy zamienne

Grupy wielokrotnego wykorzystania <xsd:group name="ImięNazwisko"> <xsd:sequence> <xsd:element name="imie" type="xsd:string"/> <xsd:element name="nazwisko" type="xsd:string"/> </xsd:sequence> </xsd:group> <xsd:attributeGroup name= "DaneUrzedowe"> <xsd:attribute name="NIP" type="NIPTyp"/> <xsd:attribute name="PESEL" type="PESELTyp"/> </xsd:attributeGroup> <xsd:complexType name="OsobaTyp"> <xsd:sequence> <xsd:group ref="ImięNazwisko"/> <xsd:element name="obywatelstwo" type="xsd:token"/> </xsd:sequence> <xsd:attributeGroup ref= "DaneUrzedowe"/> </xsd:complexType>

Grupy zamienne <xsd:element name="katalog"> <xsd:complexType> <xsd:sequence> <xsd:element ref="produkt" maxOccurs="unbounded"/> <xsd:sequence> <xsd:complexType> </xsd:element> <xsd:element name="produkt" type="ProduktTyp"/> <xsd:element name="komputer" type="KomputerTyp" substitutionGroup="produkt"/> <xsd:element name="ubranie" type="UbranieTyp" substitutionGroup="produkt"/>

Grupy zamienne – wykorzystanie <katalog> <produkt>...</produkt> <komputer>...</komputer> <ubranie>...</ubranie> <produkt>...</produkt> </katalog>

Więzy integralności Elementy więzów integralności Zalety unique – wartości w ramach określonego zakresu muszą być unikatowe key - wartości w ramach określonego zakresu muszą być unikatowe i nie mogą być puste keyref – odwołanie do wartości wskazanego klucza Zalety można tworzyć wiele niezależnych od siebie ograniczeń odwołanie wskazuje konkretny klucz więzy integralności mogą być nałożone na kombinację wartości więzy integralności mogą być nałożone na zawartość elementów

Więzy integralności <xsd:element name="zamówienia-i-faktury" type="ZamówieniaFakturyTyp"> <xsd:unique name="fakturaId"> <xsd:selector xpath="faktury/faktura"/> <xsd:field xpath="@nr"/> <xsd:field xpath="rok"/> </xsd:unique> <xsd:keyref name="zamówienieRef" refer="zamówienieId"> <xsd:selector xpath="faktury/faktura/do-zamówienia"/> <xsd:field xpath="@nr"/> </xsd:keyref> <xsd:key name="zamówienieId"> <xsd:selector xpath="zamówienia/zamówienie"/> <xsd:field xpath="numer"/> </xsd:key> </xsd:element>

Tworzenie schematu XSD za pomocą .NET