Scribd
Upload
72 views

UNIT 2C and Lab 6 XML Schema

An XML schema defines elements and attributes that can appear in an XML document. It defines properties like an element's child elements, number of children, data types, default values, and more. XML schemas have advantages over DTDs like being more powerful, extensible, written in XML, and supporting data types and namespaces. They allow sending and receiving parties to have a shared understanding of the structure and content of XML documents.

Uploaded by

tame regassa
Copyright
© © All Rights Reserved
Available Formats
Download as PPTX, PDF, TXT or read online on Scribd
72 views

UNIT 2C and Lab 6 XML Schema

An XML schema defines elements and attributes that can appear in an XML document. It defines properties like an element's child elements, number of children, data types, default values, and more. XML schemas have advantages over DTDs like being more powerful, extensible, written in XML, and supporting data types and namespaces. They allow sending and receiving parties to have a shared understanding of the structure and content of XML documents.

Uploaded by

tame regassa
Copyright
© © All Rights Reserved
Available Formats
Download as PPTX, PDF, TXT or read online on Scribd
You are on page 1/ 112

What is an XML Schema?

An XML Schema:
defines elements that can appear in a
document
defines attributes that can appear in a
document
defines which elements are child elements
defines the order of child elements
defines the number of child elements
defines whether an element is empty or can
include text
defines data types for elements and attributes
defines default and fixed values for elements
and attributes

XML Schemas are the Successors of DTDs

Very soon XML Schemas will be used in


most Web applications as a replacement
for DTDs. Here are some reasons:
XML Schemas are extensible to future
additions
XML Schemas are richer and more
powerful than DTDs
XML Schemas are written in XML
XML Schemas support data types
XML Schemas support namespaces
2

Why Use XML


Schemas?
3

XML Schemas Support Data Types


One of the greatest strength of XML
Schemas is the support for data types.
With support for data types:
It is easier to describe allowable document
content
It is easier to validate the correctness of data
It is easier to work with data from a database
It is easier to define data facets (restrictions on
data)
It is easier to define data patterns (data
formats)
It is easier to convert data between different
4
data types

XML Schemas use XML Syntax


Another great strength about XML
Schemas is that they are written in XML.
Some benefits of that XML Schemas are
written in XML:
You don't have to learn a new language
You can use your XML editor to edit your
Schema files
You can use your XML parser to parse your
Schema files
You can manipulate your Schema with the
XML DOM
You can transform your Schema with XSLT
5

XML Schemas Secure Data Communication


When sending data from a sender to a receiver, it is
essential that both parts have the same
"expectations" about the content.
With XML Schemas, the sender can describe the data
in a way that the receiver will understand.
A date like: "03-11-2004" will, in some countries, be
interpreted as 3.November and in other countries as
11.March.
However, an XML element with a data type like this:
<date type="date">2004-03-11</date>
ensures a mutual understanding of the content,
because the XML data type "date" requires the
6
format "YYYY-MM-DD".

XML Schemas are Extensible


XML Schemas are extensible, because
they are written in XML.
With an extensible Schema definition
you can:
Reuse your Schema in other Schemas
Create your own data types derived from
the standard types
Reference multiple schemas in the same
document

Well-Formed is not Enough


A well-formed XML document is a document
that conforms to the XML syntax rules, like:
it must begin with the XML declaration
it must have one unique root element
start-tags must have matching end-tags
elements are case sensitive
all elements must be closed
all elements must be properly nested
all attribute values must be quoted
entities must be used for special characters
8

XSDHowTo?
Look at this simple XML document
called "note.xml":
<?xml version="1.0"?>
<note>
<to>Tove</to>
<from>Jani</from>
<heading>Reminder</heading>
<body>Don't forget me this
weekend!</body>
</note>
9

An XML Schema
ThefollowingexampleisanXMLSchemafilecalled"note.xsd"that
definestheelementsoftheXMLdocumentabove("note.xml"):
<?xml version="1.0"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
targetNamespace="http://www.w3schools.com"
xmlns="http://www.w3schools.com"
elementFormDefault="qualified">
<xs:element name="note">
<xs:complexType>
<xs:sequence>
<xs:element name="to" type="xs:string"/>
<xs:element name="from" type="xs:string"/>
<xs:element name="heading" type="xs:string"/>
<xs:element name="body" type="xs:string"/>
</xs:sequence>
</xs:complexType>
</xs:element>
10

A Reference to an XML Schema


<?xml version="1.0"?>
<note
xmlns="http://www.w3schools.com"
xmlns:xsi="http://www.w3.org/2001/XMLSchemainstance"
xsi:schemaLocation="http://www.w3schools.com
note.xsd">
<to>Tove</to>
<from>Jani</from>
<heading>Reminder</heading>
<body>Don't forget me this weekend!</body>
</note>
11

XSD-The<schema>Element
The<schema>elementistheroot
elementofeveryXMLSchema:
< ?xm lversion= "1.0"?>

< xs:schem a>


...
...
< /xs:schem a>

12

Framgments
targ etN am esp ace=
h ttp ://w w w .w 3sch ools.com
indicatesthattheelementsdefinedbythisschema(note,to,from,
heading,body.)comefromthe"http://www.w3schools.com"
namespace.

xm ln s= "h ttp ://w w w .w 3sch ools.com "


indicatesthatthedefaultnamespaceis
"http://www.w3schools.com".

elementFormDefault="qualified
indicates that any elements used by the XML
instance document which were declared in this
schema must be namespace qualified.
13

XSDSimpleElements
A simple element is an XML element that can
contain only text. It cannot contain any other
elements or attributes.
However, the "only text" restriction is quite
misleading. The text can be of many different
types. It can be one of the types included in the
XML Schema definition (boolean, string, date,
etc.), or it can be a custom type that you can
define yourself.
You can also add restrictions (facets) to a data
type in order to limit its content, or you can
require the data to match a specific pattern. 14

Defining a Simple Element


The syntax for defining a simple element is:
<xs:element name="xxx" type="yyy"/>
where xxx is the name of the element and
yyy is the data type of the element.
XML Schema has a lot of built-in data
types. The most common types are:
xs:string
xs:decimal
xs:integer
xs:boolean
xs:date
xs:time
15

Example
Here are some XML elements:
<lastname>Refsnes</lastname>
<age>36</age>
<dateborn>1970-03-27</dateborn>
And here are the corresponding
simple element definitions:
<xs:element name="lastname"
type="xs:string"/>
<xs:element name="age"
type="xs:integer"/>
<xs:element name="dateborn"

16

Default and Fixed Values for Simple Elements


Simple elements may have a default value OR a
fixed value specified.
A default value is automatically assigned to the
element when no other value is specified.
In the following example the default value is "red":
<xs:element
name="color"
type="xs:string"
default="red"/>
A fixed value is also automatically assigned to the
element, and you cannot specify another value.
In the following example the fixed value is "red":
<xs:element
name="color"
type="xs:string"
fixed="red"/>
17

XSDAttributes
What is an Attribute?
Simple elements cannot have attributes. If an element has
attributes, it is considered to be of a complex type. But the
attribute itself is always declared as a simple type.
How to Define an Attribute?
Thesyntaxfordefininganattributeis:
< xs:attribute nam e= "xxx" type= "yyy"/>
wherexxxisthenameoftheattributeandyyyspecifiesthe
datatypeoftheattribute.
XML Schema has a lot of built-in data types. The most
commontypesare:xs:string

xs:decimal
xs:integer
xs:boolean
xs:date
xs:time

Example
Here is an XML element with an attribute:
<lastname
lang="EN">Smith</lastname>
And here is the corresponding attribute18
definition:

Default and Fixed Values for Attributes


Attributes may have a default value OR a fixed
value specified.
A default value is automatically assigned to the
attribute when no other value is specified.
In the following example the default value is "EN":
<xs:attribute
name
=
"lang"
type
=
"xs:string" default = "EN"/>
A fixed value is also automatically assigned to the
attribute, and you cannot specify another value.
In the following example the fixed value is "EN":
<xs:attribute name="lang" type="xs:string"
fixed="EN"/>
19

Optional and Required Attributes


Attributes are optional by default. To
specify that the attribute is required,
use the "use" attribute:
<xs:attribute name="lang"
type="xs:string"
use="required"/>

20

Restrictions on Content
When an XML element or attribute has a
data type defined, it puts restrictions on
the element's or attribute's content.
If an XML element is of type "xs:date" and
contains a string like "Hello World", the
element will not validate.
With XML Schemas, you can also add your
own restrictions to your XML elements and
attributes. These restrictions are called
facets.You can read more about facets in
the next chapter.
21

XSDRestrictions/Facets
Restrictions are used to define acceptable values
for XML elements or attributes. Restrictions on
XML elements are called facets.
Restrictions on Values
The following example defines an element called
"age" with a restriction. The value of age
cannot be lower than 0 or greater than 120:
<xs:element name="age">
<xs:simpleType>
<xs:restriction base="xs:integer">
<xs:minInclusive value="0"/>
<xs:maxInclusive value="120"/>
</xs:restriction>
</xs:simpleType>
22
</xs:element>

Restrictions on a Set of Values


To limit the content of an XML element to a set of
acceptable
values,
we
would
use
the
enumeration constraint.
The example below defines an element called
"car" with a restriction. The only acceptable
values are: Audi, Golf, BMW:
<xs:element name="car">
<xs:simpleType>
<xs:restriction base="xs:string">
<xs:enumeration value="Audi"/>
<xs:enumeration value="Golf"/>
<xs:enumeration value="BMW"/>
</xs:restriction>
</xs:simpleType>
23
</xs:element>

The example above could also have been written like


this:
<xs:element name="car" type="carType"/>
<xs:simpleType name="carType">
<xs:restriction base="xs:string">
<xs:enumeration value="Audi"/>
<xs:enumeration value="Golf"/>
<xs:enumeration value="BMW"/>
</xs:restriction>
</xs:simpleType>

Note:In this case the type "carType" can


be used by other elements because it is not
a part of the "car" element.
24

Restrictions on a Series of Values


To limit the content of an XML element to
define a series of numbers or letters that can
be used, we would use the pattern constraint.
The example below defines an element called
"letter" with a restriction. The only acceptable
value is ONE of the LOWERCASE letters from a
to z:
<xs:element name="letter">
<xs:simpleType>
<xs:restriction base="xs:string">
<xs:pattern value="[a-z]"/>
</xs:restriction>
</xs:simpleType>
25
</xs:element>

The next example defines an element called


"initials" with a restriction. The only acceptable
value is THREE of the UPPERCASE letters from a
toz:
< xs:elem ent nam e= "initials">
< xs:sim pleType>
< xs:restriction base= "xs:string">
< xs:pattern value= "[A-Z][A-Z][A-Z]"/>
< /xs:restriction>
< /xs:sim pleType>
< /xs:elem ent>
26

The next example also defines an element called "initials"


with a restriction. The only acceptable value is THREE of
the LOWERCASE OR UPPERCASE letters from a to z:
<xs:element name="initials">
<xs:simpleType>
<xs:restriction base="xs:string">
<xs:pattern value="[a-zA-Z][a-zA-Z][a-zA-Z]"/>
</xs:restriction>
</xs:simpleType>
</xs:element>
The next example defines an element called "choice" with
a restriction. The only acceptable value is ONE of the
following letters: x, y, OR z:
<xs:element name="choice">
<xs:simpleType>
<xs:restriction base="xs:string">
<xs:pattern value="[xyz]"/>
</xs:restriction>
</xs:simpleType>
27

The next example defines an element


called "prodid" with a restriction. The
only acceptable value is FIVE digits in a
sequence, and each digit must be in a
range from 0 to 9:
<xs:element name="prodid">
<xs:simpleType>
<xs:restriction base="xs:integer">
<xs:pattern value="[0-9][0-9][0-9]
[0-9][0-9]"/>
</xs:restriction>
</xs:simpleType>
</xs:element>
28

Other Restrictions on a Series of Values


The example below defines an element
called "letter" with a restriction. The
acceptable value is zero or more
occurrences of lowercase letters from a
to z:
<xs:element name="letter">
<xs:simpleType>
<xs:restriction base="xs:string">
<xs:pattern value="([a-z])*"/>
</xs:restriction>
</xs:simpleType>
</xs:element>
29

The next example also defines an element


called "letter" with a restriction. The
acceptable value is one or more pairs of
letters, each pair consisting of a lower case
letter followed by an upper case letter. For
example, "sToP" will be validated by this
pattern, but not "Stop" or "STOP" or
"stop":
<xs:element name="letter">
<xs:simpleType>
<xs:restriction base="xs:string">
<xs:pattern value="([a-z][A-Z])+"/>
</xs:restriction>
</xs:simpleType>
30
</xs:element>

The next example defines an element


called "gender" with a restriction. The
only acceptable value is male OR
female:
<xs:element name="gender">
<xs:simpleType>
<xs:restriction base="xs:string">
<xs:pattern value="male|
female"/>
</xs:restriction>
</xs:simpleType>
</xs:element>
31

The next example defines an element


called "password" with a restriction. There
must be exactly eight characters in a row
and those characters must be lowercase
or uppercase letters from a to z, or a
number from 0 to 9:
<xs:element name="password">
<xs:simpleType>
<xs:restriction base="xs:string">
<xs:pattern value="[a-zA-Z0-9]
{8}"/>
</xs:restriction>
</xs:simpleType>
</xs:element>
32

Restrictions on Whitespace Characters


To specify how whitespace characters should be
handled, we would use the whiteSpace constraint.
This example defines an element called "address"
with a restriction. The whiteSpace constraint is set
to "preserve", which means that the XML processor
WILL NOT remove any white space characters:
<xs:element name="address">
<xs:simpleType>
<xs:restriction base="xs:string">
<xs:whiteSpace value="preserve"/>
</xs:restriction>
</xs:simpleType>
</xs:element>
33

Restrictions on Length
To limit the length of a value in an
element, we would use the length,
maxLength, and minLength constraints.
This example defines an element called
"password" with a restriction. The value
must be exactly eight characters:
<xs:element name="password">
<xs:simpleType>
<xs:restriction base="xs:string">
<xs:length value="8"/>
</xs:restriction>
</xs:simpleType>
34
</xs:element>

Restrictions for Data types


Constraint

Description

enumeration

Definesalistofacceptablevalues

fractionDigits

Specifiesthemaximumnumberofdecimalplacesallowed.Mustbeequaltoor
greaterthanzero

length

Specifiestheexactnumberofcharactersorlistitemsallowed.Mustbeequal
toorgreaterthanzero

maxExclusive

Specifiestheupperboundsfornumericvalues(thevaluemustbelessthan
thisvalue)

maxInclusive

Specifiestheupperboundsfornumericvalues(thevaluemustbelessthanor
equaltothisvalue)

maxLength

Specifiesthemaximumnumberofcharactersorlistitemsallowed.Mustbe
equaltoorgreaterthanzero

minExclusive

Specifiesthelowerboundsfornumericvalues(thevaluemustbegreaterthan
thisvalue)

minInclusive

Specifiesthelowerboundsfornumericvalues(thevaluemustbegreaterthan
orequaltothisvalue)

minLength

Specifiestheminimumnumberofcharactersorlistitemsallowed.Mustbe
equaltoorgreaterthanzero

pattern

Definestheexactsequenceofcharactersthatareacceptable

totalDigits

Specifiestheexactnumberofdigitsallowed.Mustbegreaterthanzero

whiteSpace

Specifieshowwhitespace(linefeeds,tabs,spaces,andcarriagereturns)is
35
handled

XSDComplex Elements

What is a Complex Element?


A complex element is an XML element that
contains other elements and/or attributes.
There are four kinds of complex elements:
empty elements
elements that contain only other elements
elements that contain only text
elements that contain both other elements
and text
Note:Each of these elements may contain
attributes as well!
36

Examples of Complex Elements


A complex XML element, "product",
which is empty:
<product pid="1345"/>
A complex XML element, "employee",
which contains only other elements:
<employee>
<firstname>John</firstname>
<lastname>Smith</lastname>
</employee>
37

A complex XML element, "food", which


contains only text:
<food type="dessert">Ice
cream</food>
A complex XML element, "description",
which contains both elements and text:
<description>
It happened on <date lang=Afan
Oromo">03.03.99</date> ....
</description>
38

We can define a complex element in an XML Schema two


different ways:
1. The "employee" element can be declared directly
by naming the element, like this:
<xs:element name="employee">
<xs:complexType>
<xs:sequence>
<xs:element name="firstname" type="xs:string"/>
<xs:element name="lastname" type="xs:string"/>
</xs:sequence>
</xs:complexType>
</xs:element>
If you use the method described above, only the
"employee" element can use the specified complex type.
Note that the child elements, "firstname" and "lastname",
are surrounded by the <sequence> indicator. This means
that the child elements must appear in the same order as
39
they are declared.

2. The "employee" element can have a type attribute that


refers to the name of the complex type to use:
<xs:element name="employee" type="personinfo"/>
<xs:complexType name="personinfo">
<xs:sequence>
<xs:element name="firstname" type="xs:string"/>
<xs:element name="lastname" type="xs:string"/>
</xs:sequence>
</xs:complexType>
If you use the method described above, several elements can refer
to the same complex type, like this:
<xs:element name="employee" type="personinfo"/>
<xs:element name="student" type="personinfo"/>
<xs:element name="member" type="personinfo"/>
<xs:complexType name="personinfo">
<xs:sequence>
<xs:element name="firstname" type="xs:string"/>
<xs:element name="lastname" type="xs:string"/>
</xs:sequence>

40

You can also base a complex element on an


existing complex element and add some
elements, like this:
<xs:element name="employee" type="fullpersoninfo"/>
<xs:complexType name="personinfo">
<xs:sequence>
<xs:element name="firstname" type="xs:string"/>
<xs:element name="lastname" type="xs:string"/>
</xs:sequence>
</xs:complexType>
<xs:complexType name="fullpersoninfo">
<xs:complexContent>
<xs:extension base="personinfo">
<xs:sequence>
<xs:element name="address" type="xs:string"/>
<xs:element name="city" type="xs:string"/>
<xs:element name="country" type="xs:string"/>
</xs:sequence>
</xs:extension>
</xs:complexContent>
</xs:complexType>

41

XSDEmptyElements
Complex Empty Elements
An empty XML element:
<product prodid="1345" />
The "product" element above has no content at all. To
define a type with no content, we must define a type that
allows elements in its content, but we do not actually
declare any elements, like this:
<xs:element name="product">
<xs:complexType>
<xs:complexContent>
<xs:restriction base="xs:integer">
<xs:attribute name="prodid"
type="xs:positiveInteger"/>
</xs:restriction>
</xs:complexContent>
</xs:complexType>
42
</xs:element>

In the example above, we define a complex type with a


complex content. The complexContent element signals that we
intend to restrict or extend the content model of a complex
type, and the restriction of integer declares one attribute but
does not introduce any element content.
However, it is possible to declare the "product" element more
compactly, like this:
<xs:element name="product">
<xs:complexType>
<xs:attribute name="prodid" type="xs:positiveInteger"/>
</xs:complexType>
</xs:element>
Or you can give the complexType element a name, and let the
"product" element have a type attribute that refers to the
name of the complexType (if you use this method, several
elements can refer to the same complex type):
<xs:element name="product" type="prodtype"/>
<xs:complexType name="prodtype">
<xs:attribute name="prodid" type="xs:positiveInteger"/>
</xs:complexType>

43

XSDElementsOnly
An "elements-only" complex type contains an element that
contains only other elements.
Complex Types Containing Elements Only
An XML element, "person", that contains only other elements:
<person>
<firstname>John</firstname>
<lastname>Smith</lastname>
</person>
You can define the "person" element in a schema, like this:
<xs:element name="person">
<xs:complexType>
<xs:sequence>
<xs:element name="firstname" type="xs:string"/>
<xs:element name="lastname" type="xs:string"/>
</xs:sequence>
</xs:complexType>
</xs:element>
Notice the <xs:sequence> tag. It means that the elements defined
("firstname" and "lastname") must appear in that order inside a 44

Or you can give the complexType element a


name, and let the "person" element have a type
attribute that refers to the name of the
complexType (if you use this method, several
elements can refer to the same complex
type):
<xs:element name="person"
type="persontype"/>
<xs:complexType name="persontype">
<xs:sequence>
<xs:element name="firstname"
type="xs:string"/>
<xs:element name="lastname"
type="xs:string"/>
</xs:sequence>
</xs:complexType>

45

XSDText-OnlyElements
Complex Text-Only Elements
This type contains only simple content (text and attributes), therefore we add a simpleContent
element around the content. When using simple content, you must define an extension OR a
restriction within the simpleContent element, like this:
<xs:element name="somename">
<xs:complexType>
<xs:simpleContent>
<xs:extension base="basetype">
....
....
</xs:extension>
</xs:simpleContent>
</xs:complexType>
</xs:element>
OR
<xs:element name="somename">
<xs:complexType>
<xs:simpleContent>
<xs:restriction base="basetype">
....
....
</xs:restriction>
</xs:simpleContent>
</xs:complexType>
</xs:element>
46
Tip:Use the extension/restriction element to expand or to limit the base simple type for the element.

The following example declares a complexType, "shoesize". The


content is defined as an integer value, and the "shoesize" element
also contains an attribute named "country":
<xs:element name="shoesize">
<xs:complexType>
<xs:simpleContent>
<xs:extension base="xs:integer">
<xs:attribute name="country" type="xs:string" />
</xs:extension>
</xs:simpleContent>
</xs:complexType>
</xs:element>
We could also give the complexType element a name, and let the
"shoesize" element have a type attribute that refers to the name of
the complexType (if you use this method, several elements can refer
to the same complex type):
<xs:element name="shoesize" type="shoetype"/>
<xs:complexType name="shoetype">
<xs:simpleContent>
<xs:extension base="xs:integer">
<xs:attribute name="country" type="xs:string" />
</xs:extension>
</xs:simpleContent>

47

XSDMixedContent
A mixed complex type element can contain attributes, elements, and
text.
Complex Types with Mixed Content
An XML element, "letter", that contains both text and other elements:
<letter>
Dear Mr.<name>John Smith</name>.
Your order <orderid>1032</orderid>
will be shipped on <shipdate>2001-07-13</shipdate>.
</letter>
The following schema declares the "letter" element:
<xs:element name="letter">
<xs:complexType mixed="true">
<xs:sequence>
<xs:element name="name" type="xs:string"/>
<xs:element name="orderid" type="xs:positiveInteger"/>
<xs:element name="shipdate" type="xs:date"/>
</xs:sequence>
</xs:complexType>
</xs:element>
48

Note:To enable character data to appear between the


child-elements of "letter", the mixed attribute must be set
to "true". The <xs:sequence> tag means that the
elements defined (name, orderid and shipdate) must
appear in that order inside a "letter" element.
We could also give the complexType element a name, and
let the "letter" element have a type attribute that refers
to the name of the complexType (if you use this method,
several elements can refer to the same complex type):
<xs:element name="letter" type="lettertype"/>

<xs:complexType name="lettertype" mixed="true">


<xs:sequence>
<xs:element name="name" type="xs:string"/>
<xs:element name="orderid"
type="xs:positiveInteger"/>
<xs:element name="shipdate" type="xs:date"/>
</xs:sequence>
</xs:complexType>

49

XSDIndicators
There are seven indicators:
Order indicators:
All
Choice
Sequence

Occurrence indicators:
maxOccurs
minOccurs

Group indicators:
Group name
attributeGroup name

50

Order Indicators
Order indicators are used to define the order of the elements.
All Indicator
The <all> indicator specifies that the child elements can appear
in any order, and that each child element must occur only once:
<xs:element name="person">
<xs:complexType>
<xs:all>
<xs:element name="firstname" type="xs:string"/>
<xs:element name="lastname" type="xs:string"/>
</xs:all>
</xs:complexType>
</xs:element>
Note:When using the <all> indicator you can set the
<minOccurs> indicator to 0 or 1 and the <maxOccurs>
indicator can only be set to 1 (the <minOccurs> and
<maxOccurs> are described later).
51

Choice Indicator

The <choice> indicator specifies that either


one child element or another can occur:
<xs:element name="person">
<xs:complexType>
<xs:choice>
<xs:element name="employee"
type="employee"/>
<xs:element name="member"
type="member"/>
</xs:choice>
</xs:complexType>
</xs:element>
52

Sequence Indicator
The <sequence> indicator specifies that the
child elements must appear in a specific order:
<xs:element name="person">
<xs:complexType>
<xs:sequence>
<xs:element name="firstname"
type="xs:string"/>
<xs:element name="lastname"
type="xs:string"/>
</xs:sequence>
</xs:complexType>
</xs:element>
53

Occurrence Indicators
Occurrence indicators are used to define how often an
element can occur.
Note:For all "Order" and "Group" indicators (any, all, choice,
sequence, group name, and group reference) the default
value for maxOccurs and minOccurs is 1.
maxOccurs Indicator
The <maxOccurs> indicator specifies the maximum number
of times an element can occur:
<xs:element name="person">
<xs:complexType>
<xs:sequence>
<xs:element name="full_name" type="xs:string"/>
<xs:element name="child_name" type="xs:string"
maxOccurs="10"/>
</xs:sequence>
</xs:complexType>
</xs:element>
54

The example above indicates that the "child_name"


element can occur a minimum of one time (the
default value for minOccurs is 1) and a maximum of
ten times in the "person" element.
minOccurs Indicator
The <minOccurs> indicator specifies the minimum
number of times an element can occur:
<xs:element name="person">
<xs:complexType>
<xs:sequence>
<xs:element name="full_name"
type="xs:string"/>
<xs:element name="child_name"
type="xs:string"
maxOccurs="10" minOccurs="0"/>
</xs:sequence>
</xs:complexType>
55
</xs:element>

The example above indicates that the "child_name" element can occur a
minimum of zero times and a maximum of ten times in the "person" element.
Tip:To allow an element to appear an unlimited number of times, use the
maxOccurs="unbounded" statement:
A working example:
An XML file called "Myfamily.xml":
<?xml version="1.0" encoding="UTF-8"?>
<persons xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:noNamespaceSchemaLocation="family.xsd">
<person>
<full_name>Hege Refsnes</full_name>
<child_name>Cecilie</child_name>
</person>
<person>
<full_name>Tove Refsnes</full_name>
<child_name>Hege</child_name>
<child_name>Stale</child_name>
<child_name>Jim</child_name>
<child_name>Borge</child_name>
</person>

<person>
<full_name>Stale Refsnes</full_name>
</person>

56

The XML file above contains a root element named "persons". Inside this root
element we have defined three "person" elements. Each "person" element must
contain a "full_name" element and it can contain up to five "child_name"
elements.
Here is the schema file "family.xsd":
<?xml version="1.0" encoding="UTF-8"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
elementFormDefault="qualified">
<xs:element name="persons">
<xs:complexType>
<xs:sequence>
<xs:element name="person" maxOccurs="unbounded">
<xs:complexType>
<xs:sequence>
<xs:element name="full_name" type="xs:string"/>
<xs:element name="child_name" type="xs:string"
minOccurs="0" maxOccurs="5"/>
</xs:sequence>
</xs:complexType>
</xs:element>
</xs:sequence>
</xs:complexType>
</xs:element>

57

Group Indicators
Group indicators are used to define related sets of elements.
Element Groups
Element groups are defined with the group declaration, like
this:
<xs:group name="groupname">
...
</xs:group>
You must define an all, choice, or sequence element inside
the group declaration. The following example defines a
group named "persongroup", that defines a group of
elements that must occur in an exact sequence:
<xs:group name="persongroup">
<xs:sequence>
<xs:element name="firstname" type="xs:string"/>
<xs:element name="lastname" type="xs:string"/>
<xs:element name="birthday" type="xs:date"/>
58
</xs:sequence>

After you have defined a group, you can reference it


in another definition, like this:
<xs:group name="persongroup">
<xs:sequence>
<xs:element name="firstname" type="xs:string"/>
<xs:element name="lastname" type="xs:string"/>
<xs:element name="birthday" type="xs:date"/>
</xs:sequence>
</xs:group>
<xs:element name="person" type="personinfo"/>
<xs:complexType name="personinfo">
<xs:sequence>
<xs:group ref="persongroup"/>
<xs:element name="country" type="xs:string"/>
</xs:sequence>
</xs:complexType>

59

Attribute Groups
Attribute groups are defined with the
attributeGroup declaration, like this:
<xs:attributeGroup name="groupname">
...
</xs:attributeGroup>
The following example defines an attribute group
named "personattrgroup":
<xs:attributeGroup name="personattrgroup">
<xs:attribute name="firstname"
type="xs:string"/>
<xs:attribute name="lastname"
type="xs:string"/>
<xs:attribute name="birthday" type="xs:date"/>
</xs:attributeGroup>
60

After you have defined an attribute group, you


can reference it in another definition, like this:
<xs:attributeGroup name="personattrgroup">
<xs:attribute name="firstname"
type="xs:string"/>
<xs:attribute name="lastname"
type="xs:string"/>
<xs:attribute name="birthday"
type="xs:date"/>
</xs:attributeGroup>
<xs:element name="person">
<xs:complexType>
<xs:attributeGroup ref="personattrgroup"/>
</xs:complexType>
</xs:element>
61

XSDThe<any>Element
The <any> element enables us to extend the XML
document with elements not specified by the schema.
The following example is a fragment from an XML
schema called "family.xsd". It shows a declaration for
the "person" element. By using the <any> element we
can extend (after <lastname>) the content of "person"
with any element:
<xs:element name="person">
<xs:complexType>
<xs:sequence>
<xs:element name="firstname" type="xs:string"/>
<xs:element name="lastname" type="xs:string"/>
<xs:any minOccurs="0"/>
</xs:sequence>
</xs:complexType>
62
</xs:element>

Now we want to extend the "person" element with a


"children" element. In this case we can do so, even if the
author of the schema above never declared any "children"
element.
Look at this schema file, called "children.xsd":
<?xml version="1.0" encoding="UTF-8"?>
<xs:schema
xmlns:xs="http://www.w3.org/2001/XMLSchema"
targetNamespace="http://www.w3schools.com"
xmlns="http://www.w3schools.com"
elementFormDefault="qualified">
<xs:element name="children">
<xs:complexType>
<xs:sequence>
<xs:element name="childname" type="xs:string"
maxOccurs="unbounded"/>
</xs:sequence>
</xs:complexType>
</xs:element>

63

The XML file below (called "Myfamily.xml"), uses components


from two different schemas; "family.xsd" and "children.xsd":
<?xml version="1.0" encoding="UTF-8"?>
<persons xmlns="http://www.microsoft.com"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.microsoft.com family.xsd
http://www.w3schools.com children.xsd">
<person>
<firstname>Hege</firstname>
<lastname>Refsnes</lastname>
<children>
<childname>Cecilie</childname>
</children>
</person>
<person>
<firstname>Stale</firstname>
<lastname>Refsnes</lastname>
</person>

64

The XML file above is valid because the


schema "family.xsd" allows us to extend
the "person" element with an optional
element after the "lastname" element.
The <any> and <anyAttribute>
elements are used to make EXTENSIBLE
documents! They allow documents to
contain additional elements that are not
declared in the main XML schema.
65

XSDThe<anyAttribute>Element
The <anyAttribute> Element
The <anyAttribute> element enables us to extend the XML
document with attributes not specified by the schema.
The following example is a fragment from an XML schema
called "family.xsd". It shows a declaration for the "person"
element. By using the <anyAttribute> element we can add
any number of attributes to the "person" element:
<xs:element name="person">
<xs:complexType>
<xs:sequence>
<xs:element name="firstname" type="xs:string"/>
<xs:element name="lastname" type="xs:string"/>
</xs:sequence>
<xs:anyAttribute/>
</xs:complexType>
</xs:element>
66

Now we want to extend the "person" element with a "gender"


attribute. In this case we can do so, even if the author of the
schema above never declared any "gender" attribute.
Look at this schema file, called "attribute.xsd":
<?xml version="1.0" encoding="UTF-8"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
targetNamespace="http://www.w3schools.com"
xmlns="http://www.w3schools.com"
elementFormDefault="qualified">
<xs:attribute name="gender">
<xs:simpleType>
<xs:restriction base="xs:string">
<xs:pattern value="male|female"/>
</xs:restriction>
</xs:simpleType>
</xs:attribute>
</xs:schema>
67

<persons xmlns="http://www.microsoft.com"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:SchemaLocation="http://www.microsoft.com family.xsd
http://www.w3schools.com attribute.xsd">
<person gender="female">
<firstname>Hege</firstname>
<lastname>Refsnes</lastname>
</person>
<person gender="male">
<firstname>Stale</firstname>
<lastname>Refsnes</lastname>
</person>
</persons>
The XML file above is valid because the schema "family.xsd"
allows us to add an attribute to the "person" element.
The <any> and <anyAttribute> elements are used to make
EXTENSIBLE documents! They allow documents to contain
additional elements that are not declared in the main XML 68

XSDElement Substitution
Let's say that we have users from two different countries:
England and Norway. We would like the ability to let the
user choose whether he or she would like to use the
Norwegian element names or the English element names
in the XML document.
To solve this problem, we could define
asubstitutionGroupin the XML schema. First, we
declare a head element and then we declare the other
elements which state that they are substitutable for the
head element.
<xs:element name="name" type="xs:string"/>
<xs:element name="navn" substitutionGroup="name"/>
In the example above, the "name" element is the head
element and the "navn" element is substitutable for
"name".
69

Look at this fragment of an XML schema:

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


<xs:element name="navn" substitutionGroup="name"/>

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

<xs:element name="customer" type="custinfo"/>


<xs:element name="kunde" substitutionGroup="customer"/>
A valid XML document (according to the schema above) could look
like this:
<customer>
<name>John Smith</name>
</customer>
or like this:
<kunde>
70
<navn>John Smith</navn>

Blocking Element Substitution


To prevent other elements from substituting with a
specified element, use the block attribute:
<xs:element name="name" type="xs:string"
block="substitution"/>
Look at this fragment of an XML schema:
<xs:element name="name" type="xs:string"
block="substitution"/>
<xs:element name="navn" substitutionGroup="name"/>
<xs:complexType name="custinfo">
<xs:sequence>
<xs:element ref="name"/>
</xs:sequence>
</xs:complexType>
<xs:element name="customer" type="custinfo"
block="substitution"/>
<xs:element name="kunde"

71

A valid XML document (according to


the schema above) looks like this:
<customer>
<name>John Smith</name>
</customer>
BUT THIS IS NO LONGER VALID:
<kunde>
<navn>John Smith</navn>
</kunde>
72

Using substitutionGroup

The type of the substitutable elements must be


the same as, or derived from, the type of the
head element. If the type of the substitutable
element is the same as the type of the head
element you will not have to specify the type of
the substitutable element.
Note that all elements in the substitutionGroup
(the head element and the substitutable
elements) must be declared as global elements,
otherwise it will not work!
What are Global Elements?
Global elements are elements that are immediate
children of the "schema" element! Local elements
are elements nested within other elements.
73

AnXSDExample
Let's have a look at this XML document called "shiporder.xml":
<?xml version="1.0" encoding="UTF-8"?>
<shiporder orderid="889923"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:noNamespaceSchemaLocation="shiporder.xsd">
<orderperson>John Smith</orderperson>
<shipto>
<name>Ola Nordmann</name>
<address>Langgt 23</address>
<city>4000 Stavanger</city>
<country>Norway</country>
</shipto>
<item>
<title>Empire Burlesque</title>
<note>Special Edition</note>
<quantity>1</quantity>
<price>10.90</price>
</item>
<item>
<title>Hide your heart</title>
<quantity>1</quantity>
<price>9.90</price>
</item>

74

The XML document above consists of a root


element, "shiporder", that contains a required
attribute called "orderid". The "shiporder"
element contains three different child elements:
"orderperson", "shipto" and "item". The "item"
element appears twice, and it contains a "title",
an optional "note" element, a "quantity", and a
"price" element.
The line above:
xmlns:xsi="http://www.w3.org/2001/XMLSchemainstance" tells the XML parser that this document
should be validated against a schema. The line:
xsi:noNamespaceSchemaLocation="shiporder.xs
d" specifies WHERE the schema resides (here it
is in the same folder as "shiporder.xml").
75

Create an XML Schema

Now we want to create a schema for the XML


document above.
We start by opening a new file that we will call
"shiporder.xsd". To create the schema we could
simply follow the structure in the XML document
and define each element as we find it. We will start
with the standard XML declaration followed by the
xs:schema element that defines a schema:
<?xml version="1.0" encoding="UTF-8" ?>
<xs:schema
xmlns:xs="http://www.w3.org/2001/XMLSchema">
...
</xs:schema>
76

In the schema above we use the standard namespace


(xs), and the URI associated with this namespace is
the Schema language definition, which has the
standard value of
http://www.w3.org/2001/XMLSchema.
Next, we have to define the "shiporder" element. This
element has an attribute and it contains other
elements, therefore we consider it as a complex type.
The child elements of the "shiporder" element is
surrounded by a xs:sequence element that defines an
ordered sequence of sub elements:
<xs:element name="shiporder">
<xs:complexType>
<xs:sequence>
...
</xs:sequence>
</xs:complexType>
</xs:element>
77

Then we have to define the "orderperson" element as a


simple type (because it does not contain any attributes
or other elements). The type (xs:string) is prefixed with
the namespace prefix associated with XML Schema that
indicates a predefined schema data type:
<xs:element name="orderperson" type="xs:string"/>
Next, we have to define two elements that are of the
complex type: "shipto" and "item". We start by defining
the "shipto" element:
<xs:element name="shipto">
<xs:complexType>
<xs:sequence>
<xs:element name="name" type="xs:string"/>
<xs:element name="address" type="xs:string"/>
<xs:element name="city" type="xs:string"/>
<xs:element name="country" type="xs:string"/>
</xs:sequence>
</xs:complexType>
78
</xs:element>

With schemas we can define the number of possible occurrences


for an element with the maxOccurs and minOccurs attributes.
maxOccurs specifies the maximum number of occurrences for an
element and minOccurs specifies the minimum number of
occurrences for an element. The default value for both
maxOccurs and minOccurs is 1!
Now we can define the "item" element. This element can appear
multiple times inside a "shiporder" element. This is specified by
setting the maxOccurs attribute of the "item" element to
"unbounded" which means that there can be as many
occurrences of the "item" element as the author wishes. Notice
that the "note" element is optional. We have specified this by
setting the minOccurs attribute to zero:
<xs:element name="item" maxOccurs="unbounded">
<xs:complexType>
<xs:sequence>
<xs:element name="title" type="xs:string"/>
<xs:element name="note" type="xs:string"
minOccurs="0"/>
<xs:element name="quantity" type="xs:positiveInteger"/>
<xs:element name="price" type="xs:decimal"/>
79
</xs:sequence>

We can now declare the attribute of


the "shiporder" element. Since this is
a required attribute we specify
use="required".
Note:The
attribute
declarations
must always come last:
<xs:attribute
name="orderid"
type="xs:string" use="required"/>
Here is the complete listing of the
schema file called "shiporder.xsd":
80

<?xml version="1.0" encoding="UTF-8" ?>


<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:element name="shiporder">
<xs:complexType>
<xs:sequence>
<xs:element name="orderperson" type="xs:string"/>
<xs:element name="shipto">
<xs:complexType>
<xs:sequence>
<xs:element name="name" type="xs:string"/>
<xs:element name="address" type="xs:string"/>
<xs:element name="city" type="xs:string"/>
<xs:element name="country" type="xs:string"/>
</xs:sequence>
</xs:complexType>
</xs:element>
<xs:element name="item" maxOccurs="unbounded">
<xs:complexType>
<xs:sequence>
<xs:element name="title" type="xs:string"/>
<xs:element name="note" type="xs:string" minOccurs="0"/>
<xs:element name="quantity" type="xs:positiveInteger"/>
<xs:element name="price" type="xs:decimal"/>
</xs:sequence>
</xs:complexType>
</xs:element>
</xs:sequence>
<xs:attribute name="orderid" type="xs:string" use="required"/>
</xs:complexType>
</xs:element>
</xs:schema>

81

Divide the Schema


The previous design method is very
simple, but can be difficult to read
and maintain when documents are
complex.
The next design method is based on
defining all elements and attributes
first, and then referring to them
using the ref attribute.

82

Here is the new design of the schema file ("shiporder.xsd"):


<?xml version="1.0" encoding="UTF-8" ?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
<!-- definition of simple elements -->
<xs:element name="orderperson" type="xs:string"/>
<xs:element name="name" type="xs:string"/>
<xs:element name="address" type="xs:string"/>
<xs:element name="city" type="xs:string"/>
<xs:element name="country" type="xs:string"/>
<xs:element name="title" type="xs:string"/>
<xs:element name="note" type="xs:string"/>
<xs:element name="quantity" type="xs:positiveInteger"/>
<xs:element name="price" type="xs:decimal"/>
<!-- definition of attributes -->
<xs:attribute name="orderid" type="xs:string"/>
<!-- definition of complex elements -->
<xs:element name="shipto">
<xs:complexType>
<xs:sequence>
<xs:element ref="name"/>
<xs:element ref="address"/>
<xs:element ref="city"/>
<xs:element ref="country"/>
</xs:sequence>
</xs:complexType>
</xs:element>
<xs:element name="item">
<xs:complexType>
<xs:sequence>
<xs:element ref="title"/>
<xs:element ref="note" minOccurs="0"/>
<xs:element ref="quantity"/>
<xs:element ref="price"/>
</xs:sequence>
</xs:complexType>
</xs:element>
<xs:element name="shiporder">
<xs:complexType>
<xs:sequence>
<xs:element ref="orderperson"/>
<xs:element ref="shipto"/>
<xs:element ref="item" maxOccurs="unbounded"/>
</xs:sequence>
<xs:attribute ref="orderid" use="required"/>
</xs:complexType>
</xs:element>

83

Using Named Types


The third design method defines
classes or types, that enables us to
reuse element definitions. This is done
by naming the simpleTypes and
complexTypes elements, and then
point to them through the type
attribute of the element.
Here is the third design of the schema
file ("shiporder.xsd"):
84

<?xml version="1.0" encoding="UTF-8" ?>


<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:simpleType name="stringtype">
<xs:restriction base="xs:string"/>
</xs:simpleType>
<xs:simpleType name="inttype">
<xs:restriction base="xs:positiveInteger"/>
</xs:simpleType>
<xs:simpleType name="dectype">
<xs:restriction base="xs:decimal"/>
</xs:simpleType>
<xs:simpleType name="orderidtype">
<xs:restriction base="xs:string">
<xs:pattern value="[0-9]{6}"/>
</xs:restriction>
</xs:simpleType>
<xs:complexType name="shiptotype">
<xs:sequence>
<xs:element name="name" type="stringtype"/>
<xs:element name="address" type="stringtype"/>
<xs:element name="city" type="stringtype"/>
<xs:element name="country" type="stringtype"/>
</xs:sequence>
</xs:complexType>
<xs:complexType name="itemtype">
<xs:sequence>
<xs:element name="title" type="stringtype"/>
<xs:element name="note" type="stringtype" minOccurs="0"/>
<xs:element name="quantity" type="inttype"/>
<xs:element name="price" type="dectype"/>
</xs:sequence>
</xs:complexType>
<xs:complexType name="shipordertype">
<xs:sequence>
<xs:element name="orderperson" type="stringtype"/>
<xs:element name="shipto" type="shiptotype"/>
<xs:element name="item" maxOccurs="unbounded" type="itemtype"/>
</xs:sequence>
<xs:attribute name="orderid" type="orderidtype" use="required"/>
</xs:complexType>
<xs:element name="shiporder" type="shipordertype"/>
</xs:schema>

85

The restriction element indicates that the datatype is


derived from a W3C XML Schema namespace
datatype. So, the following fragment means that the
value of the element or attribute must be a string
value:
<xs:restriction base="xs:string">
The restriction element is more often used to apply
restrictions to elements. Look at the following lines
from the schema above:
<xs:simpleType name="orderidtype">
<xs:restriction base="xs:string">
<xs:pattern value="[0-9]{6}"/>
</xs:restriction>
</xs:simpleType>
This indicates that the value of the element or
attribute must be a string, it must be exactly six
characters in a row, and those characters must be a
number from 0 to 9.

86

XSDStringDataTypes
StringDataType
Thestringdatatypecancontaincharacters,linefeeds,
carriagereturns,andtabcharacters.
Thefollowingisanexampleofastringdeclarationina
schema:
< xs:elem ent nam e= "custom er" type= "xs:string"/>
Anelementinyourdocumentmightlooklikethis:
< custom er> John Sm ith< /custom er>
Oritmightlooklikethis:
< custom er> John Sm ith < /custom er>
Note:TheXMLprocessorwillnotmodifythevalueifyou
87
usethestringdatatype.

NormalizedStringDataType
ThenormalizedStringdatatypeisderivedfromtheStringdatatype.
ThenormalizedStringdatatypealsocontainscharacters,butthe
XMLprocessorwillremovelinefeeds,carriagereturns,andtab
characters.
ThefollowingisanexampleofanormalizedStringdeclarationina
schema:
< xs:elem ent nam e= "custom er" type= "xs:norm alizedString"/>
Anelementinyourdocumentmightlooklikethis:
< custom er> John Sm ith< /custom er>
Oritmightlooklikethis:
< custom er> John Sm ith < /custom er>
Note:IntheexampleabovetheXMLprocessorwillreplacethe
tabswithspaces

88

TokenDataType
ThetokendatatypeisalsoderivedfromtheString
datatype.
Thetokendatatypealsocontainscharacters,butthe
XMLprocessorwillremovelinefeeds,carriagereturns,
tabs,leadingandtrailingspaces,andmultiplespaces.
Thefollowingisanexampleofatokendeclarationina
schema:
< xs:elem ent nam e= "custom er" type= "xs:token"/>
Anelementinyourdocumentmightlooklikethis:
< custom er> John Sm ith< /custom er>
Oritmightlooklikethis:
< custom er> John Sm ith < /custom er>
Note:IntheexampleabovetheXMLprocessorwill
removethetabs.

89

String Data Types


Note that all of the data types below
derive from the String data type
(except for string itself)!
Name

Description

ENTITIES

ENTITY

ID

AstringthatrepresentstheIDattributeinXML(onlyusedwithschemaattributes)

IDREF

AstringthatrepresentstheIDREFattributeinXML(onlyusedwithschemaattributes)

IDREFS

language

Astringthatcontainsavalidlanguageid

Name

AstringthatcontainsavalidXMLname

NCName

NMTOKEN

AstringthatrepresentstheNMTOKENattributeinXML(onlyusedwithschemaattributes)

NMTOKENS

normalizedString

Astringthatdoesnotcontainlinefeeds,carriagereturns,ortabs

QName

string

Astring

token

Astringthatdoesnotcontainlinefeeds,carriagereturns,tabs,leadingortrailingspaces,or
90
multiplespaces

Restrictions on String Data Types


Restrictions that can be used with
String data types:
enumeration
length
maxLength
minLength
pattern (NMTOKENS, IDREFS, and
ENTITIES cannot use this constraint)
whiteSpace
91

XSDDate and TimeData Types


Thedatedatatypeisusedtospecifyadate.
Thedateisspecifiedinthefollowingform"YYYY-MM-DD"where:
YYYYindicatestheyear
MMindicatesthemonth
DDindicatestheday
Note:Allcomponentsarerequired!
Thefollowingisanexampleofadatedeclarationinaschema:
< xs:elem ent nam e= "start" type= "xs:date"/>
Anelementinyourdocumentmightlooklikethis:
< start> 2002-09-24< /start>

TimeZones
Tospecifyatimezone,youcaneitherenteradateinUTCtimebyaddinga"Z"behind
thedate-likethis:
< start> 2002-09-24Z< /start>
oryoucanspecifyanoffsetfromtheUTCtimebyaddingapositiveornegativetime
behindthedate-likethis:
< start> 2002-09-24-06:00< /start>

or
< start> 2002-09-24+ 06:00< /start>
92

TimeDataType

Thetimedatatypeisusedtospecifya
time.
Thetimeisspecifiedinthefollowing
form"hh:mm:ss"where:
hhindicatesthehour
mmindicatestheminute
ssindicatesthesecond
Note:All components are required!

93

The following is an example of a time declaration in a


schema:

<xs:element name="start" type="xs:time"/>


An element in your document might look like this:
<start>09:00:00</start>
Or it might look like this:
<start>09:30:10.5</start>
Time Zones
To specify a time zone, you can either enter a
time in UTC time by adding a "Z" behind the
time - like this:
<start>09:30:10Z</start>
94

or you can specify an offset from the


UTC time by adding a positive or
negative time behind the time - like
this:
<start>09:30:10-06:00</start>
or
<start>09:30:10+06:00</start>
95

DateTime Data Type


The dateTime data type is used to
specify a date and a time.
The dateTime is specified in the
following form "YYYY-MM-DDThh:mm:ss"
where

YYYY indicates the year


MM indicates the month
DD indicates the day
T indicates the start of the required time section
hh indicates the hour
mm indicates the minute
ss indicates the second
96

Note:All components are required!


The following is an example of a dateTime declaration in a schema:
<xs:element name="startdate" type="xs:dateTime"/>
An element in your document might look like this:
<startdate>2002-05-30T09:00:00</startdate>
Or it might look like this:
<startdate>2002-05-30T09:30:10.5</startdate>
Time Zones
To specify a time zone, you can either enter a dateTime in UTC time by adding a "Z"
behind the time - like this:
<startdate>2002-05-30T09:30:10Z</startdate>
or you can specify an offset from the UTC time by adding a positive or negative time
behind the time - like this:
<startdate>2002-05-30T09:30:10-06:00</startdate>
or
<startdate>2002-05-30T09:30:10+06:00</startdate>
97

Duration Data Type


The duration data type is used to specify a time
interval.
The time interval is specified in the following
form "PnYnMnDTnHnMnS" where:
P indicates the period (required)
nY indicates the number of years
nM indicates the number of months
nD indicates the number of days
T indicates the start of a time section (required if you
are going to specify hours, minutes, or seconds)
nH indicates the number of hours
nM indicates the number of minutes
nS indicates the number of seconds
98

The following is an example of a duration declaration in a schema:


<xs:element name="period" type="xs:duration"/>
An element in your document might look like this:
<period>P5Y</period>
The example above indicates a period of five years.
Or it might look like this:
<period>P5Y2M10D</period>
The example above indicates a period of five years, two months,
and 10 days.
Or it might look like this:
<period>P5Y2M10DT15H</period>
The example above indicates a period of five years, two months,
10 days, and 15 hours.
Or it might look like this:
<period>PT15H</period>
The example above indicates a period of 15 hours.
Negative Duration
To specify a negative duration, enter a minus sign before the P:
<period>-P10D</period>
99
The example above indicates a period of minus 10 days.

Date and Time Data Types


Name

Description

date

Definesadatevalue

dateTime

Definesadateandtimevalue

duration

Definesatimeinterval

gDay

Definesapartofadate-theday(DD)

gMonth

Definesapartofadate-themonth(MM)

gMonthDay

Definesapartofadate-themonthandday(MM-DD)

gYear

Definesapartofadate-theyear(YYYY)

gYearMonth

Definesapartofadate-theyearandmonth(YYYYMM)

time

Definesatimevalue
100

Restrictions on Date Data Types


Restrictions that can be used with Date
data types:
enumeration
maxExclusive
maxInclusive
minExclusive
minInclusive
pattern
whiteSpace

101

XSDNumericData Types

DecimalDataType
Thedecimaldatatypeisusedtospecifyanumericvalue.
Thefollowingisanexampleofadecimaldeclarationinaschema:
< xs:elem ent nam e= "prize" type= "xs:decim al"/>
Anelementinyourdocumentmightlooklikethis:
< prize> 999.50< /prize>
Oritmightlooklikethis:
< prize> + 999.5450< /prize>
Oritmightlooklikethis:
< prize> -999.5230< /prize>
Oritmightlooklikethis:
< prize> 0< /prize>
Oritmightlooklikethis:
< prize> 14< /prize>
Note:Themaximumnumberofdecimaldigitsyoucanspecifyis18.
102

IntegerDataType
Theintegerdatatypeisusedtospecifyanumericvalue
withoutafractionalcomponent.
Thefollowingisanexampleofanintegerdeclarationina
schema:
< xs:elem ent nam e= "prize" type= "xs:integer"/>
Anelementinyourdocumentmightlooklikethis:
< prize> 999< /prize>
Oritmightlooklikethis:
< prize> + 999< /prize>
Oritmightlooklikethis:
< prize> -999< /prize>
Oritmightlooklikethis:
< prize> 0< /prize>

103

Numeric Data Types


Note that all of the data types below
derive from the Decimal data type
(except for decimal itself)!
Name

Description

byte

Asigned8-bitinteger

decimal

Adecimalvalue

int

Asigned32-bitinteger

integer

Anintegervalue

long

Asigned64-bitinteger

negativeInteger

Anintegercontainingonlynegativevalues(..,-2,-1)

nonNegativeInteger

Anintegercontainingonlynon-negativevalues(0,1,2,..)

nonPositiveInteger

Anintegercontainingonlynon-positivevalues(..,-2,-1,0)

positiveInteger

Anintegercontainingonlypositivevalues(1,2,..)

short

Asigned16-bitinteger

unsignedLong

Anunsigned64-bitinteger

unsignedInt

Anunsigned32-bitinteger

unsignedShort

Anunsigned16-bitinteger

unsignedByte

Anunsigned8-bitinteger

104

Restrictions on Numeric Data Types

Restrictions that can be used with


Numeric data types:
enumeration
fractionDigits
maxExclusive
maxInclusive
minExclusive
minInclusive
pattern
totalDigits
whiteSpace
105

XSDMiscellaneousDataTypes
BooleanDataType
Thebooleandatatypeisusedtospecifyatrueorfalse
value.
Thefollowingisanexampleofabooleandeclarationina
schema:
< xs:attribute nam e= "disabled" type= "xs:boolean"/>
Anelementinyourdocumentmightlooklikethis:
< prize disabled= "true"> 999< /prize>
Note:Legalvaluesforbooleanaretrue,false,1(which
indicatestrue),and0(whichindicatesfalse).
106

BinaryDataTypes
Binarydatatypesareusedtoexpress
binary-formatteddata.
Wehavetwobinarydatatypes:
base64Binary(Base64-encodedbinarydata)
hexBinary(hexadecimal-encodedbinary
data)

Thefollowingisanexampleofa
hexBinarydeclarationinaschema:
< xs:elem ent nam e= "blobsrc"
type= "xs:hexBinary"/>

107

AnyURIDataType
TheanyURIdatatypeisusedtospecifyaURI.
ThefollowingisanexampleofananyURI
declarationinaschema:
< xs:attribute nam e= "src" type= "xs:anyU RI"/>
Anelementinyourdocumentmightlooklikethis:
< pic
src= "http://w w w .w 3schools.com /im ages/sm iley.gif" /
>
Note:IfaURIhasspaces,replacethemwith%20.

108

Excercise:write xml schema for


the following hierarchy

109

110

Choose the valid xml for xml schema


document below

<?xmlversion="1.0"?>
<xs:schema
xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:elementname="Employee"type="EmployeeType"/>
<xs:complexTypename="EmployeeType">
<xs:sequencemaxOccurs="unbounded">
<xs:elementref="Name"/>
<xs:elementref="Department"/>
</xs:sequence>
</xs:complexType>
<xs:elementname="Name"type="xs:string"/>
<xs:elementname="Department"type="xs:string"/>
</xs:schema>
A. <Employee></Employee>
B.<Employee>
<Name>MasashiTanaka</Name>
<Name>MakikoOkamura</Name>
</Employee>
C.<Employee>
<Name>MasashiTanaka</Name>
<Name>MakikoOkamura</Name>
<Department>SalesDepartment</Department>
<Department>AccountingDepartment</Department>
</Employee>

111

Oops!!
Finished!!
Thanks to
w3schools

112

You might also like