All2 9-3-2004

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 "
>
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:complexType>
<xs:sequence>
<xs:element ref="comment" minOccurs ="0"/>
</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
targetNamespace ="http://dellapenna.univaq.it/CD"
xmlns ="http://dellapenna.univaq.it/CD" >
elementFormDefault posto a
qualified indica che tutti i
documenti che fanno uso degli
elementi definiti in questa
sintassi dovranno sempre
dichiararne il namespace.
<xs:complexType>
<xs:sequence>
</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
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>
</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
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

Definisce gli elementi del namespace

u
u
Uno schema definisce un vocabolario

Un documento-istanza usa gli elementi
definiti
XML Schema / 22

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

>
<xs:complexType>
<xs:sequence>
</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
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
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:complexType>
<xs:sequence>
<xs:element name="songmaxOccurs ="unbounded ">
<xs:complexType>
<xs:sequence>
<xs:element name="artist" type="xs:string " minOccurs ="0"/>
<xs:element name="year" type="xs:string" minOccurs ="0"/>
<xs:element name="comment" type="xs:string" minOccurs ="0"/>
</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
<xs:element name="song type=songType/>
<xs:element name="CD type=cdType/>
<xs:complexTypename=songType>
<xs:sequence>
</xs:sequence>
</xs:complexType>
Gli elementi song e CD sono dichiarati

facendo riferimento al loro tipo dichiarato
globalmente.
Dichiara il modello di contenuto
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
<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="year" type="xs:string" minOccurs ="0"/>
<xs:element name="comment" type="xs:string" minOccurs ="0"/>
</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: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:complexType>
<xs:sequence>
<xs:element name="song>
<xs:complexType>
</xs:complexType>
</xs:sequence>
</xs:complexType>
</xs:element>
<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>
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: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: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

Questi tipi si possono usare solo nella

dichiarazione di attributi!
XML Schema / 40

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

<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:restriction >
</xs:simpleType>
Restrizione a partire da tipo builtin o dichiarato globalmente
<xs:restriction>
</xs:simpleType>
Restrizione
applicata
direttamente a un tipo anonimo
definito inline
</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
replace
Stringa permessa. Si possono specificare pi
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)
replace
Valore permesso. Si possono specificare pi
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: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>
</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>
</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: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: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:restriction>
<xs:simpleType>
<xs:list itemType="xs:integer"/>
</xs:simpleType>
</xs:restriction >
</xs:simpleType>
Definizione con nidificazione di tipo

1 (restrizione su tipo lista anonimo)
<xs:restriction>
<xs:simpleType>
<xs:list>
<xs:simpleType>
<xs:restriction base="xs:integer">
</xs:restriction >
</xs:simpleType>
</xs:list>
</xs:simpleType>
</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=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: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
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
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
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
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
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:sequence>
</xs:complexType>
Questo tipo complesso definisce un

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

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
<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:sequence>
</xs: choice >
</xs:complexType>

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

un
Un elemento nome, un elemento

cognome e un numero di telefono
opzionale, in qualsiasi ordine.
XML Schema / 69
23

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

<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 >
<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

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

<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

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

<xs:complexTypename=tracklist" >
<xs:choice>
</xs:sequence>
</xs: choice >
</xs:complexType>
<xs:complexTypename=twotracklist" >
<xs:complexContent >
<xs:restriction base=tracklist ">
<xs:sequence maxOccurs =2">
</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

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

<xs:choice>
</xs:sequence>
</xs: choice >
</xs:complexType>
<xs:complexTypename=trackandtitlelist" >
<xs:extension base=tracklist">
<xs:element ref=title"/>
</xs:sequence>
</xs:restriction >
</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:sequence>
<xs:choice>
</xs:sequence>
</xs: choice >
<xs:element ref=title"/>
</xs:sequence>
</xs:sequence>
</xs:complexType>
XML Schema / 79
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
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
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
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
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:extension base="TPubblicazione">
<xs:sequence>
<xs:element ref="ISBN"/>
</xs:sequence>
</xs:extension>
</xs:complexType>
<xs:complexTypename="TRivista">
<xs:extension base="TPubblicazione">
<xs:sequence>
<xs:element ref="Volume"/>
</xs:sequence>
</xs:extension>
</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:complexType>
<xs:sequence>
<!ELEMENT song
>
<xs:element ref="comment" minOccurs ="0"/> <!ATTLIST song
track NMTOKEN #required
</xs:sequence>
>
<xs:attribute name="track "
type="xs:positiveInteger" use="required "/>
</xs:complexType>
</xs:element>
<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: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

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

<xsd:attribute name=genre">
<xsd:simpleType>
<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: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

<xsd:attribute name=genre" use="optional">
<xsd:simpleType>
...
</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
(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

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

<xs:complexTypename=dwid">
<xs:simpleContent>
<xs:extension base="xs:double">
</xs:extension>
</xs:simpleContent>
</xs:complexType>
<xs:complexTypename=songType">
<xs:sequence>
...
</xs:sequence>
<xsd:attributeGroup ref=songAttributes"/>
</xs:complexType>
<xs:complexTypename=swid">
<xs:extension base=type1 ">
</xs:extension>
</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>

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>

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="Citta"/>
</xs:all>
</xs:complexType>
<xs:element name=Indirizzo type=indType >

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:complexType>
</xs:element>

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:sequence>
</xs:group >
<xs:complexType>
<xs:sequence>
<xs:group ref="common"/>
<xs:element ref="comment"/>
</xs:sequence>
</xs:complexType>
</xs:element>
<xs:complexType>
<xs:sequence>
<xs:sequence>
<xs:element ref="artist"/>
</xs:sequence>
<xs:element ref="comment"/>
</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:sequence>
<xs:group ref="flow" minOccurs ="0
maxOccurs ="unbounded "/>
</xs:sequence>
</xs:complexType>
</xs:element>
<xs:element name=H1 ">
<xs:sequence>
</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
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
<xs:attributeGroup name="commonAttrs">
<xs:attribute name="class" type="xs:string"/>
<xs:attribute name="style" type="xs:string "/>
</xs:attributeGroup >
<xs:element name="P">
<xs:sequence>
</xs:sequence>
<xs:attributeGroup ref="commonAttrs "/>
<xs:attribute name="align ">
<xs:simpleType>
<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="Citt"/>
</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
<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
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
<xs:schema targetNamespace="APersona" xmlns="APersona"
xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:complexType>
<xs:sequence>
</xs:sequence>
<xs:anyAttribute/>
</xs:complexType>
</xs:element>
<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

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

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:annotation>
<xs:documentation>
Annotazione inserita prima dellelemento globale
Titolo della canzone
</xs:documentation>
</xs:annotation>
<xs:element name=title" type="xs:string"/>
<xs:annotation>
<xs:documentation> Annotazione inserita dopo un tag di apertura
Una sequenza
</xs:documentation>
</xs:annotation>
<xs:complexType>
<xs:sequence>
</xs:sequence>
</xs:complexType>
</xs:element>
XML Schema / 127
Creare Documenti con pi di uno Schema

<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.
definiscono elementi senza namespace.
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 >
xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns="APersona" >
<xs:include schemaLocation="Persona-titolo.xsd"/>
<xs:complexType>
<xs:sequence>
<xs:element ref=Titolo"/>
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:include schemaLocation="Persona-titolo.xsd"/>
<xs:complexType>
Il secondo schema importa il primo, che
<xs:sequence>
definisce elementi senza namespace.
In questo caso, gli elementi importati
vengono inseriti nel namespace del
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:pattern value="\+\d{1,4}(-\d{1,4})?-\d{1,4}-\d+"/>
</xs:restriction >
</xs:simpleType>
<xs:import namespace=ATelefono " schemaLocation =Telefono .xsd"/>
<xs:complexType>
Il secondo schema importa il namespace
<xs:sequence>
del primo.
Il secondo schema usa un tipo definito nel
namespace importato per dichiarare un
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

All2 9-3-2004

Caricato da

Informazioni sul documento

Titolo originale

Copyright

Formati disponibili

Condividi questo documento

Condividi o incorpora il documento

Opzioni di condivisione

Hai trovato utile questo documento?

Questo contenuto è inappropriato?

Copyright:

Formati disponibili

All2 9-3-2004

Caricato da

Copyright:

Formati disponibili

Schemi XML

Gli Schemi XML sono nati con lo stesso

Specificare la struttura dei documenti.

Specificare il tipo dei dati utilizzabili allinterno

Modelli di contenuto, elementi radice,

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

Perch gli Schemi?

I DTD usano una sintassi non XML.

Perch costringere gli sviluppatori ad imparare le

I DTD hanno pochi tipi di dato.

Il controllo sui domini dei dati parte integrante

Vantaggi degli Schemi

Cosa Forniscono gli Schemi

Un modello per i dati.

Descrivono cio organizzazione e tipi per

Lo schema contiene molte informazioni valide

Cosa si pu ottenere dagli Schemi?

Oltre che per validare i documenti istanza, si

Creazione automatica di interfacce per la

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

Gli elementi blu fanno parte della sintassi DTD.

Si dichiarano elementi e attributi, cio

Gli elementi della sintassi

La dichiarazione del default

Richiamare lo schema in un documento

Indichiamo al parser che tutti gli

Creare e Usare un Namespace

Usa gli elementi del namespace

Definisce gli elementi del namespace

Uno schema definisce un vocabolario

Schemi senza Namespace

Nei documenti istanza, per indicare uno schema

Schemi senza Namespace

Gli elementi della sintassi XML

Documenti senza Namespace

Dichiarazioni Globali e Locali

La dichiarazione che usa elementi locali

Gli elementi song e CD sono dichiarati

Un approccio misto, che usa elementi nidificati

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

Riferimento a tipo globale

Dichiarazione locale di elementi

Riferimento ad elemento dichiarato

Dichiarazione dellelemento CD. Linterno

Dichiarazione degli elementi song e length.

Per lelemento song, il tipo globale

Per lelemento length, il tipo dichiarato

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

La dichiarazione dellelemento globale

Il Tipo degli Elementi

Il Tipo degli Elementi

Gli schemi definiscono due generi di tipo.

Tipo semplice, o simpleType.

Quali sono le differenze tra i due?

Un simpleType un tipo di dato ottenuto da

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

Tipi di dato Built-in

Tipi di dato Built-in (derivati)

Una stringa senza \t, \n, \r

Tipi di dato ereditati dai DTD

Come definito nei DTD

Questi tipi si possono usare solo nella

Creazione di Tipi Semplici