XML Schema

In this lecture
• XML Schemas
• Elements v. Types
• Regular expressions
• Expressive power
Resources
W3C Draft: www.w3.org/TR/2001/REC-xmlschema-1-20010502
 XML Schemas
• http://www.w3.org/TR/xmlschema-1/10/2000
• generalizes DTDs
• uses XML syntax
• two documents: structure and datatypes
– http://www.w3.org/TR/xmlschema-1
– http://www.w3.org/TR/xmlschema-2
• XML-Schema is very complex
– often criticized
– some alternative proposals
 XML Schemas
<xsd:element
<xsd:elementname=“paper”
name=“paper”type=“papertype”/>
type=“papertype”/>
<xsd:complexType
<xsd:complexTypename=“papertype”>
name=“papertype”>
<xsd:sequence>
<xsd:sequence>
<xsd:element
<xsd:elementname=“title”
name=“title”type=“xsd:string”/>
type=“xsd:string”/>
<xsd:element
<xsd:elementname=“author”
name=“author”minOccurs=“0”/>
minOccurs=“0”/>
<xsd:element
<xsd:elementname=“year”/>
name=“year”/>
<xsd:
<xsd:choice>
choice><<xsd:element
xsd:elementname=“journal”/>
name=“journal”/>
<xsd:element
<xsd:elementname=“conference”/>
name=“conference”/>
</xsd:choice>
</xsd:choice>
</xsd:sequence>
</xsd:sequence>
</xsd:element>
</xsd:element>

DTD: <!ELEMENT paper (title,author*,year, (journal|conference))>

 Elements v.s. Types in
XML Schema

<xsd:element
<xsd:elementname=“person”> <xsd:element
name=“person”> <xsd:elementname=“person”
name=“person”
<xsd:complexType>
<xsd:complexType> type=“ttt”>
type=“ttt”>
<xsd:sequence> <xsd:complexType
<xsd:sequence> <xsd:complexTypename=“ttt”>
name=“ttt”>
<xsd:element
<xsd:elementname=“name”
name=“name” <xsd:sequence>
<xsd:sequence>
type=“xsd:string”/> <xsd:element
type=“xsd:string”/> <xsd:elementname=“name”
name=“name”
<xsd:element name=“address”
<xsd:element name=“address” type=“xsd:string”/>
type=“xsd:string”/>
type=“xsd:string”/>
type=“xsd:string”/> <xsd:element name=“address”
<xsd:element name=“address”
</xsd:sequence>
</xsd:sequence> type=“xsd:string”/>
type=“xsd:string”/>
</xsd:complexType>
</xsd:complexType> </xsd:sequence>
</xsd:sequence>
</xsd:element>
</xsd:element> </xsd:complexType>
</xsd:complexType>

DTD: <!ELEMENT person (name,address)>

 Elements v.s. Types in
XML Schema
• Types:
– Simple types (integers, strings, ...)
– Complex types (regular expressions, like in DTDs)
• Element-type-element alternation:
– Root element has a complex type
– That type is a regular expression of elements
– Those elements have their complex types...
– ...
– On the leaves we have simple types
 Local and Global Types in
XML Schema
• Local type:
<xsd:element name=“person”>
[define locally the person’s type]
</xsd:element>
• Global type:
<xsd:element name=“person” type=“ttt”/>

<xsd:complexType name=“ttt”>
[define here the type ttt]
</xsd:complexType>
Global types: can be reused in other elements
 Local v.s. Global Elements in
XML Schema
• Local element:
<xsd:complexType name=“ttt”>
<xsd:sequence>
<xsd:element name=“address” type=“...”/>...
</xsd:sequence>
</xsd:complexType>
• Global element:
<xsd:element name=“address” type=“...”/>

<xsd:complexType name=“ttt”>
<xsd:sequence>
<xsd:element ref=“address”/> ...
</xsd:sequence>
</xsd:complexType>

Global elements: like in DTDs

 Regular Expressions in
XML Schema
Recall the element-type-element alternation:
<xsd:complexType name=“....”>
[regular expression on elements]
</xsd:complexType>
Regular expressions:
• <xsd:sequence> A B C </...> =ABC
• <xsd:choice> A B C </...> =A|B|C
• <xsd:group> A B C </...> = (A B C)
• <xsd:... minOccurs=“0” maxOccurs=“unbounded”> ..</...> = (...)*
• <xsd:... minOccurs=“0” maxOccurs=“1”> ..</...> = (...)?
 Local Names in XML-Schema
<xsd:element
<xsd:elementname=“person”>
name=“person”>
<xsd:complexType>
<xsd:complexType>
name has ..........
<xsd:element
<xsd:elementname=“name”>
name=“name”>
different meanings <xsd:complexType>
<xsd:complexType>
<xsd:sequence>
in person and <xsd:sequence>
<xsd:element
<xsd:elementname=“firstname”
name=“firstname”type=“xsd:string”/>
type=“xsd:string”/>
in product <xsd:element name=“lastname” type=“xsd:string”/>
<xsd:element name=“lastname” type=“xsd:string”/>
</xsd:sequence>
</xsd:sequence>
</xsd:element>
</xsd:element>
.. ......
</xsd:complexType>
</xsd:complexType>
</xsd:element>
</xsd:element>

<xsd:element
<xsd:elementname=“product”>
name=“product”>
<xsd:complexType>
<xsd:complexType>
..........
<xsd:element
<xsd:elementname=“name”
name=“name” type=“xsd:string”/>
type=“xsd:string”/>
</xsd:complexType>
</xsd:complexType>
</xsd:element>
</xsd:element>
 Subtle Use of Local Names
<xsd:element
<xsd:elementname=“A”
name=“A”type=“oneB”/>
type=“oneB”/> <xsd:complexType
<xsd:complexTypename=“oneB”>
name=“oneB”>
<xsd:choice>
<xsd:choice>
<xsd:element
<xsd:elementname=“B”
name=“B”type=“xsd:string”/>
type=“xsd:string”/>
<xsd:complexType <xsd:sequence>
<xsd:complexTypename=“onlyAs”>
name=“onlyAs”> <xsd:sequence>
<xsd:element
<xsd:choice>
<xsd:choice> <xsd:elementname=“A”
name=“A”type=“onlyAs”/>
type=“onlyAs”/>
<xsd:sequence> <xsd:element name=“A” type=“oneB”/>
<xsd:element name=“A” type=“oneB”/>
<xsd:sequence> </xsd:sequence>
<xsd:element
<xsd:elementname=“A”
name=“A”type=“onlyAs”/>
type=“onlyAs”/> </xsd:sequence>
<xsd:element name=“A” type=“onlyAs”/> <xsd:sequence>
<xsd:sequence>
<xsd:element name=“A” type=“onlyAs”/> <xsd:element
</xsd:sequence>
</xsd:sequence> <xsd:elementname=“A”
name=“A”type=“oneB”/>
type=“oneB”/>
<xsd:element <xsd:element name=“A” type=“onlyAs”/>
<xsd:elementname=“A”
name=“A”type=“xsd:string”/>
type=“xsd:string”/> <xsd:element name=“A” type=“onlyAs”/>
</xsd:sequence>
</xsd:choice>
</xsd:choice> </xsd:sequence>
</xsd:complexType> </xsd:choice>
</xsd:choice>
</xsd:complexType> </xsd:complexType>
</xsd:complexType>

Arbitrary deep binary tree with A elements, and a single B element

 Attributes in XML Schema
<xsd:element
<xsd:elementname=“paper”name=“paper”type=“papertype”/>
type=“papertype”/>
<xsd:complexType
<xsd:complexTypename=“papertype”>
name=“papertype”>
<xsd:sequence>
<xsd:sequence>
<xsd:element
<xsd:elementname=“title”
name=“title”type=“xsd:string”/>
type=“xsd:string”/>
. .. .. .. .. .. .
</xsd:sequence>
</xsd:sequence>
<xsd:attribute
<xsd:attributename=“language"
name=“language"type="xsd:NMTOKEN"
type="xsd:NMTOKEN"fixed=“English"/>
fixed=“English"/>
</xsd:complexType>
</xsd:complexType>

Attributes are associated to the type, not to the element

Only to complex types; more trouble if we want to add attributes
to simple types.
 “Mixed” Content, “Any” Type
<xsd:complexType
<xsd:complexTypemixed="true">
mixed="true">
.. .. .. ..
• Better than in DTDs: can still enforce the type, but now
may have text between any elements

<xsd:element
<xsd:elementname="anything"
name="anything"type="xsd:anyType"/>
type="xsd:anyType"/>
........
• Means anything is permitted there
 “All” Group
<xsd:complexType
<xsd:complexTypename="PurchaseOrderType">
name="PurchaseOrderType">
<xsd:all>
<xsd:all> <xsd:element
<xsd:elementname="shipTo"
name="shipTo"type="USAddress"/>
type="USAddress"/>
<xsd:element
<xsd:elementname="billTo"
name="billTo"type="USAddress"/>
type="USAddress"/>
<xsd:element
<xsd:elementref="comment"
ref="comment"minOccurs="0"/>
minOccurs="0"/>
<xsd:element
<xsd:elementname="items"
name="items" type="Items"/>
type="Items"/>
</xsd:all>
</xsd:all>
<xsd:attribute
<xsd:attributename="orderDate"
name="orderDate"type="xsd:date"/>
type="xsd:date"/>
</xsd:complexType>
</xsd:complexType>
• A restricted form of & in SGML
• Restrictions:
– Only at top level
– Has only elements
– Each element occurs at most once
• E.g. “comment” occurs 0 or 1 times
 Derived Types by Extensions
<complexType
<complexTypename="Address">
name="Address">
<sequence>
<sequence> <element
<elementname="street"
name="street"type="string"/>
type="string"/>
<element
<elementname="city"
name="city" type="string"/>
type="string"/>
</sequence>
</sequence>
</complexType>
</complexType>

<complexType
<complexTypename="USAddress">
name="USAddress">
<complexContent>
<complexContent>
<extension
<extensionbase="ipo:Address">
base="ipo:Address">
<sequence>
<sequence> <element
<elementname="state"
name="state"type="ipo:USState"/>
type="ipo:USState"/>
<element
<elementname="zip"
name="zip" type="positiveInteger"/>
type="positiveInteger"/>
</sequence>
</sequence>
</extension>
</extension>
</complexContent>
</complexContent>
</complexType>
</complexType>

Corresponds to inheritance
 Derived Types by Restrictions

<complexContent>
<complexContent>
<restriction
<restrictionbase="ipo:Items“>
base="ipo:Items“>
……[rewrite
[rewritethe
theentire
entirecontent,
content,with
withrestrictions]...
restrictions]...
</restriction>
</restriction>
</complexContent>
</complexContent>

• (*): may restrict cardinalities, e.g. (0,infty)

to (1,1); may restrict choices; other
restrictions…
Corresponds to set inclusion
 Simple Types
• String • Time
• Token • dateTime
• Byte • Duration
• unsignedByte • Date
• Integer • ID
• positiveInteger • IDREF
• Int (larger than integer) • IDREFS
• unsignedInt
• Long
• Short
• ...
 Facets of Simple Types
•Facets = additional properties restricting a simple type
•15 facets defined by XML Schema

Examples • maxInclusive
• length • maxExclusive
• minLength • minInclusive
• maxLength • minExclusive
• pattern • totalDigits
• enumeration • fractionDigits
• whiteSpace
 Facets of Simple Types
• Can further restrict a simple type by
changing some facets
• Restriction = subset
 Not so Simple Types
• List types:
<xsd:simpleType
<xsd:simpleTypename="listOfMyIntType">
name="listOfMyIntType">
<xsd:list
<xsd:listitemType="myInteger"/>
itemType="myInteger"/>
</xsd:simpleType>
</xsd:simpleType>

<listOfMyInt>20003 15037 95977 95945</listOfMyInt>

• Union types
• Restriction types
 Summary of XML Schema
• Formal Expressive Power:
– Can express precisely the regular tree
languages (over unranked trees)

• Lots of other stuff

– Some form of inheritance
– A “null” value
– Large collection of data types
 Summary of Schemas
• in SS data:
– graph theoretic
– data and schema are decoupled
– used in data processing
• in XML
– from grammar to object-oriented
– schema wired with the data
– emphasis on semantics for exchange