Sei sulla pagina 1di 45

Schemi XML

(XSD)
Giuseppe Della Penna
Universit degli Studi di LAquila
gdellape@univaq.it
http://dellapenna.univaq.it

Sommario
Schemi e DTD
Perch gli Schemi?
Nuove caratteristiche
Vantaggi degli Schemi
Dichiarazioni e Definizioni
Schemi e Namespaces
Richiamare lo schema in un documento
Creare e Usare un Namespace
Schemi senza Namespace
Documenti senza Namespace
Dichiarazioni Globali e Locali
Dichiarazioni Locali
Dichiarazioni di Globali
XML Schema / 2

Sommario
I Tipi Semplici
Tipi di dato Built-in
Creazione di Tipi Semplici
Sintassi di simpleType
Facets dei Tipi Numerici
Facets dei Tipi Stringa
Facets del Tipi Data
Impedire la Ridefinizione di una Facet
Uso dei simpleType Definiti
Liste di Tipi Semplici
Unione di Tipi Semplici
Riassunto dei simpleType
XML Schema / 3

Sommario
I Tipi Complessi
Modelli di Raggruppamento
minOccurs e maxOccurs
Il Modello sequence
Il Modello choice
Il Modello all
Tipi Complessi a Modello Misto
complexType Derivati
Tipi Complessi basati su Tipi Semplici
Tipi Complessi basati su Tipi Complessi
XML Schema / 4

Sommario
Restrizioni su Tipi Complessi
Estensioni su Tipi Complessi
Impedire le Derivazioni
Sostituzione di Elementi
Attributi
Aggiungere Attributi a un Tipo
Estensione con Attributi
Restrizione di Attributi
Valori di Default per Elementi
Elementi Vuoti
XML Schema / 5

Sommario
Elemento group
Elemento attributeGroup
Estendibilit dei Documenti Istanza
Elemento any
Elemento anyAttribute
Namespaces ed Elementi any
Annotazioni
Creare Documenti con pi di uno Schema
Combinare Schemi Diversi

XML Schema / 6

Schemi e DTD
u

Gli Schemi XML sono nati con lo stesso


scopo dei DTD:

Specificare la struttura dei documenti.

Specificare il tipo dei dati utilizzabili allinterno


di elementi e attributi.

Modelli di contenuto, elementi radice,

Per gli elementi, il tipo di dato poteva essere testo e/o


un particolare modello di contenuto.

XML Schema / 7

Perch gli Schemi?


u

I DTD usano una sintassi non XML.

Perch costringere gli sviluppatori ad imparare le


regole di un nuovo linguaggio?
Perch scrivere parser XML che debbano leggere
anche formati non XML per la validazione?

I DTD hanno pochi tipi di dato.

Il controllo sui domini dei dati parte integrante


del controllo di un documento ben formato.
Esistono tipi di dato molto noti che si vorrebbero
poter sfruttare (linguaggi, basi di dati).

XML Schema / 8

Nuove caratteristiche
Pi tipi di dato (44 contro 10), e la possibilit
di definirne di nuovi o derivarne altri da tipi
gi esistenti applicando regole e restrizioni.
u Ci sono nuovi modelli di contenuto, tra cui
linsieme (tutti questi elementi, in qualsiasi
ordine).
u Si possono definire pi campi chiave diversi.
u Si possono dichiarare classi di equivalenza
tra elementi.
u

XML Schema / 9

Vantaggi degli Schemi


Generalmente, le applicazioni che devono
basarsi su documenti o dati provenienti
dallesterno sprecano una grossa quantit di
codice per controllarne la validit.
u Pi complessi sono i dati, pi il codice sar
laborioso da scrivere.
u Se i dati sono strutturati secondo un preciso
Schema XML, lapplicazione potr avvalersi
delle funzionalit di un qualsiasi validatore di
schemi in commercio!
u

XML Schema / 10

Cosa Forniscono gli Schemi


u

Un modello per i dati.

Un contratto.

Descrivono cio organizzazione e tipi per


linformazione.
Cio un protocollo molto specifico per lo scambio
di informazioni.

Metadati.

Lo schema contiene molte informazioni valide


per linterpretazione dei dati strutturati sulla sua
base.

XML Schema / 11

Cosa si pu ottenere dagli Schemi?


u

Oltre che per validare i documenti istanza, si


possono immaginare molte altri impieghi per
gli schemi:

Creazione automatica di interfacce per la


compilazione dei documenti XML associati.
Creazione di interfacce grafiche per la
rappresentazione dei dati.

XML Schema / 12

Un DTD di Partenza
<!ELEMENT
<!ELEMENT
<!ELEMENT
<!ELEMENT
<!ELEMENT

artist (#PCDATA)>
title (#PCDATA)>
year (#PCDATA)>
comment (#PCDATA)>
length (#PCDATA)>

<!ELEMENT song (artist?, title, year?, comment ?, length)>


<!ELEMENT CD song+>

Gli elementi blu fanno parte della sintassi DTD.


Gli elementi neri fanno parte della nuova sintassi
che stiamo definendo.
Poich i DTD sono stati creati prima dei
namespaces, non esiste questo concetto nei DTD
e gli elementi delle due sintassi sono mescolati.

XML Schema / 13

Un XSD di Partenza
<xs:element name="artist" type="xs:string"/>
<xs:element name="comment" type="xs:string"/>
<xs:element name="length" type="xs:string "/>
<xs:element name="title" type="xs:string"/>
<xs:element name="year" type="xs:string"/>

<!ELEMENT
<!ELEMENT
<!ELEMENT
<!ELEMENT
<!ELEMENT

artist (#PCDATA)>
title (#PCDATA)>
year (#PCDATA)>
comment (#PCDATA)>
length (#PCDATA)>

<xs:element name="song">
<xs:complexType>
<xs:sequence>
<xs:element ref="artist" minOccurs ="0"/>
<!ELEMENT song
<xs:element ref="title"/>
(artist?, title, year?, comment ?, length)
<xs:element ref="year" minOccurs ="0"/>
<xs:element ref="comment" minOccurs ="0"/> >
<xs:element ref="length "/>
</xs:sequence>
</xs:complexType>
</xs:element>
<xs:element name="CD">
<xs:complexType>
<!ELEMENT CD song+>
<xs:sequence>
<xs:element ref="song" maxOccurs ="unbounded "/>
</xs:sequence>
</xs:complexType>
</xs:element>
XML Schema / 14

Un XSD di Partenza

XML Schema / 15

Dichiarazioni e Definizioni
In un DTD, si descrivono oggetti che faranno
parte dei documenti istanza, ma anche oggetti
usati solo nel DTD (entit parametriche).
u Ugualmente, in uno Schema:
u

Si dichiarano elementi e attributi, cio


componenti che saranno usati nei documenti
istanza.
Si definiscono tipi, modelli di gruppo, gruppi di
attributi ecc., cio componenti che non
appariranno nei documenti, ma sono usati solo
allinterno dello Schema stesso.

XML Schema / 16

Schemi e Namespaces
<?xml version="1.0" encoding="UTF-8"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
elementFormDefault="qualified "
targetNamespace ="http://dellapenna.univaq.it/CD "
xmlns ="http://dellapenna.univaq.it/CD "
>
<xs:element name="artist" type="xs:string"/>
<xs:element name="comment" type="xs:string"/>
<xs:element name="length" type="xs:string "/>
<xs:element name="title" type="xs:string"/>
<xs:element name="year" type="xs:string"/>

Gli elementi della sintassi


XML Schema provengono
dal namespace
http://www.w3.org/2001/
XMLSchema
Gli elementi della sintassi
definita in questo schema
saranno inseriti nel (nuovo)
namespace
http://dellapenna.univaq.it/CD

<xs:element name="song">
<xs:complexType>
<xs:sequence>
<xs:element ref="artist" minOccurs ="0"/>
<xs:element ref="title"/>
<xs:element ref="year" minOccurs ="0"/>
<xs:element ref="comment" minOccurs ="0"/>
<xs:element ref="length "/>
</xs:sequence>
</xs:complexType>
</xs:element>

La dichiarazione del default


namespace indica al parser
che
gli
elementi
riferiti
allinterno del documento senza
esplicito prefisso di namespace
vanno
considerati
come
appartenenti
a
http://dellapenna.univaq.it/CD,
cioe al targetNamespace!

XML Schema / 17

Schemi e Namespaces
<?xml version="1.0" encoding="UTF-8"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
elementFormDefault="qualified "
targetNamespace ="http://dellapenna.univaq.it/CD"
xmlns ="http://dellapenna.univaq.it/CD" >
<xs:element name="artist" type="xs:string"/>
<xs:element name="comment" type="xs:string"/>
<xs:element name="length" type="xs:string "/>
<xs:element name="title" type="xs:string"/>
<xs:element name="year" type="xs:string"/>

elementFormDefault posto a
qualified indica che tutti i
documenti che fanno uso degli
elementi definiti in questa
sintassi dovranno sempre
dichiararne il namespace.

<xs:element name="song">
<xs:complexType>
<xs:sequence>
<xs:element ref="artist" minOccurs ="0"/>
<xs:element ref="title"/>
<xs:element ref="year" minOccurs ="0"/>
<xs:element ref="comment" minOccurs ="0"/>
<xs:element ref="length "/>
</xs:sequence>
</xs:complexType>
</xs:element>

XML Schema / 18

Namespaces
schema
element

artist

complexType

comment

sequence

length

choice

year

attribute

title

maxOccurs

song

targetNamespace

CD

string

http://www.w3.org/2001/XMLSchema

http://dellapenna.univaq.it/CD

XML Schema / 19

Richiamare lo schema in un documento


<?xml version="1.0"?>
1
<CD
xmlns="http://dellapenna.univaq.it/CD
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance
2
xsi:schemaLocation ="http://dellapenna.univaq.it/CD.xsd">
<song >
<title>African Bamba</title>
<length >4:42</length >
</song >
<song >
<artist>Santana</artist>
<title>Corazon Espinado </title>
<comment>
First Hit from the album
</comment>
<length >4:36</length >
</song >
</CD>

Indichiamo al parser che tutti gli


elementi del documento (non
qualificati) vanno considerati parte
del namespace che abbiamo definito
nello schema
(http://dellapenna.univaq.it/CDColl)
Indichiamo al parser la provenienza
del
namespace XSI (schema
instance).
Questo namespace contiene gli
elementi di XSchema usati anche nei
documenti istanza.
Lattributi
schemaLocation,
proveniente dal namespace Schema
Instance, indica al validatore dove
prelevare lo schema per la
validazione.

XML Schema / 20

Namespaces
artist
schemaLocation

comment

noNamespaceSchemaLocati
on

length

type
nil

year
title
song
CD

http://www.w3.org/2001/XMLSchema-instance
http://dellapenna.univaq.it/CD

XML Schema / 21

Creare e Usare un Namespace

xsi:schemaLocation =
"http://dellapenna.univaq.it/CDColl.xsd">

targetNamespace =
"http://dellapenna.univaq.it/CD"

Album.xml

CD.xsd

Usa gli elementi del namespace


http://dellapenna.univaq.it/CD

Definisce gli elementi del namespace


http://dellapenna.univaq.it/CD

u
u

Uno schema definisce un vocabolario


Un documento-istanza usa gli elementi
definiti

XML Schema / 22

Schemi senza Namespace


E possibile, per semplicit, omettere il
namespace di appartenenza dallo schema:
questo semplifica anche la stesura dei
documenti istanza.
u Lattributo targetNamespace del tag
<schema> in realt opzionale. Omettendolo:

Nei documenti istanza, per indicare uno schema


senza namespace, utilizzare lattributo
noNamespaceSchemaLocation invece di
schemaLocation.
Nei documenti istanza, gli elementi appartenenti
allo schema non vanno qualificati con namespace.

XML Schema / 23

Schemi senza Namespace


<?xml version="1.0" encoding="UTF-8"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
elementFormDefault="qualified "
>
<xs:element name="artist" type="xs:string"/>
<xs:element name="comment" type="xs:string"/>
<xs:element name="length" type="xs:string "/>
<xs:element name="title" type="xs:string"/>
<xs:element name="year" type="xs:string"/>
<xs:element name="song">
<xs:complexType>
<xs:sequence>
<xs:element ref="artist" minOccurs ="0"/>
<xs:element ref="title"/>
<xs:element ref="year" minOccurs ="0"/>
<xs:element ref="comment" minOccurs ="0"/>
<xs:element ref="length "/>
</xs:sequence>
</xs:complexType>
</xs:element>

Gli elementi della sintassi XML


Schema
provengono
dal
namespace
http://www.w3.org/2001/XMLS
chema

Non
viene
specificato
un
targetNamespace, e neppure
un namespace di default.

XML Schema / 24

Documenti senza Namespace


<?xml version="1.0"?>
<CD
1
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance
xsi:noNamespaceSchemaLocation="http://dellapenna.univaq.it/CD. xsd ">
<song >
Indichiamo al parser la provenienza
2
<title>African Bamba</title>
del
namespace
XSI
(schema
<length >4:42</length >
instance).
</song >
Questo namespace contiene gli
<song >
elementi di XSchema usati anche nei
documenti istanza.
<artist>Santana</artist>
<title>Corazon Espinado </title>
Lattributo
<comment>
noNamespaceSchemaLocation,
First Hit from the album
proveniente dal namespace Schema
</comment>
Instance, indica al validatore dove
<length >4:36</length >
prelevare
lo
schema
per
la
</song >
validazione, specificando pure che
gli elementi di questo schema
</CD>
non sono inseriti in alcun
namespace.
Non viene specificato un namespace
di default: tutti gli elementi del
documento sono privi di namespace.
XML Schema / 25

Dichiarazioni Globali e Locali


Nello schema usato finora, abbiamo definito I
vari elementi (CD, Song, Title,) a livello
globale, cio come figli diretti dellelemento
schema.
u E possibile dichiarare elementi anche
localmente, limitandone lo scope (visibilit) e
quindi le possibilit di riuso.
u In XML Schema, elementi, attributi e tipi
possono essere dichiarati sia localmente
che globalmente.
u

XML Schema / 26

Dichiarazioni Locali
<xs:element name="CD">
<xs:complexType>
<xs:sequence>
<xs:element name="songmaxOccurs ="unbounded ">
<xs:complexType>
<xs:sequence>
<xs:element name="artist" type="xs:string " minOccurs ="0"/>
<xs:element name="title" type="xs:string"/>
<xs:element name="year" type="xs:string" minOccurs ="0"/>
<xs:element name="comment" type="xs:string" minOccurs ="0"/>
<xs:element name="length" type="xs:string "/>
</xs:sequence>
</xs:complexType>
</xs:sequence>
</xs:complexType>
</xs:element>

La dichiarazione che usa elementi locali


(nidificati) molto pi compatta.
Non possibile riutilizzare gli elementi e i tipi
dichiarati a livello locale!

XML Schema / 27

Dichiarazioni di Globali
<xs:element name="song type=songType/>
<xs:element name="CD type=cdType/>
<xs:complexTypename=songType>
<xs:sequence>
<xs:element ref="artist" minOccurs ="0"/>
<xs:element ref="title"/>
<xs:element ref="year" minOccurs ="0"/>
<xs:element ref="comment" minOccurs ="0"/>
<xs:element ref="length "/>
</xs:sequence>
</xs:complexType>

Gli elementi song e CD sono dichiarati


facendo riferimento al loro tipo dichiarato
globalmente.
Dichiara il modello di contenuto
(artist?, title, year?, comment ?, length)
come un tipo globale chiamato songType.

<xs:complexTypename=cdType>
Dichiara il modello di contenuto
<xs:sequence>
<xs:element ref="song" maxOccurs ="unbounded "/>(song)+
</xs:sequence>
come un tipo globale chiamato cdType.
</xs:complexType>

XML Schema / 28

Dichiarazioni di Globali
<xs:element name="CD">
<xs:complexType>
<xs:sequence>
<xs:element name="songmaxOccurs ="unbounded type=songType>
</xs:sequence>
</xs:complexType>
</xs:element>
<xs:complexTypename=songType >
<xs:sequence>
<xs:element name="artist" type="xs:string " minOccurs ="0"/>
<xs:element name="title" type="xs:string"/>
<xs:element name="year" type="xs:string" minOccurs ="0"/>
<xs:element name="comment" type="xs:string" minOccurs ="0"/>
<xs:element name="length" type="xs:string "/>
</xs:sequence>
</xs:complexType>

Un approccio misto, che usa elementi nidificati


(locali) e tipi sia locali (complexType anonimo)
che globali (songType).

XML Schema / 29

Riassumendo
<xs:element name="CD">
<xs:complexType>
<xs:sequence>

</xs:sequence>
</xs:complexType>
</xs:element>

<xs:complexTypename=songType >
<xs:sequence>

</xs:sequence>
</xs:complexType>

<xs:element name="song type=songType>

Tipo
anonimo
dichiarato
localmente , elemento con tipo inline

Tipo
con
globalmente.

nome

dichiarato

Riferimento a tipo globale

XML Schema / 30

10

Riassumendo
<xs:element name="CD">
<xs:complexType>
<xs:sequence>
<xs:element name="song>
<xs:complexType>

</xs:complexType>
</xs:sequence>
</xs:complexType>
</xs:element>

<xs:element name="CD">
<xs:complexType>
<xs:sequence>
<xs:element ref="song/>
</xs:sequence>
</xs:complexType>
</xs:element>

Dichiarazione locale di elementi

Riferimento ad elemento dichiarato


globalmente

<xs:element name="song">

</xs:element>
XML Schema / 31

Dichiarazione di Elementi
La dichiarazione di un elemento
(<!ELEMENT> nei DTD) si effettua usando
il tag <xs:element>.
u Un elemento ha sempre un nome .
u Gli elementi possono essere dichiarati sia
localmente che globalmente.
u La parte pi importante dellelemento
<xs:element> lindicazione del suo tipo, che
ne dichiara i contenuti (elementi, attributi,
testo, numeri, contenuto misto, ).
u

XML Schema / 32

Dichiarazione di Elementi
<xs:element name="CD">
<xs:complexType>
<xs:sequence>
<xs:element name="song>
<xs:complexType>

</xs:complexType>
</xs:sequence>
</xs:complexType>
</xs:element>

Dichiarazione dellelemento CD. Linterno


del
tag
<xs:element >
definisce
localmente il tipo dellelemento.
Notare che allinterno del tipo di CD viene
dichiarato, questa volta localmente, un
nuovo elemento (figlio) song.

Dichiarazione degli elementi song e length.


<xs:element name="song type=xs:string >

Per lelemento song, il tipo globale


richiamato per nome (si tratta di un tipo
built-in degli Schemi).

<xs:element name=length>
<xs:simpleTypebase=xs:positiveInteger>
<xs:maxInclusivevalue=1000/>
</xs:simpleType>
</xs:element>

Per lelemento length, il tipo dichiarato


localmente . Si tratta si un tipo semplice
(senza attributi n elementi figli) ottenuto
sulla
base
di
un
altro
tipo
(xs:positiveInteger) applicando apportune
restrizione (xs:maxInclusive).

XML Schema / 33

11

Riferimento ad Elementi
Lelemento <xs:element> viene anche usato
per riferirsi localmente ad elementi
dichiarati globalmente, tramite il loro nome.

<xs:element name="song type=xs:string >


<xs:element name="CD">
<xs:complexType>
<xs:sequence>
<xs:element ref="song/>
</xs:sequence>
</xs:complexType>
</xs:element>

La dichiarazione dellelemento globale


CD usa, allinterno del suo tipo,
lelemento song, anchesso dichiarato
globalmente, facendovi riferimento con
una particolare sintassi dellelemento
xs:element
(notare
la
mancanza
dellattributo name e la comparsa di ref ).

XML Schema / 34

Il Tipo degli Elementi


Abbiamo detto che negli schemi il concetto di
tipo racchiude tutti i possibili modelli di
contenuto degli elementi.
u I tipi sono cos importanti, che gli schemi ne
permettono la definizione globale (non solo
allinterno degli elementi) in modo che pi
elementi possano usare lo stesso tipo (o
variazioni di esso) facendovi semplicemente
riferimento.
u

XML Schema / 35

Il Tipo degli Elementi


u

Gli schemi definiscono due generi di tipo.

Tipo semplice, o simpleType.


Tipo complesso, o complexType.

Quali sono le differenze tra i due?

Un simpleType un tipo di dato ottenuto da


un tipo di base (es. stringa, intero) tramite
raffinamenti e restrizioni. Pu essere usato come
tipo per elementi e attributi.
Un complexType un tipo che pu contenere
elementi figlio, attributi e testo. Pu essere
usato solo per gli elementi.

XML Schema / 36

12

I Tipi Semplici
u

Vedremo ora:

Quali sono i tipi semplici di base, o built-in.


Come possibile creare nuovi tipi semplici
tramite il costrutto simpleType.

XML Schema / 37

Tipi di dato Built-in


string
boolean
decimal
float
double
duration
dateTime
time
date
gYearMonth
gYear
gMonthDay
gDay
gMonth
hexBinary
base64Binary
anyURI
Qname
NOTATION

Ciao
{true, false}
7.08
12.4E2, -4, INF, NAN
12.4E2, -4, INF, NAN
P1Y2M3DT10H30M12.3S
yyyy -mm-ddThh-mm-ss
hh:mm:ss.sss
yyyy -mm-dd
yyyy -mm
yyyy
--mm-dd
---dd
--mm-F0A1

http://dellapenna.univaq.it
xsi:schemaInstance
Una NOTATION XML

XML Schema / 38

Tipi di dato Built-in (derivati)


normalizedString
token
language
Name
NCName
integer
int
nonPositiveInteger
nonNegativeInteger
positiveInteger
negativeInteger
long
short
byte
unsignedInt
unsignedLong
unsignedShort
unsignedByte

Una stringa senza \t, \n, \r


Una normalizedString senza spazi
Un valore di tipo xml:lang (IT, EN,)
Un nome senza namespace
-2147483648 2147483647
-INF 0
0 INF
1 INF
-INF .. 1
-9223372036854775808 9223372036854775808

-32768 32767
-127 128
0 4294967295
0 18446744073709551615
0 65535
0 255

XML Schema / 39

13

Tipi di dato ereditati dai DTD


ID
IDREF
IDREFS
ENTITY
ENTITIES
NMTOKEN
NMTOKENS

Come definito nei DTD


Come definito nei DTD
Come definito nei DTD
Come definito nei DTD
Come definito nei DTD
Come definito nei DTD
Come definito nei DTD

Questi tipi si possono usare solo nella


dichiarazione di attributi!

XML Schema / 40

Creazione di Tipi Semplici


E possibile creare nuovi tipi di dato
applicando su un tipo base semplice
(simpleType, o un tipo built- in) una serie di
restrizioni chiamate facets (sfaccettature).
u Ogni tipo di dato possiede le proprie facets:
numerico, stringa, data.
u Le facets sono un mezzo potente per ottenere
un controllo di tipo molto avanzato da parte
del validatore.
u

XML Schema / 41

Creazione di Tipi Semplici


<xs:simpleTypename=NumeroTelefonico ">
<xs:restriction base="xsd :string ">
<xs:length value="8"/>
<xs:pattern value="\d{3}-\d{4}"/>
</xs:restriction >
</xs:simpleType>

Un numero telefonico una


stringa lunga 8 caratteri formata
da 3 digit, un trattino e altri 4
digit.

<xsd:simpleTypename=Forma">
<xsd:restriction base="xsd:string">
<xsd:enumeration value=cerchio"/>
<xsd:enumeration value=quadrato"/>
</xsd:restriction>
</xsd:simpleType>

Una forma una stringa a scelta


tra cerchio e quadrato.

<xsd:simpleTypename=Et">
<xsd:restriction base="xsd:nonNegativeInteger">
<xsd:maxInclusive value=150"/>
</xsd:restriction>
</xsd:simpleType>
<xsd:simpleTypename=EtAdulta">
<xsd:restriction base=Et">
<xsd:minInclusivevalue=18"/>
</xsd:restriction>
</xsd:simpleType>

Unet un intero non negativo


minore o uguale a 150.

Unet adulta unet che ha


come valore minimo 18.

XML Schema / 42

14

Sintassi di simpleType
<xs:simpleTypename=nome">
<xs:restriction base="tipo">
<xs:facet value=valore"/>
<xs:facet value=valore"/>

</xs:restriction >
</xs:simpleType>

Restrizione a partire da tipo builtin o dichiarato globalmente

<xs:simpleTypename=nome">
<xs:restriction>
<xs:simpleTypename=nome">

</xs:simpleType>

Restrizione
applicata
direttamente a un tipo anonimo
definito inline

<xs:facet value=valore"/>
<xs:facet value=valore"/>

</xs:restriction >
</xs:simpleType>

XML Schema / 43

Facets dei Tipi Numerici


minInclusive

Minimo valore rappresentabile (inclusivo)

minExclusive
maxInclusive
maxExclusive

Minimo valore rappresentabile (esclusivo)


Massimo valore rappresentabile (inclusivo)
Massimo valore rappresentabile (esclusivo)
Trattamento degli spazi: preserve , collapse ,
replace
Valore permesso. Si possono specificare pi
facet enumeration per costruire tipi a scelta
multipla.
Espressione regolare che deve fare match con il
valore. Si possono specificare pi pattern
(alternativi).
Solo per i tipi non-float, numero totale di cifre
(precisione)
Solo per i tipi non-float, numero di cifre
decimali (scala)

whiteSpace
enumeration

pattern
totalDigits
fractionDigits

XML Schema / 44

Espressioni Regolari /1
x
.
[a-z]
[abc]
[abA-C]
[^a-f]
E+
E*
E{n}
E{n,m}
E{n,}

Costante
Un carattere qualsiasi
Range di caratteri
Range negato
Una o pi volte E
Zero o pi volte E
Ripetizione (n volte E)
Ripetizione (da n a m volte E)
Ripetizione (n o pi volte E)

XML Schema / 45

15

Espressioni Regolari /2
\d
\s
\w
\p{L}
\p{Lu}
\p{Ll}
\p{N}
\p{Nd}
\p{P}
\p{Sc}
\n \r \t
\x

Digit
Spazio bianco (anche tab, CR,)
Carattere per parola (alfanumerico o trattino)
Lettera
Lettera maiuscola
Lettera minuscola
Numero
Digit
Punteggiatura
Simbolo di valuta
LF, CR, TAB
Il carattere riservato x

XML Schema / 46

Facets dei Tipi Stringa


length
minLength
maxLength
whiteSpace
enumeration

pattern

Lunghezza delle stringhe (fissa)


Lunghezza minima della stringhe
Lunghezza massima delle stringhe
Trattamento degli spazi: preserve , collapse ,
replace
Stringa permessa. Si possono specificare pi
facet enumeration per costruire tipi a scelta
multipla.
Espressione regolare che deve fare match con la
stringa. Si possono specificare pi pattern
(alternativi).

Questi facet si applicano ai tipi string,


base64Binary, anyURI, Name, Qname, e a
tutti i tipi ereditati dai DTD

XML Schema / 47

Facets del Tipi Data


minInclusive
minExclusive
maxInclusive
maxExclusive
whiteSpace
enumeration

pattern

Minimo valore rappresentabile (inclusivo)


Minimo valore rappresentabile (esclusivo)
Massimo valore rappresentabile (inclusivo)
Massimo valore rappresentabile (esclusivo)
Trattamento degli spazi: preserve , collapse ,
replace
Valore permesso. Si possono specificare pi
facet enumeration per costruire tipi a scelta
multipla.
Espressione regolare che deve fare match con il
valore. Si possono specificare pi pattern
(alternativi).

Questi facet si applicano ai tipi date, time,


dateTime, gYear, gMonth, duration

XML Schema / 48

16

Impedire la Ridefinizione di una Facet


Alcune volte si richiede che una particolare
facet non sia ridefinibile nei simpleType
derivati.
u Vogliamo cio rendere finale una
restrizione .
u

<xsd:simpleTypename=Et">
<xsd:restriction base="xsd:nonNegativeInteger">
<xsd:maxInclusive value=150 fixed =true"/>
</xsd:restriction>
</xsd:simpleType>
<xsd:simpleTypename=EtAdulta">
<xsd:restriction base=Et">
<xsd:minInclusivevalue=18"/>
<xsd:maxInclusive value=200/>
</xsd:restriction>
</xsd:simpleType>
XML Schema / 49

Uso dei simpleType Definiti


<xsd:simpleTypename=tipoEt">
<xsd:restriction base="xsd:nonNegativeInteger">
<xsd:maxInclusive value=150"/>
</xsd:restriction>
</xsd:simpleType>

Lelemento Et contiene valori di


tipo tipoEt (tipo simpleType
dichiarato
globalmente
e
richiamato).

<xs:element name="Et" type="tipoEt"/>

<xs:element name="Et">
<xsd:simpleTypename=tipoEt">
<xsd:restriction base="xsd:nonNegativeInteger">
<xsd:maxInclusive value=150"/>
</xsd:restriction>
</xsd:simpleType>
</xs:element>

Lelemento Et contiene valori di


un tipo anonimo (simpleType
dichiarato localmente ).

XML Schema / 50

Liste di Tipi Semplici


Un simpleType pu rappresentare una lista di
elementi appartenenti ad un altro tipo
semplice (che non sia a sua volta una lista).
u In XML, le liste sono rappresentate
semplicemente da oggetti separati con singoli
spazi, tabulazioni, o CR. Ad esempio 1 2 3
una lista di interi.
u E possibile applicare facets per controllare
vari aspetti della lista. Le liste hanno le
stesse facets dei tipi stringa.
u

XML Schema / 51

17

Creazione di Tipi Lista


<xs:simpleTypename=ListaDiInteri">
<xs:list itemType="xs:integer"/>
</xs:simpleType>

Dichiariamo una ListaDiInteri come


una lista di integer. Non si possono
applicare
immediatamente
le
facets: bisogna ricorrere a una
nuova restrizione.

<xs:simpleTypename=TriplaDiInteri">
<xs:restriction base="ListaDiInteri">
<xs:length value="3"/>
</xs:restriction >
</xs:simpleType>

La facet length indica in questo


caso il numero massimo di
elementi nella lista. Le facet
minLength
e
maxLength
si
riferiscono
ugualmente
alla
lunghezza della lista .

<xs:simpleTypename=PermutazioneDi123 ">
<xs:restriction base="ListaDiInteri">
<xs:enumeration value=1"/>
<xs:enumeration value=2"/>
<xs:enumeration value=3"/>
</xs:restriction >
</xs:simpleType>

Le facet enumeration e pattern s i


riferiscono
invece
ai
valori
possibili e alla forma dei singoli
elementi della lista.
Il simpleType PermutazionDi123
una lista di tre interi scelti tra 1, 2 e
3.

XML Schema / 52

Creazione di Tipi Lista: Alternativa


<xs:simpleTypename=PermutazioneDi123 ">
<xs:restriction>
<xs:simpleType>
<xs:list itemType="xs:integer"/>
</xs:simpleType>
<xs:length value="3"/>
<xs:enumeration value=1"/>
<xs:enumeration value=2"/>
<xs:enumeration value=3"/>
</xs:restriction >
</xs:simpleType>

Definizione con nidificazione di tipo


1 (restrizione su tipo lista anonimo)

<xs:simpleTypename=PermutazioneDi123 ">
<xs:restriction>
<xs:simpleType>
<xs:list>
<xs:simpleType>
<xs:restriction base="xs:integer">
<xs:enumeration value=1"/>
<xs:enumeration value=2"/>
<xs:enumeration value=3"/>
</xs:restriction >
</xs:simpleType>
</xs:list>
</xs:simpleType>
<xs:length value="3"/>
</xs:restriction >
</xs:simpleType>
Definizione con nidificazione di tipo
2 (restrizione su tipo lista anonimo
definito su tipo anonimo)

XML Schema / 53

Unione di Tipi Semplici


Un simpleType pu avere come dominio
lunione dei domini di altri tipi semplici,
anche non compatibili tra loro.
u Ad esempio, si pu dichiarare un simpleType
che accetta valori scelti tra un tipo definito
dallutente e i tipi built- in integer e string.
u In XSchema esiste un attributo maxOccurs
che ha come tipo lunione del tipo built- in
nonNegativeInteger e del tipo utente derivato
da string che pu avere il solo valore
unbounded.
u

XML Schema / 54

18

Creazione di Tipi Unione


<xs:simpleTypename=NumeroStringa">
<xs:list itemType="xs:integer xs:string"/>
</xs:simpleType>

Dichiariamo
una
NumeroStringa
come unione dei tipi built-in integer
e string. Il valore di itemType
una lista di nomi di tipi.

<xs:simpleTypename=NumeroLettera">
<xs:restriction base=NumeroStringa">
<xs:enumeration value=1"/>
<xs:enumeration value=2"/>
<xs:enumeration value=3"/>
<xs:enumeration value=A"/>
<xs:enumeration value=B"/>
<xs:enumeration value=C"/>
</xs:restriction >
</xs:simpleType>

Le uniche facet che possono


essere
applicate
a
una
restrizione di un tipo unione sono
enumeration e pattern. Entrambe
si riferiscono alla forma e ai
valori degli oggetti provenienti
dallunione dei domini specificati.

XML Schema / 55

Creazione di Tipi Unione: Alternativa


<xs:simpleTypename=NumeroLettera">
<xs:union >
<xs:simpleType>
<xs:restriction base=xs:integer">
<xs:enumeration value=1"/>
<xs:enumeration value=2"/>
<xs:enumeration value=3"/>
</xs:restriction >
</xs:simpleType>
<xs:simpleType>
<xs:restriction base=xs:string">
<xs:enumeration value=A"/>
<xs:enumeration value=B"/>
<xs:enumeration value=C"/>
</xs:restriction >
</xs:simpleType>
</xs:union >
</xs:simpleType>

Dichiariamo una NumeroLettera come


unione di due tipi semplici anonimi
dichiarati inline. Le restrizioni sono
applicate direttamente ai due
domini di origine.

XML Schema / 56

Riassunto dei simpleType


u

Un simpleType pu essere:

La restrizione di un altro simpleType, ottenuta


applicando una o pi facet
Una lista composta da altri simpleType
Lunione di altri simpleType

In tutti i casi, i tipi base possono essere


specificati:

Attraverso il loro nome, se dichiarati globalmente


Inline, tramite nidificazione di altri elementi
simpleType

XML Schema / 57

19

I Tipi Complessi
I tipi complessi rappresentano i modelli di
contenuto e le dichiarazioni ATTLIST dei DTD.
u Un tipo complesso contiene una serie di
elementi ordinati secondo particolari modelli
(sequenza, scelta, insieme,) e/o attributi.
u I tipi complessi possono essere definiti sulla
base di altri tipi complessi o semplici
applicando restrizioni ed estensioni.
u I tipi complessi possono anche essere misti,
cio contenere elementi e testo.
u

XML Schema / 58

Modelli di Raggruppamento
u

Nei DTD, sono a disposizione pochi operatori


per dichiarare la grammatica dei figli di un
elemento. Questi erano:

Sequenziamento: operatore ,
Scelta: operatore |
Ripetizione: operatori * e +

Ci sono molte carenze, ad esempio manca un


modello che indichi questi elementi in
qualsiasi ordine, molto utile nella pratica.

XML Schema / 59

Modelli di Raggruppamento
u

Gli Schemi mettono a disposizione tre


modelli di raggruppamento:

sequence, per il sequenziamento.


choice, per la scelta.
all, un nuovo modello insiemistico.

Per il controllo delle occorrenze, gli Schemi


usano gli attributi minOccurs e maxOccurs
che, come vedremo, possono essere inseriti in
vari punti nella dichiarazione dei modelli.

XML Schema / 60

20

Modelli di Raggruppamento
Cosa raggruppano i modelli di
raggruppamento? In altre parole, quali sono
gli elementi ammessi come figli di un
modello di raggruppamento?
u Gli elementi che possono comparire in un
modello di raggruppamento sono:
u

<xs:element> (elementi, dichiarati o riferiti)


<xs:group> (raggruppamenti predefiniti)
<xs:any> (qualsiasi elemento)
Altri modelli di raggruppamento (nidificazione)

XML Schema / 61

minOccurs e maxOccurs
Abbiamo detto che questi due attributi
servono a specificare quante volte un
elemento, pu essere ripetuto (compresi gli
stessi modelli di raggruppamento).
u Nei DTD, lunico corrispondente erano i
simboli +, * e ?.
u

Il valore di default dei due attributi, se non


specificati, 1.
Il valore speciale unbounded per lattributo
maxOccurs rappresenta un numero di occorrenze
illimitato.

XML Schema / 62

minOccurs e maxOccurs
Schemi

DTD

minOccurs=1
maxOccurs= unbounded

Corrisponde a +

minOccurs=0
maxOccurs= unbounded

Corrisponde a *

minOccurs=0
[maxOccurs=1]

Corrisponde a ?

minOccurs=10

Nessuna espressione corrispondente

maxOccurs=10

Nessuna espressione corrispondente

XML Schema / 63

21

Il Modello sequence
Il modello sequence indica al validatore che i
figli dichiarati dovranno apparire esattamente
nellordine dato.
u Ogni figlio, per, pu avere un proprio
limite sul numero delle occorrenze .
u A causa del trattamento avanzato delle
occorrenze, il modello sequence non
corrisponde esattamente alloperatore , dei
DTD.
u

XML Schema / 64

Il Modello sequence
<xs:complexType>
<xs:sequence>
<xs:element ref="artist" minOccurs ="0"/>
<xs:element ref="title"/>
</xs:sequence>
</xs:complexType>

Questo tipo complesso definisce un


contenuto cos composto:

<xs:complexType>
<xs:sequence>
<xs:element ref="title"/>
<xs:sequence minOccurs ="0">
<xs:element ref=track "/>
<xs:element ref=length "/>
</xs:sequence>
<xs:element ref=copyright"/>
</xs:sequence>
</xs:complexType>

Questo tipo complesso definisce un


contenuto cos composto:

Un elemento artist opzionale, seguito


da un elemento title
Nella sintassi DTD: ( artist?, title)

Un elemento elemento title, seguito


da zero o pi occorrenze di coppie di
elementi (track, length), seguite da un
elemento copyright.
Nella
sintassi
DTD:
(title,(track, length)*,copyright)

XML Schema / 65

Il Modello choice
Il modello choice indica al validatore che solo
uno dei figli dichiarati dovr apparire in
quella posizione.
u Ogni figlio, per, pu avere un proprio limite
sul numero delle occorrenze.
u A causa del trattamento avanzato delle
occorrenze, il modello sequence non
corrisponde esattamente alloperatore | dei
DTD.

XML Schema / 66

22

Il Modello choice
Questo tipo complesso definisce un
contenuto cos composto:
<xs:complexType>
<xs:choice>
<xs:element ref=el1" minOccurs ="0"/>
<xs:element ref="el2" maxOccurs =10"/>
</xs: choice >
</xs:complexType>

Un elemento el1 opzionale OPPURE


da uno a dieci elementi el2 (notare
che quindi il contenuto pu essere
anche vuoto)
Nella sintassi DTD non esiste un
corrispondente, a causa del mancato
supporto per maxOccurs.
Potremmo al pi scrivere (el1? |
el2+), ma elimineremmo il limite di
dieci occorrenze su el2.

<xs:complexType>
<xs:choice>
<xs:element ref=copyright" />
<xs:sequence maxOccurs =unbounded ">
<xs:element ref=track "/>
<xs:element ref=copyright"/>
</xs:sequence>
</xs: choice >
</xs:complexType>

Questo tipo complesso definisce un


contenuto cos composto:
Un elemento copyright OPPURE una
sequenza qualsiasi di coppie di
elementi (track, copyright)
Nella sintassi DTD:
(copyright | (track, copyright)+)

XML Schema / 67

Il Modello all
Il modello all indica al validatore che i figli
dichiarati dovranno apparire tutti, in qualsiasi
ordine, o non apparire del tutto.
u I figli del modello all possono essere solo
elementi.
u I figli del modello all, e il modello stesso,
possono avere solo cardinalit maxOccurs=1
e minOccurs=1 o minOccurs=0.
u Il modello all non pu essere nidificato in
altri modelli di raggruppamento.
u

XML Schema / 68

Il Modello all
<xs:complexType>
<xs:all>
<xs:element ref=nome"/>
<xs:element ref=cognome"/>
<xs:element ref=tel" minOccurs =0"/>
</xs:all>
</xs:complexType>

Questo tipo complesso definisce


contenuto cos composto:

un

Un elemento nome, un elemento


cognome e un numero di telefono
opzionale, in qualsiasi ordine.

XML Schema / 69

23

Tipi Complessi a Modello Misto


E possibile definire tipi complessi che
ammettano la presenza contemporanea di
testo ed elementi come contenuto.
u Il cosiddetto modello misto viene specificato
inserendo lattributo mixed=true nella
specifica del complexType.
u Il modello misto degli Schemi molto pi
controllato di quello dei DTD! Lapplicazione
del modello misto non pregiudica la
validazione del modello di contenuto!
u

XML Schema / 70

Tipi Complessi a Modello Misto


<xs:element name=Intestazione">
<xs:complexTypemixed ="true">
<xs:sequence>
<xs:element ref=TitolominOccurs =0"/>
<xs:element ref=Nome"/>
<xs:element ref=Cognome/>
</xs:sequence>
</xs:complexType>
</xs:element>
<Intestazione>
Alla cortese attenzione del
<Titolo>Dott</Titolo >&nbsp;
<Nome>Giuseppe</Nome>&nbsp ;
<Cognome>Della Penna</Cognome>,
</Intestazione>

In pratica, con un modello misto il


modello di contenuto inserito nel
complexType
continua
ad
essere
validato completamente.
Il validatore ammetter per la
presenza di generico testo tra un
elemento figlio e laltro.
In questo esempio, il modello di
contenuto
dellelemento
<Intestazione> viene effettivamente
validato nel documento istanza. Il
validatore
ammetter
anche
la
presenza del testo che si trova tra gli
elementi figli <Nome>, <Cognome> e
<Titolo>

XML Schema / 71

complexType Derivati
Finora abbiamo visto come definire tipi
complessi a partire da modelli di
raggruppamento ed elementi.
u Vedremo ora come costruire tipi complessi a
partire da altri tipi (complessi o semplici)
tramite restrizione o estensione.
u

XML Schema / 72

24

Tipi Complessi basati su Tipi Semplici


Un complexType pu essere costruito usando
come base un simpleType specificando
simpleContent come modello di contenuto.
u Sono possibili due tipi di derivazioni:

E possibile operare una restriction per applicare


ulteriori facet al tipo semplice.
E possibile operare una extension per aggiungere
al tipo complesso la specifica di attributi.
I particolari sulla sintassi di definizione degli
attributi verranno discussi in seguito.

XML Schema / 73

Tipi Complessi basati su Tipi Semplici


<xs:complexType>
<xs:simpleContent>
<xs:restriction base=xs:integer">
<xs:minInclusivevalue=10"/>
</xs:restriction >
</xs:simpleContent>
</xs:complexType>

Viene definito un tipo complesso che


contiene valori del tipo semplice
xs:integer con un minimo fissato a 6.

<xs:complexType>
<xs:simpleContent>
<xs:extension base=" xs:double">
<xs:attribute name="id" type="xs:string "/>
</xs:extension>
</xs:simpleContent>
</xs:complexType>

Viene definito un tipo complesso che


contiene valori del tipo semplice
xs:double e un attributo id di tipo
xs:string.

XML Schema / 74

Tipi Complessi basati su Tipi Complessi


Un complexType pu essere costruito usando
come base un altro complexType,
specificando complexContent come modello
di contenuto [nota CC sottinteso con modelli].
u Sono possibili due tipi di derivazioni:
u

E possibile operare una restriction, limitando


alcune caratteristiche del tipo complesso di
origine.
E possibile operare una extension per aggiungere
al tipo complesso la specifica di attributi,
elementi, ecc

XML Schema / 75

25

Restrizioni su Tipi Complessi


u

Quali restrizioni si possono applicare a un


tipo complesso?

Diminuire i valori di maxOccurs e minOccurs.


Eliminare uno o pi elementi figli e attributi.
Restringere il tipo di uno o pi attributi.

E necessario ripetere esattamente lo stesso


contenuto del tipo dal quale si deriva,
apportando le modifiche richieste.

XML Schema / 76

Restrizioni su Tipi Complessi


<xs:complexTypename=tracklist" >
<xs:choice>
<xs:element ref=copyright" />
<xs:sequence maxOccurs =unbounded ">
<xs:element ref=track "/>
<xs:element ref=copyright"/>
</xs:sequence>
</xs: choice >
</xs:complexType>
<xs:complexTypename=twotracklist" >
<xs:complexContent >
<xs:restriction base=tracklist ">
<xs:sequence maxOccurs =2">
<xs:element ref=track "/>
<xs:element ref=copyright"/>
</xs:sequence>
</xs:restriction >
</xs:complexContent>
</xs:complexType>

Il tipo twotracklist presenta DUE


restrizioni rispetto al tipo base
tracklist:
E stata eliminata una delle due scelte
possibili dellelemento xs:choice, che
quindi

stato
rimosso
completamente.
Il numero massimo di occorrenze
della xs:sequence stato diminuito a
2 (prima era unbounded).

XML Schema / 77

Estensioni su Tipi Complessi


u

Quali estensioni si possono applicare a un


tipo complesso?

Inserire nuovi elementi figli.


Aggiungere attributi.

Il tipo derivato deve listare i soli elementi da


aggiungere al tipo base. I figli verranno
accodati alla definizione del tipo base.

XML Schema / 78

26

Estensioni su Tipi Complessi


<xs:complexTypename=tracklist" >
<xs:choice>
<xs:element ref=copyright" />
<xs:sequence maxOccurs =unbounded ">
<xs:element ref=track "/>
<xs:element ref=copyright"/>
</xs:sequence>
</xs: choice >
</xs:complexType>
<xs:complexTypename=trackandtitlelist" >
<xs:complexContent >
<xs:extension base=tracklist">
<xs:sequence maxOccurs =unbounded ">
<xs:element ref=track "/>
<xs:element ref=title"/>
</xs:sequence>
</xs:restriction >
</xs:complexContent>
</xs:complexType>

Il tipo trackandtitlelist stato esteso


rispetto al tipo base tracklist aggiungendo
una nuova sequence di coppie (track, title).
Il validatore accoder la nuova definizione
mettendola in sequenza con quella di base.
In
altre
parole,
la
definizione
di
trackandtitlelist vista dal validatore sar la
seguente:
<xs:complexTypename=tracklist" >
<xs:sequence>
<xs:choice>
<xs:element ref=copyright" />
<xs:sequence maxOccurs =unbounded ">
<xs:element ref=track "/>
<xs:element ref=copyright"/>
</xs:sequence>
</xs: choice >
<xs:sequence maxOccurs =unbounded ">
<xs:element ref=track "/>
<xs:element ref=title"/>
</xs:sequence>
</xs:sequence>
</xs:complexType>

XML Schema / 79

Impedire le Derivazioni
A volte desiderabile impedire che utenti di
uno schema creino tipi derivati a partire da
tipi presenti nello schema di origine.
u E possibile richiedere al validatore di
rifiutare particolari derivazioni su un tipo
semplice o complesso, usando lattributo
finale degli elementi complexType e
simpleType.
u

XML Schema / 80

Impedire le Derivazioni
u

Per i simpleType, lattributo pu essere:

final=list: non si possono creare liste basate su


questo simpleType.
final=union: non si possono creare unioni che
includano questo simpleType.
final=restriction: non si possono creare tipi
semplici restringendo a questo simpleType.
final=#all: tutte le operazioni di derivazione che
fanno riferimento a questo simpleType sono
proibile.

XML Schema / 81

27

Impedire le Derivazioni
u

Per i complexType, lattributo pu essere:

final=extension: non si possono tipi estendendo


questo complexType.
final=restriction: non si possono tipi
restringendo questo complexType.
final=#all: tutte le operazioni di derivazione che
fanno riferimento a questo complexType sono
proibile.

XML Schema / 82

Sostituzione di Elementi
A cosa serve veramente la creazione di tipi
derivati?
u Soprattutto nel caso della restrizione dei tipi
complessi (dove necessario ripetere tutto il
contenuto del tipo base), sembrerebbe solo
lavoro sprecato.
u In realt, i tipi derivati tra loro sono
compatibili, e lo sono anche gli elementi che
hanno tali tipi. Questo permette il
meccanismo della sostituzione degli elementi.
u

XML Schema / 83

Sostituzione di Elementi
La sostituzione degli elementi usa (in maniera
assai pi permissiva) un meccanismo noto
nella programmazione Object-Oriented: un
tipo derivato pu comparire dovunque sia
richiesto il suo tipo base.
u Negli schemi, un qualunque tipo che sia
uguale o derivato da un altro pu comparire al
suo posto.
u E tuttavia necessario dichiarare al validatore
quali tipi saranno sostituibili.
u

XML Schema / 84

28

substitutionGroup
u

Per definire un gruppo di elementi sostituibili


tra loro, necessario:

Decidere quale sar lelemento radice del


gruppo, quello da cui gli altri sono derivati.
Dichiarare gli altri elementi come facenti parte
del gruppo di sostituzione della radice, usando
lattributo substitutionGroup del tag <xs:element>
impostato al nome dellelemento radice.

XML Schema / 85

substitutionGroup
<xs:complexTypename="TPubblicazione">
<xs:sequence>
<xs:element ref="titolo "/>
<xs:element ref="autore"/>
</xs:sequence>
</xs:complexType>
<xs:complexTypename="TLibro ">
<xs:complexContent >
<xs:extension base="TPubblicazione">
<xs:sequence>
<xs:element ref="ISBN"/>
</xs:sequence>
</xs:extension>
</xs:complexContent>
</xs:complexType>
<xs:complexTypename="TRivista">
<xs:complexContent >
<xs:extension base="TPubblicazione">
<xs:sequence>
<xs:element ref="Volume"/>
</xs:sequence>
</xs:extension>
</xs:complexContent>
</xs:complexType>

I tipi TLibro e TRivista sono entrambi


derivati da TPubblicazione, quindi
sono compatibili con esso

XML Schema / 86

substitutionGroup
<xs:element name="Libro" type="TLibro " substitutionGroup ="Pubblicazione"/>
<xs:element name="Rivista" type="TRivista" substitutionGroup="Pubblicazione"/>
<xs:element name="Pubblicazione" type="TPubblicazione"/>
<xs:element name="Riferimenti">
<xs:complexType>
<xs:sequence>
<xs:element ref="Pubblicazione" maxOccurs ="unbounded "/>
</xs:sequence>
</xs:complexType>
</xs:element>

Unistanza di documento possibile con questo


schema la seguente:

<Riferimenti>
<Libro >...</Libro>
<Rivista>...</Rivista>
</Riferimenti>
XML Schema / 87

29

substitutionGroup

XML Schema / 88

Altro sulla Sostituzione


E possibile impedire che altri elementi si
dichiarino sostituibili con un particolare
elemento inserendo in questultimo lattributo
block=substitution.
u La sostitutivit transitiva: se B
sostituibile con A e C sostituibile con B
allora C sostituibile con A.
u La sostitutivit asimmetrica: se B nel
subsititutionGroup di A, non corretto
inserire A dove richiesto B.
u

XML Schema / 89

Un Nuovo DTD di Partenza


<!ELEMENT artist (#PCDATA)>
<!ELEMENT title (#PCDATA)>
<!ELEMENT year (#PCDATA)>
<!ELEMENT comment (#PCDATA)>
<!ELEMENT length (#PCDATA)>
<!ELEMENT song (artist?, title, year?, comment ?, length)>
<!ATTLIST song
track
NMTOKEN #required
>
<!ELEMENT CD song+>
<!ATTLIST CD
compilation (true | false) false
prodid NMTOKEN #required
>

Abbiamo aggiunto la definizione di alcuni


attributi.

XML Schema / 90

30

Un Nuovo XSD di Partenza


<xs:element name="song">
<xs:complexType>
<xs:sequence>
<!ELEMENT song
<xs:element ref="artist" minOccurs ="0"/>
(artist?, title, year?, comment ?, length)
<xs:element ref="title"/>
>
<xs:element ref="year" minOccurs ="0"/>
<xs:element ref="comment" minOccurs ="0"/> <!ATTLIST song
<xs:element ref="length "/>
track NMTOKEN #required
</xs:sequence>
>
<xs:attribute name="track "
type="xs:positiveInteger" use="required "/>
</xs:complexType>
</xs:element>
<xs:element name="CD">
<xs:complexType>
<!ELEMENT CD song+>
<xs:sequence>
<!ATTLIST CD
<xs:element ref="song" maxOccurs ="unbounded "/>
</xs:sequence>
compilation (true | false) false
<xs:attribute name=prodid"
prodid NMTOKEN #required
type="xs:positiveInteger" use="required "/>
>
<xs:attribute name=compilation"
type="xs:boolean " default="true"/>
</xs:complexType>
</xs:element>
XML Schema / 91

Un Nuovo XSD di Partenza

XML Schema / 92

Attributi
Lunica componente di che non abbiamo
ancora affrontato sono gli attributi.
u Anche gli attributi entrano a far parte del
concetto di tipo degli Schemi:
u

Gli attributi hanno un tipo, che pu per


essere solo un simpleType .
Gli attributi possono essere definiti solo
allinterno di un complexType : un elemento con
attributi avr sempre un tipo complesso, che per
pu essere ottenuto estendendo con attributi un
tipo semplice.

XML Schema / 93

31

Attributi
u

La dichiarazione di un attributo si effettua


mediante il tag <xs:attribute>

Ogni attributo deve avere un nome.


Il tipo (semplice) dellattributo pu essere
richiamato tramite lattributo type (se built-in o
globale) o definito localmente tramite un
simpleType nidificato.
possibile specificare le condizioni duso
dellattributo tramite lattributo use.
possibile fissare il valore di default tramite
lattributo value.

XML Schema / 94

Attributi
<xsd:attribute name="track " type="xsd:positiveInteger" use="required "/>
L'attributo track un intero positivo, ed sempre
necessario specificarlo
<xsd:attribute name="compilation " type="xsd :boolean" value="true"/>
L'attributo compilation un booleano, con valore di
default (se non specificato) uguale a true
<xsd:attribute name=genre" use="optional">
<xsd:simpleType>
<xsd:restriction base="xsd:string">
<xsd:pattern value=rock"/>
<xsd:pattern value=pop"/>
</xsd:restriction>
</xsd:simpleType>
</xsd:attribute>
L'attributo opzionale genre di un tipo utente
(enumerativo) dichiarato localmente alla definizione
dellattributo.
<xsd:attribute name=source" type="xsd:string " use="fixed" value=digital"/>
L'attributo source una stringa a valore fisso
digital. Non pu essere specificato nei documenti!
XML Schema / 95

Attributi
u

Riassumendo, gli attributi del tag


<xs:attribute> sono:

name, il nome dellattributo definito, richiesto.


type, il tipo dellattributo, opzionale.
use, le condizioni duso dellattributo, che
possono essere:

optional (il default)


required
fixed
prohibited

value, un valore di default per lattributo.

XML Schema / 96

32

Aggiungere Attributi a un Tipo


u

Gli attributi vengono sempre inseriti


allinterno di un complexType. per
possibile dichiararli:

localmente, allinterno del complexType, sempre


dopo il modello di contenuto.
globalmente, facendovi poi riferimenti locali
come nel caso degli elementi.
globalmente a gruppi (attributeGroup), in modo
da poter fare riferimento a un insieme di attributi
di uso comune con un nome unico.

XML Schema / 97

Aggiungere Attributi a un Tipo


<xsd:attribute name=genre">
<xsd:simpleType>
<xsd:restriction base="xsd:string">
<xsd:pattern value=rock"/>
<xsd:pattern value=pop"/>
</xsd:restriction>
</xsd:simpleType>
</xsd:attribute>

In questo esempio, lattributo genre dichiarato


a livello globale, in modo da poter essere
utilizzato da pi elementi (o meglio tipi). Notare
che gli attributi globali non possono avere
un attributo use (che ha significato solo
localmente).
Lelemento song ha un tipo (complesso) che
comprende due attributi. Il primo, track,
dichiarato localmente, mentre il secondo, genre,
richiamato dallesterno.

<xs:element name="song">
<xs:complexType>
Notare che la dichiarazione degli attributi segue
<xs:sequence>
sempre quella del contenuto del complexType.
...
</xs:sequence>
<xsd:attribute name="track " type="xsd:positiveInteger" use="required "/>
<xsd:attribute ref=genre"/>
</xs:complexType>
</xs:element>

XML Schema / 98

Aggiungere Attributi a un Tipo


<xsd:attribute name=genre" use="optional">
<xsd:simpleType>
<xsd:restriction base="xsd:string">
...
</xsd:restriction>
</xsd:simpleType>
</xsd:attribute>
<xsd:attributeGroup name=songAttributes">
<xsd:attribute ref=genre"/>
<xsd:attribute name="track " type="xsd:positiveInteger"
use="required "/>
</xsd:attributeGroup>

In questo esempio, lattributo genre


dichiarato a livello globale.
Viene quindi dichiarato globalmente
un gruppo di attributi, contenente
un riferimento allattributo globale
genre e la definizione dellattributo
track.

Lelemento
song
ha
un
tipo
(complesso)
che
comprende
il
gruppo di attributi songAttributes
<xs:element name="song">
(genre e track) e lattributo source
<xs:complexType>
dichiarato localmente.
<xs:sequence>
...
</xs:sequence>
<xsd:attributeGroup ref=songAttributes"/>
<xsd:attribute name=source" type="xsd:string " use="fixed" value=digital"/>
</xs:complexType>
</xs:element>
XML Schema / 99

33

Estensione con Attributi


Abbiamo visto anche come sia possibile
estendere sia complexType che simpleType,
trasformando questi ultimi in tipi complessi.
u Il procedimento di estensione permette anche
di aggiungere attributi a un tipo complesso,
ma viene usato sui tipi semplici solo a questo
scopo.
u In altre parole, lestensione dei simpleType
stata introdotta al solo scopo di potervi
aggiungere attributi.
u

XML Schema / 100

Estensione con Attributi


<xs:complexTypename=dwid">
<xs:simpleContent>
<xs:extension base="xs:double">
<xs:attribute name="id" type="xs:string "/>
</xs:extension>
</xs:simpleContent>
</xs:complexType>
<xs:complexTypename=songType">
<xs:sequence>
...
</xs:sequence>
<xsd:attributeGroup ref=songAttributes"/>
</xs:complexType>
<xs:complexTypename=swid">
<xs:complexContent >
<xs:extension base=type1 ">
<xs:attribute name="id" type="xs:string "/>
</xs:extension>
</xs:complexContent>
</xs:complexType>

Il tipo complesso dwid permette


linserimento di un valore di tipo
xs:double ed ha un attributo id di
tipo xs:string. In altre parole, un
elemento con questo tipo conterr
un numero a doppia precisione ed
avr un attributo (opzionale) i d di
tipo stringa.

In tipo complesso songType contiene


gi
una
serie
di
attributi
songAttributes , oltre a un modello di
contenuto.
Il tipo swid, derivato da songType
per estensione, conterr anche
lattributo id di tipo xs:string.

XML Schema / 101

Restrizione di Attributi
u

anche possibile restringere un complexType


agendo sui suoi attributi:

eliminando la definizione di uno o pi attributi.


Ridefinendo il tipo di uno o pi dei suoi attributi,
in modo da renderli pi restrittivi.

XML Schema / 102

34

Riassunto...

<xs:element name=Nome type=xs:string">


<xs:element name=Telefono type=telType">

Dichiarazione di un elemento con tipo semplice


built-in o definito dallutente

XML Schema / 103

Riassunto...
<xs:element name=Telefono>
<xs:simpleType>
<xs:restriction base="xs:string">
<xs:pattern value="\+\d{1,4}(-\d{1,4})?-\d{1,4}-\d+"/>
</xs:restriction>
</xs:simpleType>
</xs:element>

Dichiarazione di un elemento con tipo semplice


definito localmente

XML Schema / 104

Riassunto...
<xs:element name=Nome>
<xs:complexType>
<xs:simpleContent>
<xs:extension base="xs:string">
<xs:attribute name="titolo" type="xs:string"/>
</xs:extension>
</xs:simpleContent>
</xs:complexType>
</xs:element>

Dichiarazione di un elemento con tipo semplice


esteso con attributi a un tipo complesso

XML Schema / 105

35

Riassunto...
<xs:element name=Indirizzo>
<xs:complexType>
<xs:all>
<xs:element ref="Via"/>
<xs:element ref="Citta"/>
<xs:element ref="CAP"/>
</xs:all>
</xs:complexType>
</xs:element>

Dichiarazione di un elemento con tipo complesso


definito inline

XML Schema / 106

Riassunto...
<xs:complexType name=indType >
<xs:all>
<xs:element ref="Via"/>
<xs:element ref="Citta"/>
<xs:element ref="CAP"/>
</xs:all>
</xs:complexType>
<xs:element name=Indirizzo type=indType >

Dichiarazione di un elemento con tipo complesso


definito in un complexType esterno

XML Schema / 107

Riassunto...
<xs:element name="IndirizzoEstero">
<xs:complexType>
<xs:complexContent>
<xs:extension base="indType">
<xs:sequence >
<xs:element name="Nazione type=xs:string"/>
</xs:sequence>
</xs:extension>
</xs:complexContent>
</xs:complexType>
</xs:element>

Dichiarazione di un elemento con tipo complesso


definito tramite estensione o restrizione di un
complexType esterno.

XML Schema / 108

36

Valori di Default per Elementi


E possibile specificare un valore di default
o un valore fisso per tutti gli elementi che
abbiano un tipo semplice come contenuto.
u Allinterno del tag <xs:element>:

Lattributo fixed dichiara il valore fissato per il


contenuto di un elemento (che anche il valore di
default se questultimo non viene specificato).
Lattributo default specifica il valore di default da
dare al contenuto dellelemento, se questo non
viene specificato.

Queste regole si applicano agli elementi


vuoti inseriti nel documento istanza.

XML Schema / 109

Elementi Vuoti
u

E ovviamente dichiarare elementi che siano:

Privi di contenuto (specificando un


complexType con soli attributi).
Completamente vuoti (specificando un
complexType vuoto).

<xs:element name="emptyElement">
<xs:complexType/>
</xs:element>

<xs:element name="img ">


<xs:complexType>
<xs:attribute name="href" type="xs:anyURI"/>
</xs:complexType>
</xs:element>

Elemento vuoto

Elemento vuoto con attributi

<emptyElement/>

<img href=http://xxxxxxx "/>

XML Schema / 110

Elemento group
u

Lelemento group consente il raggruppamento


di elementi e modelli di contenuto allinterno
di gruppi logici.

Lelemento group pu venire poi utilizzato per


richiamare lintero gruppo di elementi allinterno
di pi tipi.
Nella pratica, group viene utilizzato in
sostituzione delle entit parametriche dei DTD.

Group non pu contenere definizioni di


attributi!

XML Schema / 111

37

Elemento group
<xs:group name="common">
<xs:sequence>
<xs:element ref="artist"/>
<xs:element ref="title"/>
</xs:sequence>
</xs:group >
<xs:element name="song">
<xs:complexType>
<xs:sequence>
<xs:group ref="common"/>
<xs:element ref="year" minOccurs ="0"/>
<xs:element ref="comment"/>
<xs:element ref="length "/>
</xs:sequence>
</xs:complexType>
</xs:element>

<xs:element name="song">
<xs:complexType>
<xs:sequence>
<xs:sequence>
<xs:element ref="artist"/>
<xs:element ref="title"/>
</xs:sequence>
<xs:element ref="year" minOccurs ="0"/>
<xs:element ref="comment"/>
<xs:element ref="length "/>
</xs:sequence>
</xs:complexType>
</xs:element>

Il gruppo common contiene un modello di contenuto standard. I gruppi hanno


sempre un nome e sono dichiarati globalmente .
Il gruppo viene poi utilizzato dal tipo dellelemento song facendovi riferimento.
In pratica, il riferimento al gruppo viene espanso inline dal validatore: il tipo risultante
per song quindi quello indicato a destra.
XML Schema / 112

Elemento group

XML Schema / 113

Elemento group
<xs:group name="flow">
<xs:choice>
<xs:element ref="B"/>
<xs:element ref="I"/>
<xs:element ref="BR"/>
</xs:choice>
</xs:group >
<xs:element name="P">
<xs:complexTypemixed ="true">
<xs:sequence>
<xs:group ref="flow" minOccurs ="0
maxOccurs ="unbounded "/>
</xs:sequence>
</xs:complexType>
</xs:element>
<xs:element name=H1 ">
<xs:complexTypemixed ="true">
<xs:sequence>
<xs:group ref="flow" minOccurs ="0
maxOccurs ="unbounded "/>
</xs:sequence>
</xs:complexType>
</xs:element>

In questo esempio, pi realistico,


riportiamo un frammento semplificato
della definizione di XHTML.
In XHTML, elementi quali <P> o <H1>
possono contenere al loro interno un
certo numero di altri tag usati nel
flusso del testo, come ad esempio
<B>, <I>, ecc.
Per evitare di ripetere la definizione
dei tag nidificabili in ogni elemento,
questi
vengono
raggruppati
globalmente e richiamati come gruppo
nei vari elementi.
Nel DTD di XHTML questo veniva
realizzato
usando
una
entit
parametrica, come nel frammento che
segue:
<!ENTITY % flow "(B | I | BR)">
<!ELEMENT P (#PCDATA | (%flow;)*)*>
<!ELEMENT H1 (#PCDATA | (%flow;)*)*>

XML Schema / 114

38

Elemento attributeGroup
u

Lelemento attributeGroup consente il


raggruppamento di attributi allinterno di
gruppi logici.

Lelemento attributeGroup pu venire poi


utilizzato per richiamare lintero gruppo di
attributi allinterno di pi tipi.
Nella pratica, attributeGroup viene utilizzato in
sostituzione delle entit parametriche dei DTD.

XML Schema / 115

Elemento attributeGroup
<xs:attributeGroup name="commonAttrs">
<xs:attribute name="id" type="xs:string "/>
<xs:attribute name="class" type="xs:string"/>
<xs:attribute name="style" type="xs:string "/>
</xs:attributeGroup >
<xs:element name="P">
<xs:complexTypemixed ="true">
<xs:sequence>
<xs:group ref="flow" minOccurs ="0
maxOccurs ="unbounded "/>
</xs:sequence>
<xs:attributeGroup ref="commonAttrs "/>
<xs:attribute name="align ">
<xs:simpleType>
<xs:restriction base="xs:string">
<xs:enumeration value="left"/>
<xs:enumeration value="right"/>
</xs:restriction >
</xs:simpleType>
</xs:attribute>
</xs:complexType>
</xs:element>

In XHTML, quasi tutti i tag possono


avere i tre attributi style, class e id.
E quindi utile inserire questi tre
attributi un un gruppo, e poi
richiamarlo allinterno degli elementi
che li incorporano.
Notare che in questo caso gli attributi
sono stati definiti direttamente nel
gruppo. Questo significa che non
potremo mai riferirci localmente a uno
di questi singolarmente.
Ovviamente, ai gruppi di attributi
possono essere affiancate anche delle
normali definizioni di attributo. In
questo caso, ad esempio, il tag P
dichiara anche un suo attributo align.

XML Schema / 116

Estendibilit dei Documenti Istanza


Finora con gli schemi abbiamo definito delle
strutture rigide che il creatore di documentiistanza deve rispettare.
u Tuttavia, in alcuni casi opportuno lasciare a
chi crea il documento la facolt di estendere
lo schema predefinito con altro elementi.
u

Ad esempio, uno schema pu rappresentare una


struttura di base, e poi permettere allutente di
aggiungere informazioni specifiche tramite
elementi presi da altre grammatiche.

XML Schema / 117

39

Elemento any
u

Lelemento any permette agli autori dei


documenti istanza di estendere il contenuto
usando elementi non presenti nello schema.

In altre parole, lelemento any permette di


lasciare aperto il contenuto di un elemento
definito nello schema.

Lelemento <xs:any> pu essere inserito in


qualsiasi modello di contenuto.

Spesso, opportuno porre minOccurs=0 per


any, in modo che laggiunta di altri elementi
divenga opzionale.

XML Schema / 118

Elemento any
<xs:schema targetNamespace="APersona" xmlns="APersona
xmlns:xs="http://www.w3.org/2001/XMLSchema>
<xs:element name="Persona">
<xs:complexType>
<xs:sequence>
<xs:element ref="Nome"/>
<xs:element ref="Cognome"/>
<xs:any minOccurs ="0" maxOccurs ="unbounded"/>
</xs:sequence>
</xs:complexType>
</xs:element>
<xs:schema targetNamespace="AIndirizzo " xmlns="AIndirizzo "
xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:element name="Indirizzo ">
<xs:complexType>
<xs:all>
<xs:element ref="Via"/>
<xs:element ref="Citt"/>
<xs:element ref="CAP"/>
</xs:all>
</xs:complexType>
</xs:element>

Consideriamo
questi
due
frammenti di Schema. Notare
che entrambi hanno un
namespace: questo molto
importante
quando
si
intendono
mescolare
(e
validare) elementi provenienti
da schemi diversi nello stesso
documento istanza.
Lelemento
Persona
(namespace
APersona)
permette linserimento di
altri elementi qualsiasi alla
dopo Nome e Cognome, per
inserire informazioni specifiche
nelle istanze.
Nel nostro semplice esempio,
noi inseriremo un elemento
indirizzo in ogni elemento
persona. Come?

XML Schema / 119

Elemento any
<?xml version="1.0" encoding="UTF-8"?>
<Personaxmlns="APersona" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation ="APersona Persona.xsd AIndirizzo Indirizzo.xsd ">
<Nome> Giuseppe </Nome>
<Cognome> Della Penna </Cognome>
<Indirizzo xmlns="AIndirizzo ">
<Via>Giulia</Via>
<Citt>Vasto</Citt>
<CAP>66054 </CAP>
</Indirizzo >
</Persona>
Nellelemento radice del nostro documento, tramite lattributo xsi:schemaLocation,
specifichiamo una lista di schemi, associandoli al nome del loro namespace (il
formato namespace1 indirizzoxsd1 namespace2 indirizzoxds2 ).
Quando inseriamo gli elementi, definiamo il loro namespace di appartenenza. In
questo caso, tramite lattributo xmlns , stiamo dicendo che gli elementi del
sottoalbero Parsona appartengono al namespace APersona, tranne indirizzo, che
ridefinisce il proprio namespace (e quello dei propri figli) come AIndirizzo.
In questo modo il validatore applicher le regole dello schema corrispondente
a ciscun namespace agli elementi che vi appartengono.
XML Schema / 120

40

Elemento anyAttribute
Lelemento anyAttribute permette agli autori
dei documenti istanza di estendere il
contenuto degli elementi inserendo attributi
non presenti nello schema.
u Lelemento <xs:anyAttribute> pu essere
inserito in qualsiasi modello di contenuto.
u

XML Schema / 121

Elemento anyAttribute
<xs:schema targetNamespace="APersona" xmlns="APersona"
xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:element name="Persona">
<xs:complexType>
<xs:sequence>
<xs:element ref="Nome"/>
<xs:element ref="Cognome"/>
</xs:sequence>
<xs:anyAttribute/>
</xs:complexType>
</xs:element>
<?xml version="1.0" encoding="UTF-8"?>
<Personaxmlns="APersona"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation ="Persona.xsd
newattribute=newvalue>
<Nome> Giuseppe </Nome>
<Cognome> Della Penna </Cognome>
</Persona>

Consideriamo il frammento di
schema in alto. Lelemento
Persona
dichiara
di
poter
accettare qualsiasi attributo.
Nel documento istanza, un nuovo
attributo newvalue inserito in
Persona. Il validatore accetter
questo attributo.
Da notare che in questo caso
lattributo non ha namespace
e quindi nessuno schema per
la sua validazione, quindi il
validatore non effettuer alcun
controllo sul suo contenuto.

XML Schema / 122

Namespaces ed Elementi any


La forma base (vuota) degli elementi any e
anyAttribute permette linserimento di
elementi/attributi provenienti da ogni
namespace.
u Tuttavia, possibile limitare i namespaces da
cui le estensioni possono essere prelevate,
usando lattributo namespace su entrambi gli
elementi any e anyAttribute.
u

XML Schema / 123

41

Namespaces ed Elementi any


u

Lattributo namespace pu assumere i valori


seguenti:

##any : (default) oggetti da ogni namespace.


##local : oggetti non qualificati (senza
namespace).
##other : oggetti che non siano nel namespace
dellelemento/attributo che si sta definendo.
##targetNamespace : altri oggetti dallo stesso
namespace dellelemento/attributo che si sta
definendo.
Una lista esplicita di namespaces.

XML Schema / 124

Annotazioni
Le annotazioni non hanno alcun effetto sulla
validazione. Servono solo a documentare lo
schema fornendo informazioni utili per gli
esseri umani e per altre applicazioni.
u Le annotazioni possono essere inserite:
u

Prima e dopo ogni elemento globale.


Allinizio (dopo il tag di apertura) di ogni
elemento non globale o globale.

XML Schema / 125

Annotazioni
Le annotazioni sono poste allinterno dei tag
<xs:annotation>.
u Esistono due tipi di annotazioni:

<xs:documentation>: annotazioni testuali utili


per gli esseri umani.
<xs:appinfo>: annotazioni in un linguaggio
XML valido, utili per altre applicazioni.
Lannotazione pu essere inline o contenuta in un
file puntato dallattributo opzionale source.
Il tag documentation accetta anche un attributo
xml:lang.

XML Schema / 126

42

Inserire Annotazioni
<xs:element name="artist" type="xs:string"/>
<xs:annotation>
<xs:documentation>
Annotazione inserita prima dellelemento globale
Titolo della canzone
</xs:documentation>
</xs:annotation>
<xs:element name=title" type="xs:string"/>
<xs:element name="song">
<xs:annotation>
<xs:documentation> Annotazione inserita dopo un tag di apertura
Una sequenza
</xs:documentation>
</xs:annotation>
<xs:complexType>
<xs:sequence>
<xs:element ref="artist" minOccurs ="0"/>
<xs:element ref="title"/>
</xs:sequence>
</xs:complexType>
</xs:element>

XML Schema / 127

Creare Documenti con pi di uno Schema


<?xml version="1.0" encoding="UTF-8"?>
<Rubrica xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:p="APersona" xmlns :i="AIndirizzo
xsi:schemaLocation ="APersona Persona.xsd AIndirizzo Indirizzo.xsd ">
<p:Persona>
<p:Nome> Giuseppe </p:Nome>
<p:Cognome> Della Penna </p:Cognome>
</p:Persona>
<i:Indirizzo >
< i:Via>Giulia</ i:Via>
< i:Citt>Vasto</ i:Citt>
< i:CAP>66054</ i:CAP>
</i:Indirizzo >
</Rubrica>
In questo esempio, utilizziamo elementi da due namespaces diversi, Aindirizzo e
Apersona, per costruire il documento istanza. Vengono indicati due schemi al
validatore, uno per ciascun namespace definito.
Il validatore user lo schema associato al namespace di ciascun elemento
per validarlo . Inoltre, poich lelemento root non viene dichiarato in
nessuno dei namespaces importati, il validatore lo ignorer.
XML Schema / 128

Combinare Schemi Diversi


Possiamo creare uno schema a partire da
pi schemi diversi, ed aggiungendo nuovi
elementi.
u I tipi di combinazione possibili sono:
u

Importare in uno schema altri schemi che


definiscono elementi nello stesso namespace.
Importare in uno schema altri schemi che
definiscono elementi senza namespace.
Importare in uno schema altri schemi che
definiscono elementi in namespaces diversi.

XML Schema / 129

43

Importare Schemi con lo Stesso Namespace


<xs:schema targetNamespace="APersona"
xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns="APersona">
<xs:element name="Titolo ">
<xs:simpleType>

</xs:simpleType>
</xs:element >
<xs:schema targetNamespace="APersona"
xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns="APersona" >
<xs:include schemaLocation="Persona-titolo.xsd"/>
<xs:element name="Persona">
<xs:complexType>
<xs:sequence>
<xs:element ref=Titolo"/>
<xs:element ref="Nome"/>
<xs:element ref="Cognome"/>
Il secondo schema importa il primo, che
definisce
elementi
nello
stesso
</xs:sequence>
</xs:complexType>
namespace.
</xs:element>
Il secondo schema fa riferimento agli
elementi
dello
schema
importato
esattamente come fossero dichiarati nello
stesso documento.
XML Schema / 130

Importare Schemi senza Namespace


<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:element name="Titolo ">
<xs:simpleType>

</xs:simpleType>
</xs:element>

<xs:schema targetNamespace="APersona"
xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns="APersona" >
<xs:include schemaLocation="Persona-titolo.xsd"/>
<xs:element name="Persona">
<xs:complexType>
Il secondo schema importa il primo, che
<xs:sequence>
definisce elementi senza namespace.
<xs:element ref=Titolo"/>
In questo caso, gli elementi importati
<xs:element ref="Nome"/>
vengono inseriti nel namespace del
<xs:element ref="Cognome"/>
documento
che
li
importa ,
cio
</xs:sequence>
APersona.
</xs:complexType>
</xs:element>
Il secondo schema fa riferimento agli
elementi
dello
schema
importato
esattamente come fossero dichiarati nello
stesso documento.
XML Schema / 131

Importare Schemi con Namespaces Diversi


<xs:schema targetNamespace="ATelefono " xmlns="ATelefono
xmlns:xs="http://www.w3.org/2001/XMLSchema" >
<xs:simpleTypename="telType">
<xs:restriction base="xs:string">
<xs:pattern value="\+\d{1,4}(-\d{1,4})?-\d{1,4}-\d+"/>
</xs:restriction >
</xs:simpleType>
<xs:schema targetNamespace="APersona"
xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns="APersona" >
<xs:import namespace=ATelefono " schemaLocation =Telefono .xsd"/>
<xs:element name="Persona">
<xs:complexType>
Il secondo schema importa il namespace
<xs:sequence>
del primo.
<xs:element ref=Titolo"/>
Il secondo schema usa un tipo definito nel
<xs:element ref="Nome"/>
namespace importato per dichiarare un
<xs:element ref="Cognome"/>
proprio elemento. Il tipo qualificato col
<xs:element name=Telefono
suo namespace di appartenenza .
type=ATelefono :telType"/>
</xs:sequence>
</xs:complexType>
</xs:element>

Tutti gli altri elementi disponibili nel


namespace importato saranno utilizzabili
anche nei documenti istanza, ma
dovranno essere qualificati col loro
namespace.

XML Schema / 132

44

Riferimenti

Specifica di XML schema dal W3C,


prima parte
http://www.w3c.org/TR/xmlschema-0/

XML Schema / 133

45