XML Schema Tutorial

XML Schema Tutorial
Schema Tutorial
In our Schema tutorial, you will learn what an XML Schema is. You will also
learn how XML Schema will replace DTD, and how to use the XML Schema
language in your applications. Start Learning XML Schema!
Schema References
At W3Schools you will find a list of valid XML Schema Elements and Data
Types. XML Schema Elements.
Table of Contents
Introduction to XML Schemas

This introduction to the XML Schema language explains what an XML
Schema is.
XML Schema - Why?
This chapter explains why XML Schemas should be used instead of DTDs.
XML Schema How To
This chapter explains how to reference to an XML Schema.
XML Schema The <schema> Element
This chapter explains the schema element and its attributes.
XSD Simple Types
XML Schema Simple Elements
This chapter explains how to declare simple elements.
XML Schema Attributes
This chapter explains how to declare attributes.
XML Schema Restrictions/Facets
This chapter explains how to add restrictions to XML elements.
XSD Complex Types
XML Schema Complex Elements
This chapter explains XML Schema complex elements.
XML Schema Complex Empty Elements
This chapter explains XML Schema empty complex elements.
XML Schema Complex Elements Only
This chapter explains XML Schema complex elements only elements.
XML Schema Complex Text Elements
This chapter explains XML Schema complex text elements.
XML Schema Complex Elements with Mixed Content
This chapter explains XML Schema complex types with mixed content.
XML Schema Complex Elements Indicators
This chapter explains how to structuring complex elements with indicators.
XML Schema <any>
This chapter explains how to use the <any> element to extend the XML
document with elements not specified by the schema!
XML Schema <anyAttribute>
This chapter explains how to use the <anyAttribute> element to extend the
XML document with attributes not specified by the schema!
XML Schema Substitution
This chapter explains how one element can substitute another element.
XML Schema Example
Demonstrates how to write an XML Schema. You will also learn that a
schema can be written in different ways!
XSD Data Types
XML Schema String Data Types
This chapter explains XML Schema string data types.
XML Schema Date Data Types
This chapter explains XML Schema date data types.
XML Schema Numeric Data Types
This chapter explains XML Schema numeric data types.
XML Schema Miscellaneous Data Types
This chapter explains some other XML Schema miscellaneous data types.
XML Schema References
XML Schema Content Models - References

A list of valid XML Schema Elements.
Introduction to XML Schema
XML Schema is an XML based alternative to DTD.

An XML schema describes the structure of an XML document.
The XML Schema language is also referred to as XML Schema Definition (XSD).
What You Should Already Know
Before you study the XML Schema Language, you should have a basic understanding of XML and XML
Namespaces. It will also help to have some basic understanding of DTD.
If you want to study these subjects first, please visit our XML tutorial and our DTD tutorial.
What is an XML Schema?
The purpose of an XML Schema is to define the legal building blocks of an XML document, just like a DTD.
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
We think that 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 useful than DTDs
• XML Schemas are written in XML
• XML Schemas support data types
• XML Schemas support namespaces
XML Schema is a W3C Recommendation
XML Schema was originally proposed by Microsoft, but became an official W3C recommendation in May
2001.
The specification is now stable and has been reviewed by the W3C Membership.
For a full overview of W3C Activities and Status, visit our W3C tutorial.
XML Schemas - Why?
There are a number of reasons why XML Schema is better than DTD.
XML Schema has Support for Data Types
One of the greatest strength of XML Schemas is the support for data types.
With the support for data types:
It is easier to describe permissible 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 data types
XML Schemas use XML Syntax
Another great strength about XML Schemas is that they are written in XML.
Because XML Schemas are written in XML:
You don't have to learn another 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
XML Schemas Secure Data Communication

When data is sent 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 1999-03-11 might (in some countries) be interpreted as 3. November or (in some other countries)
as 11. March, but an XML element with a data type like this:
<date type="date">1999-03-11</date>
ensures a mutual understanding of the content because the XML data type date requires the format CCYY-
MM-DD.
XML Schemas are Extensible
XML Schemas are extensible, just like XML, 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 standard types
Reference multiple schemas from the same document
Well-Formed is not Enough
A well-formed XML document is a document that conforms to the XML syntax rules:
• must begin with the XML declaration

• must have one unique root element
• all start tags must match end-tags
• XML tags are case sensitive
• all elements must be closed
• all elements must be properly nested
• all attribute values must be quoted
• XML entities must be used for special characters
Even if documents are Well-Formed they can still contain errors, and those errors can have serious
consequences. Think of this situation: you order 5 gross of laser printers, instead of 5 laser printers. With XML
Schemas, most of these errors can be caught by your validating software.
XSD How To
XML documents can have a reference to a DTD or an XML Schema.
A Simple XML Document
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>
A Simple DTD
This is a simple DTD file called "note.dtd" that defines the elements of the XML document above ("note.xml"):
<!ELEMENT note (to, from, heading, body)>
<!ELEMENT to (#PCDATA)>
<!ELEMENT from (#PCDATA)>
<!ELEMENT heading (#PCDATA)>
<!ELEMENT body (#PCDATA)>
Line 1 defines the note element to have four elements: "to, from, heading, body". Line 2-5 defines the to
element to be of the type "#PCDATA", the from element to be of the type "#PCDATA", and so on...
A Simple XML Schema
This is a simple XML Schema file called "note.xsd" that defines the elements of the XML document above
("note.xml"):
<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>
</xs:schema>
The note element is said to be of a complex type because it contains other elements. The other elements (to,
from, heading, body) are said to be simple types because they do not contain other elements. You will learn
more about simple and complex types in the following chapters.
A Reference to a DTD
This XML document has a reference to a DTD:

<!DOCTYPE note SYSTEM
"http://www.w3schools.com/dtd/note.dtd">
<note>
<to>Tove</to>
<from>Jani</from>
</note>
A Reference to an XML Schema
This XML document has a reference to an XML Schema:

<note
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation=
"http://www.w3schools.com/schema/note.xsd">
<to>Tove</to>
<from>Jani</from>
</note>
XSD - The <schema> Element
The <schema> element is the root element of every XML Schema!
The <schema> Element
The <schema> element is the root element of every XML Schema:

<xs:schema>
...
...
</xs:schema>
The <schema> element may contain some attributes. A schema declaration often looks something like this:
...
...
</xs:schema>
The following fragment:
xmlns:xs="http://www.w3.org/2001/XMLSchema"
indicates that the elements and data types used in the schema (schema, element, complexType, sequence,
string, boolean, etc.) come from the "http://www.w3.org/2001/XMLSchema" namespace. It also specifies that
the elements and data types that come from the "http://www.w3.org/2001/XMLSchema" namespace should be
prefixed with xs: !!
This fragment:
indicates that the elements defined by this schema (note, to, from, heading, body.) come from the
"http://www.w3schools.com" namespace.
This fragment:
indicates that the default namespace is "http://www.w3schools.com".
This fragment:
elementFormDefault="qualified"
indicates that any elements used by the XML instance document which were declared in this schema must be
namespace qualified.
Referencing a Schema in an XML Document
This XML document has a reference to an XML Schema:

<note xmlns="http://www.w3schools.com"
xsi:schemaLocation="http://www.w3schools.com note.xsd">
<to>Tove</to>
<from>Jani</from>
</note>
The following fragment:
specifies the default namespace declaration. This declaration tells the schema-validator that all of the
elements used in this XML document come from the "http://www.w3schools.com" namespace.
This fragment:
tells the schema-validator that the schemaLocation attribute we are using is the one in the XMLSchema-
instance namespace.
This fragment:
xsi:schemaLocation="http://www.w3schools.com note.xsd"
tells the schema-validator that the "http://www.w3schools.com" namespace is defined by note.xsd.
XSD Simple Elements
XML Schemas define the elements of your XML files.

A simple element is an XML element that can contain only text. It cannot contain any
other elements or attributes.
What is a Simple Element?
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 that are 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, and you can require the data
to match a defined pattern.
How to Define 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.
Here are some XML elements:
<lastname>Refsnes</lastname>
<age>34</age>
<dateborn>1968-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" type="xs:date"/>
Common XML Schema Data Types
XML Schema has a lot of built-in data types. Here is a list of the most common types:
xs:string
xs:decimal
xs:integer
xs:boolean
xs:date
xs:time
Declare Default and Fixed Values for Simple Elements
Simple elements can have a default value OR a fixed value set.

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. You cannot specify another value. In the following
example the fixed value is "red":
<xs:element name="color" type="xs:string" fixed="red"/>
XSD Attributes
All attributes are declared as simple types.

Only complex elements can have attributes!
What is an Attribute?
Simple elements cannot have attributes. If an element has attributes, it is considered to be of complex type.
But the attribute itself is always declared as a simple type. This means that an element with attributes always
has a complex type definition.
How to Define an Attribute
The syntax for defining an attribute is:

<xs:attribute name="xxx" type="yyy"/>
where xxx is the name of the attribute and yyy is the data type of the attribute.
Here are an XML element with an attribute:
<lastname lang="EN">Smith</lastname>
And here are a corresponding simple attribute definition:
<xs:attribute name="lang" type="xs:string"/>
Common XML Schema Data Types
XML Schema has a lot of built-in data types. Here is a list of the most common types:
xs:string
xs:decimal
xs:integer
xs:boolean
xs:date
xs:time
Declare Default and Fixed Values for Attributes
Attributes can 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. You cannot specify another value. In the following
example the fixed value is "EN":
<xs:attribute name="lang" type="xs:string" fixed="EN"/>
Creating Optional and Required Attributes
All attributes are optional by default. To explicitly specify that the attribute is optional, use the "use" attribute:
<xs:attribute name="lang" type="xs:string" use="optional"/>
To make an attribute required:
<xs:attribute name="lang" type="xs:string" use="required"/>
Restrictions on Content
When an XML element or attribute has a type defined, it puts a restriction for the element's or attribute's
content. If an XML element is of type "xs:date" and contains a string like "Hello Mother", the element will not
validate.
But, there is more... with XML Schemas, you can 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.
XSD Restrictions/Facets
Restrictions are used to control acceptable values for XML elements or attributes.
Restrictions on XML elements are called facets.
Restrictions on Values
This example defines an element called "age" with a restriction. The value of age can NOT be lower than 0 or
greater than 100:
<xs:element name="age">
<xs:simpleType>
<xs:restriction base="xs:integer">
<xs:minInclusive value="0"/>
<xs:maxInclusive value="100"/>
</xs:restriction>
</xs:simpleType>
</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.
This example defines an element called "car":
<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>
</xs:element>
The "car" element is a simple type with a restriction. The acceptable values are: Audi, Golf, BMW.
The example above could also have been written like this:.
<xs:element name="car" type="carType"/>
<xs:simpleType name="carType">
<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.
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.
This example defines an element called "letter":
<xs:element name="letter">
<xs:simpleType>
<xs:pattern value="[a-z]"/>
</xs:restriction>
</xs:simpleType>
</xs:element>
The "letter" element is a simple type with a restriction. The only acceptable value is ONE of the LOWERCASE
letters from a to z.
The next example defines an element called "initials":
<xs:element name="initials">
<xs:simpleType>
<xs:pattern value="[A-Z][A-Z][A-Z]"/>
</xs:restriction>
</xs:simpleType>
</xs:element>
The "initials" element is a simple type with a restriction. The only acceptable value is THREE of the
UPPERCASE letters from a to z.
This example also defines an element called "initials":
<xs:simpleType>
<xs:pattern value="[a-zA-Z][a-zA-Z][a-zA-Z]"/>
</xs:restriction>
</xs:simpleType>
</xs:element>
The "initials" element is a simple type with a restriction. The only acceptable value is THREE of the
LOWERCASE OR UPPERCASE letters from a to z.
This example defines an element called "choice":
<xs:element name="choice">
<xs:simpleType>
<xs:pattern value="[xyz]"/>
</xs:restriction>
</xs:simpleType>
</xs:element>
The "choice" element is a simple type with a restriction. The only acceptable value is ONE of the following
letters: x, y, OR z.
The next example defines an element called "prodid":
<xs:element name="prodid">
<xs:simpleType>
<xs:pattern value="[0-9][0-9][0-9][0-9][0-9]"/>
</xs:restriction>
</xs:simpleType>
</xs:element>
The "prodid" element is a simple type 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.
Other Restrictions on a Series of Values
Some other restrictions that can be defined by the pattern constraint:

This example defines an element called "letter":
<xs:simpleType>
<xs:pattern value="([a-z])*"/>
</xs:restriction>
</xs:simpleType>
</xs:element>
The "letter" element is a simple type with a restriction. The acceptable value is zero or more occurrences of
lowercase letters from a to z.
This example also defines an element called "letter":
<xs:simpleType>
<xs:pattern value="([a-z][A-Z])+"/>
</xs:restriction>
</xs:simpleType>
</xs:element>
The "letter" element is a simple type with a restriction. The acceptable value is one or more occurrences of a
lowercase letter followed by a uppercase letter from a to z.
This example defines an element called "gender":
<xs:element name="gender">
<xs:simpleType>
<xs:pattern value="male|female"/>
</xs:restriction>
</xs:simpleType>
</xs:element>
The "gender" element is a simple type with a restriction. The only acceptable value is male OR female.
This example defines an element called "password":
<xs:element name="password">
<xs:simpleType>
<xs:pattern value="[a-zA-Z0-9]{8}"/>
</xs:restriction>
</xs:simpleType>
</xs:element>
The "password" element is a simple type 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.
Restrictions on White Space Characters
To specify how white space characters should be handled, we would use the whiteSpace constraint.
This example defines an element called "address":
<xs:element name="address">
<xs:simpleType>
<xs:whiteSpace value="preserve"/>
</xs:restriction>
</xs:simpleType>
</xs:element>
The "address" element is a simple type with a restriction. The whiteSpace constraint is set to "preserve", which
means that the XML processor WILL NOT remove any white space characters.
This example also defines an element called "address":
<xs:simpleType>
<xs:whiteSpace value="replace"/>
</xs:restriction>
</xs:simpleType>
</xs:element>
This "address" element is a simple type with a restriction. The whiteSpace constraint is set to "replace", which
means that the XML processor WILL REPLACE all white space characters (line feeds, tabs, spaces, and
carriage returns) with spaces.
This example also defines an element called "address":
<xs:simpleType>
<xs:whiteSpace value="collapse"/>
</xs:restriction>
</xs:simpleType>
</xs:element>
This "address" element is a simple type with a restriction. The whiteSpace constraint is set to "collapse", which
means that the XML processor WILL REMOVE all white space characters (line feeds, tabs, spaces, carriage
returns are replaced with spaces, leading and trailing spaces are removed, multiple spaces are reduced to a
single space).
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":
<xs:simpleType>
<xs:length value="8"/>
</xs:restriction>
</xs:simpleType>
</xs:element>
The "password" element is a simple type with a restriction. The value must be exactly eight characters.
This example defines another element called "password":
<xs:simpleType>
<xs:minLength value="5"/>
<xs:maxLength value="8"/>
</xs:restriction>
</xs:simpleType>
</xs:element>
This "password" element is a simple type with a restriction. The value must be minimum five characters and
maximum eight characters.
Restrictions for Datatypes
Constraint Description
enumeration Defines a list of acceptable values
fractionDigits Specifies the maximum number of decimal places allowed. Must be equal to or
greater than zero
length Specifies the exact number of characters or list items allowed. Must be equal to
or greater than zero
maxExclusive Specifies the upper bounds for numeric values (the value must be less than this
value)
maxInclusive Specifies the upper bounds for numeric values (the value must be less than or
equal to this value)
maxLength Specifies the maximum number of characters or list items allowed. Must be equal
to or greater than zero
minExclusive Specifies the lower bounds for numeric values (the value must be greater than
this value)
minInclusive Specifies the lower bounds for numeric values (the value must be greater than or
equal to this value)
minLength Specifies the minimum number of characters or list items allowed. Must be equal
to or greater than zero
pattern Defines the exact sequence of characters that are acceptable
totalDigits Specifies the exact number of digits allowed. Must be greater than zero
whiteSpace Specifies how white space (line feeds, tabs, spaces, and carriage returns) are
handled
XSD Complex Elements
A complex element contains other elements and/or attributes.
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!

Examples of Complex XML 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>
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="norwegian">03.03.99</date> ....
</description>
How to Define a Complex Element
Look at this complex XML element, "employee", which contains only other elements:
<employee>
</employee>
We can define a complex element in an XML Schema in 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:sequence>
</xs:complexType>
</xs:element>
If you use the method described above, only the "employee" element can use the specified complex type.
Notice 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 they are declared; "firstname" first and
"lastname" second. You will learn more about indicators in the XSD Indicators chapter.
2. The "employee" element can have a type attribute that references to the name of the complex type to use:
<xs:element name="employee" type="personinfo"/>
<xs:complexType name="personinfo">
<xs:sequence>
</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:sequence>
</xs:sequence>
</xs:complexType>
You can also base a complex type element on an existing complex type and add some elements, like this:
<xs:element name="employee" type="fullpersoninfo"/>
<xs:sequence>
</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>
XSD Complex Empty Elements
An empty complex element can contain attributes; but it cannot have any content
between the opening and closing tags.
Define Complex Types for 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 only elements in its content, but we do not actually declare any elements, like this:
<xs:element name="product">
<xs:complexType>
<xs:complexContent>
<xs:attribute name="prodid" type="xs:positiveInteger"/>
</xs:restriction>
</xs:complexType>
</xs:element>
In the example above, we define a complexType having complexContent, i.e. only elements. 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: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:complexType>
XSD Complex Type Elements Only
An "elements only" complex type contains an element that contains only other
elements.
Define Complex Types with Elements Only
An XML element, "person", that contains only other elements:

<person>
</person>
You can define the "person" element in a schema, like this:
<xs:element name="person">
<xs:complexType>
<xs:sequence>
</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 "person" element.
Or you can give the complexType element a name, and let the "person" element have a type attribute that
complex type):
<xs:element name="person" type="persontype"/>
<xs:complexType name="persontype">
<xs:sequence>
</xs:sequence>
</xs:complexType>
XSD Complex Text-Only Elements
A complex text element can contain both attributes and text.
Define 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>
Tip: Use the extension element to expand on the base simple type for the element, and use the restriction
element to limit the base simple type for the element.
Here is an example of an XML element, "shoesize", that contains text-only:
<shoesize country="france">35</shoesize>
The following example declares a complexType, "shoesize". The content is defined as an integer data type
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>
</xs:complexType>
XSD Complex Types With Mixed Content
A mixed complex type element can contain attributes, elements, and text.
Define Complex Types with Mixed Content
An XML element, "letter", that contains both other elements and text:
<letter>
Dear Mr.<name>John Smith</name>.
Your order <orderid>1032</orderid>
will be shipped on <shipdate>2001-07-13</shipdate>.
</letter>
Notice the text that appears between the elements. "name", "orderid", and "shipdate" are all children of letter.
The following schema declares the "letter" element:
<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>
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
complex type):
<xs:element name="letter" type="lettertype"/>
<xs:complexType name="lettertype" mixed="true">
<xs:sequence>
<xs:element name="orderid" type="xs:positiveInteger"/>
<xs:element name="shipdate" type="xs:date"/>
</xs:sequence>
</xs:complexType>
XSD Complex Types Indicators
We can control HOW elements are to be used in documents with indicators.
Indicators
We have seven types of indicators:

Order indicators:
• All
• Choice
• Sequence
Occurrence indicators:
• maxOccurs
• minOccurs
Group indicators:
• Group name
• attributeGroup name
Order Indicators
Order indicators are used to define how elements should occur.

All Indicator
The <all> indicator specifies by default that the child elements can appear in any order and that each child
element must occur once and only once:
<xs:complexType>
<xs:all>
</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).
Choice Indicator
The <choice> indicator specifies that either one child elements or another can occur:
<xs:complexType>
<xs:choice>
<xs:element name="employee" type="employee"/>
<xs:element name="member" type="member"/>
</xs:choice>
</xs:complexType>
</xs:element>
Sequence Indicator
The <sequence> indicator specifies that the child elements must appear in a specific order:
<xs:complexType>
<xs:sequence>
</xs:sequence>
</xs:complexType>
</xs:element>
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: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>
The example above indicates that the "child_name" element can minimum occur one time (the default value
for minOccurs is 1) and maximum occur ten times in a "person" element.
minOccurs Indicator
The <minOccurs> indicator specifies the minimum number of times an element can occur:
<xs:complexType>
<xs:sequence>
<xs:element name="child_name" type="xs:string"
maxOccurs="10" minOccurs="0"/>
</xs:sequence>
</xs:complexType>
</xs:element>
The example above indicates that the "child_name" element can minimum occur zero times and maximum
occur ten times in a "person" element.
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="ISO-8859-1"?>
<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>
</persons>
The XML file above contains a root element named "persons". Inside this root element are defined several
"person" elements. Each "person" element must contain a "full_name" child element and it can contain up to
five "child_name" child elements.
Here is the schema file "family.xsd":
<xs:element name="persons">
<xs:complexType>
<xs:sequence>
<xs:element name="person" maxOccurs="unbounded">
<xs:complexType>
<xs:sequence>
<xs:element name="child_name" type="xs:string"
minOccurs="0" maxOccurs="5"/>
</xs:sequence>
</xs:complexType>
</xs:element>
</xs:sequence>
</xs:complexType>
</xs:element>
</xs:schema>
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="birthday" type="xs:date"/>
</xs:sequence>
</xs:group>
After you have defined a group, you can reference it in another group or complex type definition, like this:
<xs:group name="persongroup">
<xs:sequence>
<xs:element name="birthday" type="xs:date"/>
</xs:sequence>
</xs:group>
<xs:element name="person" type="personinfo">
<xs:sequence>
<xs:group ref="persongroup"/>
</xs:sequence>
</xs:complexType>
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"/>
After you have defined an attribute group, you can reference it in another group or complex type 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:complexType>
<xs:attributeGroup ref="personattrgroup"/>
</xs:complexType>
</xs:element>
XSD The <any> Element
The <any> element enables us to extend the XML document with elements not
specified by the schema!
The <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:complexType>
<xs:sequence>
<xs:any minOccurs="0"/>
</xs:sequence>
</xs:complexType>
</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":
<xs:element name="children">
<xs:complexType>
<xs:sequence>
<xs:element name="childname" type="xs:string"
maxOccurs="unbounded"/>
</xs:sequence>
</xs:complexType>
</xs:element>
</xs:schema>
The XML file below (called "Myfamily.xml"), uses components from two different schemas; "family.xsd" and
"children.xsd":
<persons xmlns="http://www.microsoft.com"
xsi:SchemaLocation="http://www.microsoft.com family.xsd
http://www.w3schools.com children.xsd">
<person>
<firstname>Hege</firstname>
<children>
<childname>Cecilie</childname>
</children>
</person>
<person>
<firstname>Stale</firstname>
</person>
</persons>
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!
XSD The <anyAttribute> Element
The <anyAttribute> element enables us to extend the XML document with attributes
not specified by the schema!
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:complexType>
<xs:sequence>
</xs:sequence>
<xs:anyAttribute/>
</xs:complexType>
</xs:element>
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":
<xs:attribute name="gender">
<xs:simpleType>
<xs:pattern value="male|female"/>
</xs:restriction>
</xs:simpleType>
</xs:attribute>
</xs:schema>
The XML file below (called "Myfamily.xml"), uses components from two different schemas; "family.xsd" and
"attribute.xsd":
<persons xmlns="http://www.microsoft.com"
xsi:SchemaLocation="http://www.microsoft.com family.xsd
http://www.w3schools.com attribute.xsd">
<person gender="female">
<firstname>Hege</firstname>
</person>
<person gender="male">
<firstname>Stale</firstname>
</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 schema!
XSD Element Substitution
With XML Schemas one element can substitute another element.
Element Substitution
Let's say that we have users from two different countries: England and Norway. We would like the possibility
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 a substitutionGroup in 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="navn" substitutionGroup="name"/>
In the example above, the "name" element is the head element and the "navn" element is substitutable for
"name".
Look at this fragment of an XML schema:
<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>
<navn>John Smith</navn>
</kunde>
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:complexType name="custinfo">
<xs:sequence>
</xs:sequence>
</xs:complexType>
<xs:element name="customer" type="custinfo" block="substitution"/>
<xs:element name="kunde" substitutionGroup="customer"/>
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>
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!
An XSD Example
This chapter will demonstrate how to write an XML Schema. You will also learn that a
schema can be written in different ways.
An XML Document
Let's have a look at this XML document called "shiporder.xml":

<shiporder orderid="889923"
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>
</shiporder>
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/XMLSchema-instance" tells the XML parser that this
document should be validated against a schema. The line: xsi:noNamespaceSchemaLocation="shiporder.xsd"
specifies WHERE the schema resides (here it is in the same folder as "shiporder.xml").
Create an XML Schema
Now we are going 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="ISO-8859-1" ?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
...
...
</xs:schema>
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>
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:sequence>
</xs:complexType>
</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"/>
</xs:sequence>
</xs:complexType>
</xs:element>
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":
<xs:complexType>
<xs:sequence>
<xs:complexType>
<xs:sequence>
</xs:sequence>
</xs:complexType>
</xs:element>
<xs:element name="item" maxOccurs="unbounded">
<xs:complexType>
<xs:sequence>
<xs:element name="note" type="xs:string" minOccurs="0"/>
</xs:sequence>
</xs:complexType>
</xs:element>
</xs:sequence>
<xs:attribute name="orderid" type="xs:string" use="required"/>
</xs:complexType>
</xs:element>
</xs:schema>
Divide the Schema
The previous design method is very simple but can be very difficult to read and maintain when documents are
complex!
The next design method is based on defining all elements and attributes first, and then reference to them
using the ref attribute.
Here is the new look of the schema file ("shiporder.xsd"):

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

<xs:attribute name="orderid" type="xs:string"/>

<xs:complexType>
<xs:sequence>
<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: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>
</xs:schema>
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 new look of the schema file ("shiporder.xsd"):
<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: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>
The restriction element indicates that the datatype is derived from a W3C XML Schema namespace datatype.
So, this fragment:
means that the value of the element or attribute must be a string value.
The restriction element is more often used to apply restrictions on elements. Look at the following lines from
the schema above:
<xs:simpleType name="orderidtype">
<xs:pattern value="[0-9]{6}"/>
</xs:restriction>
</xs:simpleType>
This indicates that the value of the element or attribute must be a string and it must be exactly six characters
in a row and those characters must be a number from 0 to 9.
XSD String Data Types
String data types are used for values that contains character strings.
String Data Type
The string data type can contain characters, line feeds, carriage returns, and tab characters.
The following is an example of a string declaration in a schema:
<xs:element name="customer" type="xs:string"/>
An element in your document might look like this:
<customer>John Smith</customer>
Or it might look like this:
<customer> John Smith </customer>
Note: The XML processor will not modify the value if you use the string data type.
NormalizedString Data Type
The normalizedString data type is derived from the String data type.
The normalizedString data type also contains characters, but the XML processor will remove line feeds,
carriage returns, and tab characters.
The following is an example of a normalizedString declaration in a schema:
<xs:element name="customer" type="xs:normalizedString"/>
Note: In the example above the XML processor will replace the tabs with spaces.
Token Data Type
The token data type is also derived from the String data type.
The token data type also contains characters, but the XML processor will remove line feeds, carriage returns,
tabs, leading and trailing spaces, and multiple spaces.
The following is an example of a token declaration in a schema:
<xs:element name="customer" type="xs:token"/>
Note: In the example above the XML processor will remove the tabs.
String Data Types
Note that all of the data types below derives from the String data type (except from string itself)!
Name Description
ENTITIES
ENTITY
ID A string that represents the ID attribute in XML (only used with schema
attributes)
IDREF A string that represents the IDREF attribute in XML (only used with
schema attributes)
IDREFS
language A string that contains a valid language id
Name A string that contains a valid XML name
NCName
NMTOKEN A string that represents the NMTOKEN attribute in XML (only used with
schema attributes)
NMTOKENS
normalizedString A string that does not contain line feeds, carriage returns, or tabs
QName
string A string
token A string that does not contain line feeds, carriage returns, tabs, leading or
trailing spaces, or multiple spaces
Restrictions on String Data Types
Restrictions that can be used with String data types:
• enumeration
• length
• maxLength
• minLength
• pattern (NMTOKENS, IDREFS, and ENTITIES can NOT use this constraint)
• whiteSpace
XSD Date and Time Data Types
Date and time data types are used for values that contains date and time.
Date Data Type
The date data type is used to specify a date.

The date is specified in the following form "CCYY-MM-DD" where:
• CC indicates the century

• YY indicates the year
• MM indicates the month
• DD indicates the day
Note: All components are required!

The following is an example of a date declaration in a schema:
<xs:element name="start" type="xs:date"/>
<start>2002-09-24</start>
Time Zones
To specify a time zone, you can either enter a date in UTC time by adding a "Z" behind the date - like this:
<start>2002-09-24Z</start>
or you can specify an offset from the UTC time by adding a positive or negative time behind the date - like this:
<start>2002-09-24-06:00</start>
or
<start>2002-09-24+06:00</start>
Time Data Type
The time data type is used to specify a time.

The time is specified in the following form "hh:mm:ss" where:
• hh indicates the hour

• mm indicates the minute
• ss indicates the second

The following is an example of a time declaration in a schema:
<xs:element name="start" type="xs:time"/>
<start>09:00:00</start>
<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>
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>
DateTime Data Type
The dateTime data type is used to specify a date and a time.

The dateTime is specified in the following form "CCYY-MM-DDThh:mm.ss" where:
• CC indicates the century

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

The following is an example of a dateTime declaration in a schema:
<xs:element name="startdate" type="xs:dateTime"/>
<startdate>2002-05-30T09:00:00</startdate>
<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>
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
The following is an example of a duration declaration in a schema:

<xs:element name="period" type="xs:duration"/>
<period>P5Y</period>
The example above indicates a period of five years.
<period>P5Y2M10D</period>
The example above indicates a period of five years, two months, and 10 days.
<period>P5Y2M10DT15H</period>
The example above indicates a period of five years, two months, 10 days, and 15 hours.
<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>
The example above indicates a period of minus 10 days.
Date and Time Data Types
Name Description
date Defines a date value
dateTime Defines a date and time value
duration Defines a time interval
gDay Defines a part of a date - the day (DD)
gMonth Defines a part of a date - the month (MM)
gMonthDay Defines a part of a date - the month and day (MM-DD)
gYear Defines a part of a date - the year (CCYY)
gYearMonth Defines a part of a date - the year and month (CCYY-MM)
time Defines a time value
Restrictions on Date Data Types
Restrictions that can be used with Date data types:
• enumeration
• maxExclusive
• maxInclusive
• minExclusive
• minInclusive
• pattern
• whiteSpace
XSD Numeric Data Types
Decimal data types are used for numeric values.
Decimal Data Type
The decimal data type is used to specify a numeric value.

The following is an example of a decimal declaration in a schema:
<xs:element name="prize" type="xs:decimal"/>
<prize>999.50</prize>
<prize>+999.5450</prize>
<prize>-999.5230</prize>
<prize>0</prize>
<prize>14</prize>
Note: The maximum number of decimal digits you can specify is 18!
Integer Data Type
The integer data type is used to specify a numeric value without a fractional component.
The following is an example of an integer declaration in a schema:
<xs:element name="prize" type="xs:integer"/>
<prize>999</prize>
<prize>+999</prize>
<prize>-999</prize>
<prize>0</prize>
Numeric Data Types
Note that all of the data types below derives from the Decimal data type (except from decimal itself)!
Name Description
byte A signed 8-bit integer
decimal A decimal value
int A signed 32-bit integer
integer An integer value
long A signed 64-bit integer
negativeInteger An integer containing only negative values ( .., -2, -1.)
nonNegativeInteger An integer containing only non-negative values (0, 1, 2, ..)
nonPositiveInteger An integer containing only non-positive values (.., -2, -1, 0)
positiveInteger An integer containing only positive values (1, 2, ..)
short A signed 16-bit integer
unsignedLong An unsigned 64-bit integer
unsignedInt An unsigned 32-bit integer
unsignedShort An unsigned 16-bit integer
unsignedByte An unsigned 8-bit integer
Restrictions on Numeric Data Types
Restrictions that can be used with Numeric data types:
• enumeration
• fractionDigits
• maxExclusive
• maxInclusive
• minExclusive
• minInclusive
• pattern
• totalDigits
• whiteSpace
XSD Miscellaneous Data Types
Other miscellaneous data types are boolean, base64Binary, hexBinary, float, double,
anyURI, QName, and NOTATION.
Boolean Data Type
The boolean data type is used to specify a true or false value.

The following is an example of a boolean declaration in a schema:
<xs:attribute name="disabled" type="xs:boolean"/>
<prize disabled="true">999</prize>
Note: Legal values for boolean are true, false, 1 (which indicates true), and 0 (which indicates false).
Binary Data Types
Binary data types are used to express binary-formatted data.

We have two binary data types:
• base64Binary (Base64-encoded binary data)

• hexBinary (hexadecimal-encoded binary data)
The following is an example of a hexBinary declaration in a schema:

<xs:element name="blobsrc" type="xs:hexBinary"/>
AnyURI Data Type
The anyURI data type is used to specify a URI.

The following is an example of an anyURI declaration in a schema:
<xs:attribute name="src" type="xs:anyURI"/>
<pic src="http://www.w3schools.com/images/smiley.gif" />
Note: If a URI has spaces, replace them with %20.
Miscellaneous Data Types
Name Description
anyURI
base64Binary
boolean
double
float
hexBinary
NOTATION
QName
Restrictions on Miscellaneous Data Types
Restrictions that can be used with the other data types:
• enumeration (a Boolean data type can NOT use this constraint)

• length (a Boolean data type can NOT use this constraint)
• maxLength (a Boolean data type can NOT use this constraint)
• minLength (a Boolean data type can NOT use this constraint)
• pattern
• whiteSpace
XSD Elements Reference
XSD Elements
Element Explanation
all Specifies that the child elements can appear in any order. Each child
element can occur 0 or 1 time
annotation Specifies the top-level element for schema comments
any Enables the author to extend the XML document with elements not
specified by the schema
anyAttribute Enables the author to extend the XML document with attributes not specified by
the schema
appInfo Specifies information to be used by the application (must go inside
annotation)
attribute Defines an attribute
attributeGroup Defines an attribute group to be used in complex type definitions
choice Allows only one of the elements contained in the <choice> declaration
to be present within the containing element
complexContent Defines extensions or restrictions on a complex type that contains
mixed content or elements only
complexType Defines a complex type element
documentation Defines text comments in a schema (must go inside annotation)
element Defines an element
extension Extends an existing simpleType or complexType element
field Specifies an XPath expression that specifies the value used to define an
identity constraint
group Defines a group of elements to be used in complex type definitions
import Adds multiple schemas with different target namespace to a document
include Adds multiple schemas with the same target namespace to a document
key Specifies an attribute or element value as a key (unique, non-nullable,
and always present) within the containing element in an instance
document
keyref Specifies that an attribute or element value correspond to those of the
specified key or unique element
list Defines a simple type element as a list of values
notation Describes the format of non-XML data within an XML document
redefine Redefines simple and complex types, groups, and attribute groups from
an external schema
restriction Defines restrictions on a simpleType, simpleContent, or a
complexContent
schema Defines the root element of a schema
selector Specifies an XPath expression that selects a set of elements for an
identity constraint
sequence Specifies that the child elements must appear in a sequence. Each child
element can occur from 0 to any number of times
simpleContent Contains extensions or restrictions on a text-only complex type or on a
simple type as content and contains no elements
simpleType Defines a simple type and specifies the constraints and information
about the values of attributes or text-only elements
union Defines a simple type as a collection (union) of values from specified
simple data types
unique Defines that an element or an attribute value must be unique within the
scope
XSD Restrictions/Facets for Datatypes
Look at XSD Restrictions!

Constraint Description
enumeration Defines a list of acceptable values
fractionDigits Specifies the maximum number of decimal places allowed. Must be
equal to or greater than zero
length Specifies the exact number of characters or list items allowed. Must be
equal to or greater than zero
maxExclusive Specifies the upper bounds for numeric values (the value must be less
than this value)
maxInclusive Specifies the upper bounds for numeric values (the value must be less
than or equal to this value)
maxLength Specifies the maximum number of characters or list items allowed. Must
be equal to or greater than zero
minExclusive Specifies the lower bounds for numeric values (the value must be
greater than this value)
minInclusive Specifies the lower bounds for numeric values (the value must be
greater than or equal to this value)
minLength Specifies the minimum number of characters or list items allowed. Must
be equal to or greater than zero
pattern Defines the exact sequence of characters that are acceptable
totalDigits Specifies the exact number of digits allowed. Must be greater than zero
whiteSpace Specifies how white space (line feeds, tabs, spaces, and carriage
returns) are handled
The all Element
Definition and Usage
The all element specifies that the child elements can appear in any order and that each child element can
occur zero or one time.
Element Information
• Parent elements: group, complexType, restriction (both simpleContent and

complexContent), extension (both simpleContent and complexContent)
Syntax
<all
id=ID
maxOccurs=1
minOccurs=0|1
any attributes
>
(annotation?,element*)
</all>
(The ? sign declares that the element can occur zero or one time, and the * sign declares that the element can
occur zero or more times inside the all element)
Attribute Description
id Optional. Specifies a unique ID for the element
maxOccurs Optional. Specifies the maximum number of times the element can occur.
The value must be 1.
minOccurs Optional. Specifies the minimum number of times the element can occur.
The value can be 0 or 1. Default value is 1
any attributes Optional. Specifies any other attributes with non-schema namespace
Example 1
<xs:complexType>
<xs:all>
</xs:all>
</xs:complexType>
</xs:element>
The example above indicates that the "firstname" and the "lastname" elements can appear in any order but
both elements MUST occur once and only once!
Example 2
<xs:complexType>
<xs:all minOccurs="0">
</xs:all>
</xs:complexType>
</xs:element>
The example above indicates that the "firstname" and the "lastname" elements can appear in any order and
each element CAN appear zero or one time!
The annotation Element
The annotation element is a top level element that specifies schema comments. The comments serve as inline
documentation.
Element Information
• Parent elements: Any element
Syntax
<annotation
id=ID
any attributes
>
(appinfo|documentation)*
</annotation>
(The * sign declares that the element can occur zero or more times inside the annotation element)
Example 1
<xs:annotation>
<xs:appInfo>W3Schools Note</xs:appInfo>
<xs:documentation xml:lang="en">
This Schema defines a W3Schools note!
</xs:documentation>
</xs:annotation>
.
.
.
</xs:schema>
The any Element
The any element enables the author to extend the XML document with elements not specified by the schema.
Element Information
• Parent elements: choice, sequence
Syntax
<any
id=ID
maxOccurs=nonNegativeInteger|unbounded
minOccurs=nonNegativeInteger
namespace=namespace
processContents=lax|skip|strict
any attributes
>
(annotation?)
</any>
(The ? sign declares that the element can occur zero or one time inside the any element)
maxOccurs Optional. Specifies the maximum number of times the any element can occur
in the parent element. The value can be any number >= 0, or if you want to
set no limit on the maximum number, use the value "unbounded". Default
value is 1
minOccurs Optional. Specifies the minimum number of times the any element can occur
in the parent element. The value can be any number >= 0. Default value is 1
namespace Optional. Specifies the namespaces containing the elements that can be used.
Can be set to one of the following:
• ##any - elements from any namespace is allowed (this is default)

• ##other - elements from any namespace that is not the namespace
of the parent element can be present
• ##local - elements must come from no namespace
• ##targetNamespace - elements from the namespace of the parent
element can be present
• List of {URI references of namespaces, ##targetNamespace,
##local} - elements from a space-delimited list of the namespaces
can be present
processContents Optional. Specifies how the XML processor should handle validation against
the elements specified by this any element. Can be set to one of the following:
• strict - the XML processor must obtain the schema for the required
namespaces and validate the elements (this is default)
• lax - same as strict but; if the schema cannot be obtained, no errors
will occur
• skip - The XML processor does not attempt to validate any elements
from the specified namespaces
Example 1
The following example shows a declaration for an element called "person". By using the <any> element the
author can extend (after <lastname>) the content of "person" with any element:
<xs:complexType>
<xs:sequence>
<xs:any minOccurs="0"/>
</xs:sequence>
</xs:complexType>
</xs:element>
The anyAttribute Element

The anyAttribute element enables the author to extend the XML document with attributes not specified by the
schema.
Element Information
• Parent elements: complexType, restriction (both simpleContent and complexContent),

extension (both simpleContent and complexContent), attributeGroup
Syntax
<anyAttribute
id=ID
namespace=namespace
processContents=lax|skip|strict
any attributes
>
(annotation?)
</anyAttribute>
(The ? sign declares that the element can occur zero or one time inside the anyAttribute element)
namespace Optional. Specifies the namespaces containing the attributes that can be used.
Can be set to one of the following:
• ##any - attributes from any namespace is allowed (this is default)

• ##other - attributes from any namespace that is not the namespace
of the parent element can be present
• ##local - attributes must come from no namespace
• ##targetNamespace - attributes from the namespace of the parent
element can be present
• List of {URI references of namespaces, ##targetNamespace,
##local} - attributes from a space-delimited list of the namespaces
can be present
processContents Optional. Specifies how the XML processor should handle validation against
the elements specified by this any element. Can be set to one of the following:
• strict - the XML processor must obtain the schema for the required
namespaces and validate the elements (this is default)
• lax - same as strict but; if the schema cannot be obtained, no errors
will occur
• skip - The XML processor does not attempt to validate any elements
from the specified namespaces
Example 1
The following example shows a declaration for an element called "person". By using the <anyAttribute>
element the author can add any number of attributes to the "person" element:
<xs:complexType>
<xs:sequence>
</xs:sequence>
<xs:anyAttribute/>
</xs:complexType>
</xs:element>
The appInfo Element
The appInfo element specifies information to be used by the application. This element must go within an
annotation element.
Element Information
• Parent elements: annotation
Syntax
<appInfo
source=anyURL
>
Any well-formed XML content
</appInfo>
source Optional. A URI reference that specifies the source of the application information
Example 1
<xs:annotation>
</xs:documentation>
</xs:annotation>
.
.
.
</xs:schema>
The attribute Element
The attribute element defines an attribute.
Element Information
• Parent elements: attributeGroup, schema, complexType, restriction (both
simpleContent and complexContent), extension (both simpleContent and
complexContent)
Syntax
<attribute
default=string
fixed=string
form=qualified|unqualified
id=ID
name=NCName
ref=QName
type=QName
use=optional|prohibited|required
any attributes
>
(annotation?,(simpleType?))
</attribute>
(The ? sign declares that the element can occur zero or one time inside the attribute element)
default Optional. Specifies a default value for the attribute. Default and fixed
attributes cannot both be present
fixed Optional. Specifies a fixed value for the attribute. Default and fixed
form Optional. Specifies the form for the attribute. The default value is the
value of the attributeFormDefault attribute of the element containing
the attribute. Can be set to one of the following:
• "qualified" - indicates that this attribute must be qualified with

the namespace prefix and the no-colon-name (NCName) of the
attribute
• unqualified - indicates that this attribute is not required to be
qualified with the namespace prefix and is matched against the
(NCName) of the attribute

name Optional. Specifies the name of the attribute. Name and ref attributes
cannot both be present
ref Optional. Specifies a reference to a named attribute. Name and ref
attributes cannot both be present. If ref is present, simpleType
element, form, and type cannot be present
type Optional. Specifies a built-in data type or a simple type. The type
attribute can only be present when the content does not contain a
simpleType element
use Optional. Specifies how the attribute is used. Can be one of the
following values:
• optional - the attribute is optional (this is default)

• prohibited - the attribute cannot be used
• required - the attribute is required
Example 1
<xs:attribute name="code">
<xs:simpleType>
<xs:pattern value="[A-Z][A-Z]"/>
</xs:restriction>
</xs:simpleType>
</xs:attribute>
The example above indicates that the "code" attribute has a restriction. The only acceptable value is two of the
uppercase letters from a to z.
Example 2
To declare an attribute using an existing attribute definition within a complex type, use the ref attribute:
<xs:attribute name="code">
<xs:simpleType>
<xs:pattern value="[A-Z][A-Z]"/>
</xs:restriction>
</xs:simpleType>
</xs:attribute>
<xs:complexType name="someComplexType">
<xs:attribute ref="code"/>
</xs:complexType>
Example 3
Attributes can have either 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 when no other value is specified. But unlike default
values; if you specify another value than the fixed, the document is considered invalid. In the following
example the fixed value is "EN":
<xs:attribute name="lang" type="xs:string" fixed="EN"/>
Example 4
All attributes are optional by default. To explicitly specify that the attribute is optional, use the "use" attribute:
<xs:attribute name="lang" type="xs:string" use="optional"/>
To make an attribute required:
<xs:attribute name="lang" type="xs:string" use="required"/>
The attributeGroup Element
The attributeGroup element is used to group a set of attribute declarations so that they can be incorporated as
a group into complex type definitions.
Element Information
• Parent elements: attributeGroup, complexType, schema, restriction (both
complexContent)
Syntax
<attributeGroup
id=ID
name=NCName
ref=QName
any attributes
>
(annotation?),((attribute|attributeGroup)*,anyAttribute?))
</attributeGroup>
occur zero or more times inside the attributeGroup element)
name Optional. Specifies the name of the attribute group. Name and ref
ref Optional. Specifies a reference to a named attribute group. Name and
ref attributes cannot both be present
Example 1
<xs:attributeGroup name="personattr">
<xs:attribute name="attr1" type="string"/>
<xs:attribute name="attr2" type="integer"/>
<xs:complexType name="person">
<xs:attributeGroup ref="personattr"/>
</xs:complexType>
The example above defines an attribute group named "personattr" which is used in a complex type named
"person".
The choice Element
The choice element allows only one of the elements contained in the <choice> declaration to be present within
the containing element.
Element Information
• Parent elements: group, choice, sequence, complexType, restriction (both

complexContent)
Syntax
<choice
id=ID
any attributes
>
(annotation?,(element|group|choice|sequence|any)*)
</choice>
occur zero or more times inside the choice element)
maxOccurs Optional. Specifies the maximum number of times the choice element
can occur in the parent element. The value can be any number >= 0,
or if you want to set no limit on the maximum number, use the value
"unbounded". Default value is 1
minOccurs Optional. Specifies the minimum number of times the choice element
can occur in the parent the element. The value can be any number >=
0. Default value is 1
Example 1
<xs:complexType>
<xs:choice>
<xs:element name="employee" type="employee"/>
<xs:element name="member" type="member"/>
</xs:choice>
</xs:complexType>
</xs:element>
The example above defines an element named "person" which must contain either a "employee" element or a
"member" element.
The complexContent Element
The complexContent element defines extensions or restrictions on a complex type that contains mixed content
or elements only.
Element Information
• Parent elements: complexType
Syntax
<complexContent
id=ID
mixed=true|false
any attributes
>
(annotation?,(restriction|extension))
</complexContent>
(The ? sign declares that the element can occur zero or one time inside the complexContent element)
mixed Optional. Specifies whether character data is allowed to appear
between the child elements of this complexType element. Default is
false
Example 1
The following example has a complex type, "fullpersoninfo", that derives from another complex type,
"personinfo", by extending the inherited type with three additional elements (address, city and country):
<xs:sequence>
</xs:sequence>
</xs:complexType>
<xs:complexContent>
<xs:sequence>
</xs:sequence>
</xs:extension>
</xs:complexType>
In the example above the "employee" element must contain, in sequence, the following elements: "firstname",
"lastname", "address", "city", and "country".
The complexType Element
The complexType element defines a complex type. A complex type element is an XML element that contains
other elements and/or attributes.
Element Information
• Parent elements: redefine, schema
Syntax
<complexType
id=ID
name=NCName
abstract=true|false
mixed=true|false
block=(#all|list of (extension|restriction))
final=(#all|list of (extension|restriction))
any attributes
>
(annotation?,(simpleContent|complexContent|((group|all|
choice|sequence)?,((attribute|attributeGroup)*,anyAttribute?))))
</complexType>
occur zero or more times inside the complexType element)
name Optional. Specifies a name for the element
abstract Optional. Specifies whether the complex type can be used in an
instance document. True indicates that an element cannot use this
complex type directly but must use a complex type derived from this
complex type. Default is false
mixed Optional. Specifies whether character data is allowed to appear
between the child elements of this complexType element. Default is
false. If a simpleContent element is a child element, the mixed attribute
is not allowed!
block Optional. Prevents a complex type that has a specified type of
derivation from being used in place of this complex type. This value can
contain #all or a list that is a subset of extension or restriction:
• extension - prevents complex types derived by extension

• restriction - prevents complex types derived by restriction
• #all - prevents all derived complex types
final Optional. Prevents a specified type of derivation of this complex type

element. Can contain #all or a list that is a subset of extension or
restriction.
• extension - prevents derivation by extension

• restriction - prevents derivation by restriction
• #all - prevents all derivation
Example 1
The following example has an element named "note" that is of a complex type:
<xs:complexType>
<xs:sequence>
</xs:sequence>
</xs:complexType>
</xs:element>
Example 2
The following example has a complex type, "fullpersoninfo", that derives from another complex type,
"personinfo", by extending the inherited type with three additional elements (address, city and country):
<xs:sequence>
</xs:sequence>
</xs:complexType>
<xs:complexContent>
<xs:sequence>
</xs:sequence>
</xs:extension>
</xs:complexType>
In the example above the "employee" element must contain, in sequence, the following elements: "firstname",
"lastname", "address", "city", and "country".
The documentation Element
The documentation element is used to enter text comments in a schema. This element must go inside an
annotation element.
Element Information
• Parent elements: annotation
Syntax
<documentation
source=URI reference
xml:lang=language
>
Any well-formed XML content
</documentation>
source Optional. Specifies the source of the application information
xml:lang Optional. Specifies the language used in the contents
Example 1
<xs:annotation>
</xs:documentation>
</xs:annotation>
.
.
.
</xs:schema>
The element Element
The element element defines an element.
Element Information
• Parent elements: schema, choice, all, sequence, group
Syntax
<element
id=ID
name=NCName
ref=QName
type=QName
substitutionGroup=QName
default=string
fixed=string
form=qualified|unqualified
nullable=true|false
abstract=true|false
block=(#all|list of (extension|restriction))
final=(#all|list of (extension|restriction))
any attributes
>
annotation?,((simpleType|complexType)?,(unique|key|keyref)*))
</element>
occur zero or more times inside the element element)
name Optional. Specifies a name for the element. This attribute is required if
the parent element is the schema element
ref Optional. Refers to the name of another element. The ref attribute can
include a namespace prefix. This attribute cannot be used if the parent
element is the schema element
type Optional. Specifies either the name of a built-in data type, or the name
of a simpleType or complexType element
substitutionGroup Optional. Specifies the name of an element that can be substituted with
this element. This attribute cannot be used if the parent element is not
the schema element
default Optional. Specifies a default value for the element (can only be used if
the element's content is a simple type or text only)
fixed Optional. Specifies a fixed value for the element (can only be used if
the element's content is a simple type or text only)
form Optional. Specifies the form for the element. "unqualified" indicates that
this attribute is not required to be qualified with the namespace prefix.
"qualified" indicates that this attribute must be qualified with the
namespace prefix. The default value is the value of the
elementFormDefault attribute of the schema element. This attribute
cannot be used if the parent element is the schema element
maxOccurs Optional. Specifies the maximum number of times this element can
occur in the parent element. The value can be any number >= 0, or if
you want to set no limit on the maximum number, use the value
"unbounded". Default value is 1. This attribute cannot be used if the
parent element is the schema element
minOccurs Optional. Specifies the minimum number of times this element can
occur in the parent element. The value can be any number >= 0.
Default value is 1. This attribute cannot be used if the parent element is
the schema element
nullable Optional. Specifies whether an explicit null value can be assigned to the
element. True enables an instance of the element to have the null
attribute set to true. The null attribute is defined as part of the XML
Schema namespace for instances. Default is false
abstract Optional. Specifies whether the element can be used in an instance
document. True indicates that the element cannot appear in the
instance document. Instead, another element whose substitutionGroup
attribute contains the qualified name (QName) of this element must
appear in this element's place. Default is false
block Optional. Prevents an element with a specified type of derivation from
being used in place of this element. This value can contain #all or a list
that is a subset of extension, restriction, or equivClass:
• extension - prevents elements derived by extension

• restriction - prevents elements derived by restriction
• substitution - prevents elements derived by substitution
• #all - prevents all derived elements
final Optional. Sets the default value of the final attribute on the element
element. This attribute cannot be used if the parent element is not the
schema element. This value can contain #all or a list that is a subset of
extension or restriction:
• extension - prevents elements derived by extension

• restriction - prevents elements derived by restriction
• #all - prevents all derived elements
Example 1
The following example is a schema with four simple elements named "fname", "lname", "age", and "dateborn",
which are of type string, nonNegativeInteger, and date:
<xs:element name="fname" type="xs:string"/>
<xs:element name="lname" type="xs:string"/>
<xs:element name="age" type="xs:nonNegativeInteger"/>
<xs:element name="dateborn" type="xs:date"/>
</xs:schema>
Example 2
The following example is a schema with an element named "note" that is of a complex type. The "note"
element contains four other simple elements; "to", "from", "heading", and "body":
<xs:complexType>
<xs:sequence>
</xs:sequence>
</xs:complexType>
</xs:element>
</xs:schema>
Example 3
This example is equal to Example 2, but here we have chosen to use the ref attribute to refer to the element
names:
<xs:complexType>
<xs:sequence>
<xs:element ref="to"/>
<xs:element ref="from"/>
<xs:element ref="heading"/>
<xs:element ref="body"/>
</xs:sequence>
</xs:complexType>
</xs:element>
</xs:schema>
The extension Element
The extension element extends an existing simpleType or complexType element.
Element Information
• Parent elements: simpleContent, complexContent
Syntax
<extension
id=ID
base=QName
any attributes
>
(annotation?,((group|all|choice|sequence)?,
((attribute|attributeGroup)*,anyAttribute?)))
</extension>
occur zero or more times inside the extension element)
base Optional. Specifies the name of a built-in data type, a simpleType
element, or a complexType element
Example 1
The following example extends an existing simpleType by adding an attribute:

<xs:simpleType name="size">
<xs:enumeration value="small" />
<xs:enumeration value="medium" />
<xs:enumeration value="large" />
</xs:restriction>
</xs:simpleType>
<xs:complexType name="jeans">
<xs:simpleContent>
<xs:extension base="size">
<xs:attribute name="sex">
<xs:enumeration value="male" />
<xs:enumeration value="female" />
</xs:restriction>
</xs:attribute>
</xs:extension>
</xs:simpleContent>
</xs:complexType>
</xs:schema>
Example 2
The following example extends an existing complexType element by adding three elements:
<xs:sequence>
</xs:sequence>
</xs:complexType>
<xs:complexContent>
<xs:sequence>
</xs:sequence>
</xs:extension>
</xs:complexType>
</xs:schema>
The field Element
The field element specifies an XPath expression that specifies the value used to define an identity constraint.
Element Information
• Parent elements: key, keyref, unique
Syntax
<field
id=ID
xpath=XPath expression
any attributes
>
(annotation?)
</field>
(The ? sign declares that the element can occur zero or one time inside the field element)
xpath Required. Identifies a single element or attribute whose content or
value is used for the constraint
Example 1
The following example shows a field element that specifies the "userID" attribute as the field to use for the
identity constraint:
<xs:field xpath="@userID"/>
The group Element

The group element is used to define a group of elements to be used in complex type definitions.
Element Information
• Parent elements: schema, choice, sequence, complexType, restriction (both

complexContent)
Syntax
<group
id=ID
name=NCName
ref=QName
any attributes
>
(annotation?,(all|choice|sequence))
</group>
(The ? sign declares that the element can occur zero or one time inside the group element)
name Optional. Specifies a name for the group. This attribute is used only
when the schema element is the parent of this group element. Name
and ref attributes cannot both be present
ref Optional. Refers to the name of another group. Name and ref attributes
cannot both be present
maxOccurs Optional. Specifies the maximum number of times the group element
can occur in the parent element. The value can be any number >= 0,
or if you want to set no limit on the maximum number, use the value
"unbounded". Default value is 1
minOccurs Optional. Specifies the minimum number of times the group element
can occur in the parent element. The value can be any number >= 0.
Default value is 1
Example 1
The following example defines a group containing a sequence of four elements and uses the group element in
a complex type definition:
<xs:group name="custGroup">
<xs:sequence>
<xs:element name="customer" type="xs:string"/>
<xs:element name="orderdetails" type="xs:string"/>
<xs:element name="billto" type="xs:string"/>
<xs:element name="shipto" type="xs:string"/>
</xs:sequence>
</xs:group>
<xs:element name="order" type="ordertype"/>

<xs:complexType name="ordertype">
<xs:group ref="custGroup"/>
<xs:attribute name="status" type="xs:string"/>
</xs:complexType>
</xs:schema>
The import Element
The import element is used to add multiple schemas with different target namespace to a document.
Element Information
• Parent elements: schema
Syntax
<import
id=ID
namespace=anyURI
schemaLocation=anyURI
any attributes
>
(annotation?)
</import>
(The ? sign declares that the element can occur zero or one time inside the import element)
namespace Required. Specifies the URI of the namespace to import
schemaLocation Optional. Specifies the URI to the schema for the imported namespace
Example 1
The following example shows importing a namespace:

<xs:import namespace="http://www.w3schools.com/schema"/>
..
..
..
</xs:schema>
The include Element

The include element is used to add multiple schemas with the same target namespace to a document.
Element Information
Syntax
<include
id=ID
any attributes
>
(annotation?)
</include>
(The ? sign declares that the element can occur zero or one time inside the include element)
schemaLocation Required. Specifies the URI to the schema to include in the target
namespace of the containing schema
Example 1
With included schemas, the included files must all reference the same target namespace. If the schema target
namespace don't match, the include won't work:
targetNamespace="http://www.w3schools.com/schema">
<xs:include
schemaLocation="http://www.w3schools.com/schema/customer.xsd"/>
<xs:include
schemaLocation="http://www.w3schools.com/schema/company.xsd"/>
..
..
..
</xs:schema>
The key Element
The key element specifies an attribute or element value as a key (unique, non-nullable, and always present)
within the containing element in an instance document.
The key element MUST contain the following (in order):
• one and only one selector element (contains an XPath expression that specifies the set
of elements across which the values specified by field must be unique)
• one or more field elements (contains an XPath expression that specifies the values that
must be unique for the set of elements specified by the selector element)
Element Information
• Parent elements: element
Syntax
<key
id=ID
name=NCName
any attributes
>
(annotation?,(selector,field+))
</key>
(The ? sign declares that the element can occur zero or one time, and the + sign declares that the element
must occur one or more times inside the key element)
name Required. Specifies the name of the key element
The keyref Element
The keyref element specifies that an attribute or element value correspond to those of the specified key or
unique element.
The keyref element MUST contain the following (in order):
Element Information
Syntax
<key
id=ID
name=NCName
refer=QName
any attributes
>
</include>
(The ? sign declares that the element can occur zero or one time, and the + sign declares that the element
must occur one or more times inside the keyref element)
name Required. Specifies the name of the keyref element
refer Required. Specifies the name of a key or unique element defined in this
or another schema
The list Element
The list element defines a simple type element as a list of values of a specified data type.
Element Information
• Parent elements: simpleType
Syntax
<list
id=ID
itemType=QName
any attributes
>
(annotation?,(simpleType?))
</list>
(The ? sign declares that the element can occur zero or one time inside the list element)
itemType Specifies the name of a built-in data type or simpleType element defined in this or
another schema. This attribute is not allowed if the content contains a simpleType
element, otherwise it is required
Example 1
The following example shows a simple type that is a list of integers:

<xs:element name="intvalues" type="valuelist">
<xs:simpleType name="valuelist">
<xs:list itemType="xs:integer"/>
</xs:simpleType>
</xs:schema>
The "intvalues" element in a document could look like this (notice that the list will have five list items):
<intvalues>100 34 56 -23 1567</intvalues>
Note: White space is treated as the list item separator!
Example 2
The following example shows a simple type that is a list of strings:
<xs:element name="stringvalues" type="valuelist">
<xs:simpleType name="valuelist">
<xs:list itemType="xs:string"/>
</xs:simpleType>
</xs:schema>
The "stringvalues" element in a document could look like this (notice that the list will have four list items):
<stringvalues>I love XML Schema</stringvalues>
The notation Element
The notation element describes the format of non-XML data within an XML document.
Element Information
Syntax
<notation
id=ID
name=NCName
public=anyURI
system=anyURI
any attributes
>
(annotation?)
</notation>
(The ? sign declares that the element can occur zero or one time inside the notation element)
name Required. Specifies a name for the element
public Required. Specifies a URI corresponding to the public identifier
system Optional. Specifies a URI corresponding to the system identifier
Example 1
The following example shows a gif and a jpeg notation using a viewer application, view.exe:
<xs:notation name="gif" public="image/gif" system="view.exe"/>
<xs:notation name="jpeg" public="image/jpeg" system="view.exe"/>
<xs:element name="image">
<xs:complexType>
<xs:simpleContent>
<xs:attribute name="type">
<xs:simpleType>
<xs:restriction base="xs:NOTATION">
<xs:enumeration value="gif"/>
<xs:enumeration value="jpeg"/>
<xs:restriction>
</xs:simpleType>
</xs:attribute>
</xs:simpleContent>
</xs:complexType>
</xs:element>
</xs:schema>
The "image" element in a document could look like this:
<image type="gif"></image>
The redefine Element
The redefine element redefines simple and complex types, groups, and attribute groups from an external
schema.
Element Information
Syntax
<redefine
id=ID
any attributes
>
(annotation|(simpleType|complexType|group|attributeGroup))*
</redefine>
schemaLocation Required. A URI to the location of a schema document
Example 1
The following example shows a schema, Myschama2.xsd, with elements specified by the Myschama1.xsd.
The pname type is redefined. According to this schema, elements constrained by the pname type must end
with a "country" element:
Myschema1.xsd:
<xs:complexType name="pname">
<xs:sequence>
<xs:element name="firstname"/>
<xs:element name="lastname"/>
</xs:sequence>
</xs:complexType>
<xs:element name="customer" type="pname"/>

</xs:schema>
Myschema2.xsd:
<xs:redefine schemaLocation="Myschema1.xsd">
<xs:complexType name="pname">
<xs:complexContent>
<xs:extension base="pname">
<xs:sequence>
<xs:element name="country"/>
</xs:sequence>
</xs:extension>
</xs:complexType>
</xs:redefine>
<xs:element name="author" type="pname"/>

</xs:schema>
The restriction Element
The restriction element defines restrictions on a simpleType, simpleContent, or complexContent definition.
Element Information
• Parent elements: simpleType, simpleContent, complexContent
Syntax
<restriction
id=ID
base=QName
any attributes
>
Content for simpleType:
(annotation?,(simpleType?,(minExclusive|minInclusive|
maxExclusive|maxInclusive|totalDigits|fractionDigits|
length|minLength|maxLength|enumeration|whiteSpace|pattern)*))
Content for simpleContent:
(annotation?,(simpleType?,(minExclusive |minInclusive|
maxExclusive|maxInclusive|totalDigits|fractionDigits|
length|minLength|maxLength|enumeration|whiteSpace|pattern)*)?,
((attribute|attributeGroup)*,anyAttribute?))
Content for complexContent:

(annotation?,(group|all|choice|sequence)?,
((attribute|attributeGroup)*,anyAttribute?))
</restriction>
(The ? sign declares that the element can occur zero or one time inside the restriction element)
base Required. Specifies the name of a built-in data type, simpleType element, or
complexType element defined in this schema or another schema
Example 1
This example defines an element called "age" with a restriction. The value of age can NOT be lower than 0 or
greater than 100:
<xs:simpleType>
</xs:restriction>
</xs:simpleType>
</xs:element>
Example 2
This example also defines an element called "initials". The "initials" element is a simple type with a restriction.
The only acceptable value is THREE of the LOWERCASE OR UPPERCASE letters from a to z:
<xs:simpleType>
<xs:pattern value="[a-zA-Z][a-zA-Z][a-zA-Z]"/>
</xs:restriction>
</xs:simpleType>
</xs:element>
Example 3
This example defines an element called "password". The "password" element is a simple type with a
restriction. The value must be minimum five characters and maximum eight characters:
<xs:simpleType>
<xs:minLength value="5"/>
<xs:maxLength value="8"/>
</xs:restriction>
</xs:simpleType>
</xs:element>
Example 4
This example shows a complex type definition using restriction. The complex type "Norwegian_customer" is
derived from a general customer complex type and its country element is fixed to "Norway":
<xs:complexType name="customer">
<xs:sequence>
</xs:sequence>
</xs:complexType>
<xs:complexType name="Norwegian_customer">
<xs:complexContent>
<xs:restriction base="customer">
<xs:sequence>
<xs:element name="country" type="xs:string" fixed="Norway"/>
</xs:sequence>
</xs:restriction>
</xs:complexType>
The schema Element
The schema element defines the root element of a schema.
Element Information
• Parent elements: NONE
Syntax
<schema
id=ID
attributeFormDefault=qualified|unqualified
elementFormDefault=qualified|unqualified
blockDefault=(#all|list of (extension|restriction|substitution))
finalDefault=(#all|list of (extension|restriction|list|union))
targetNamespace=anyURI
version=token
xmlns=anyURI
any attributes
>
((include|import|redefine|annotation)*,(((simpleType|complexType|
group|attributeGroup)|element|attribute|notation),annotation*)*)
</schema>
attributeFormDefault Optional. The form for attributes declared in the target namespace of
this schema. The value must be "qualified" or "unqualified". Default is
"unqualified". "unqualified" indicates that attributes from the target
namespace are not required to be qualified with the namespace prefix.
"qualified" indicates that attributes from the target namespace must be
qualified with the namespace prefix
elementFormDefault Optional. The form for elements declared in the target namespace of
this schema. The value must be "qualified" or "unqualified". Default is
"unqualified". "unqualified" indicates that elements from the target
namespace are not required to be qualified with the namespace prefix.
"qualified" indicates that elements from the target namespace must be
qualified with the namespace prefix
blockDefault Optional. Specifies the default value of the block attribute on element
and complexType elements in the target namespace. The block
attribute prevents a complex type (or element) that has a specified
type of derivation from being used in place of this complex type. This
value can contain #all or a list that is a subset of extension, restriction,
or substitution:
• extension - prevents complex types derived by extension

• restriction - prevents complex types derived by restriction
• substitution - prevents substitution of elements
• #all - prevents all derived complex types
finalDefault Optional. Specifies the default value of the final attribute on element,
simpleType, and complexType elements in the target namespace. The
final attribute prevents a specified type of derivation of an element,
simpleType, or complexType element. For element and complexType
elements, this value can contain #all or a list that is a subset of
extension or restriction. For simpleType elements, this value can
additionally contain list and union:
• extension - prevents derivation by extension

• restriction - prevents derivation by restriction
• list - prevents derivation by list
• union - prevents derivation by union
• #all - prevents all derivation
targetNamespace Optional. A URI reference of the namespace of this schema

version Optional. Specifies the version of the schema
xmlns A URI reference that specifies one or more namespaces for use in this
schema. If no prefix is assigned, the schema components of the
namespace can be used with unqualified references
Example 1
<xs:element name="values" type="xs:string">
</xs:schema>
Example 2
In this example, the schema components (element name, type) in the http://www.w3.org/2001/XMLSchema
namespace are unqualified and those for http://www.w3schools.com/w3schoolsschema (mystring) are
qualified with the wsc prefix:
<schema xmlns="http://www.w3.org/2001/XMLSchema"
xmlns:wsc="http://www.w3schools.com/w3shoolsschema">
<element name="fname" type="wsc:mystring"/>
</schema>
The selector Element

The selector element specifies an XPath expression that selects a set of elements for an identity constraint
(unique, key, and keyref elements).
Element Information
• Parent elements: key, keyref, unique
Syntax
<selector
id=ID
xpath=a subset of XPath expression
any attributes
>
(annotation?)
</selector>
(The ? sign declares that the element can occur zero or one time inside the selector element)
xpath Required. Specifies an XPath expression, relative to the element being
declared, that identifies the child elements to which the identity
constraint applies
The sequence Element
The sequence element specifies that the child elements must appear in a sequence. Each child element can
occur from 0 to any number of times.
Element Information
• Parent elements: group, choice, sequence, complexType, restriction (both

complexContent)
Syntax
<sequence
id=ID
any attributes
>
(annotation?,(element|group|choice|sequence|any)*)
</sequence>
(The ? sign declares that the element can occur zero or one time inside the sequence element)
maxOccurs Optional. Specifies the maximum number of times the sequence element can
occur in the parent element. The value can be any number >= 0, or if you want
to set no limit on the maximum number, use the value "unbounded". Default
value is 1
minOccurs Optional. Specifies the minimum number of times the sequence element can
occur in the parent element. The value can be any number >= 0. Default value
is 1
Example 1
This example shows a declaration for an element called "personinfo", which must contain the following five
elements in order; "firstname", "lastname", "address", "city", and "country":
<xs:element name="personinfo">
<xs:complexType>
<xs:sequence>
</xs:sequence>
</xs:complexType>
</xs:element>
Example 2
This example shows a declaration for an element called "pets" that can have zero or more of the following
elements, dog and cat, in the sequence element:
<xs:element name="pets">
<xs:complexType>
<xs:sequence minOccurs="0" maxOccurs="unbounded">
<xs:element name="dog" type="xs:string"/>
<xs:element name="cat" type="xs:string"/>
</xs:sequence>
</xs:complexType>
</xs:element>
The simpleContent Element
The simpleContent element contains extensions or restrictions on a text-only complex type or on a simple type
as content and contains no elements.
Element Information
• Parent elements: complexType

Syntax
<simpleContent
id=ID
any attributes
>
(annotation?,(restriction|extension))
</simpleContent>
(The ? sign declares that the element can occur zero or one time inside the simpleContent element)
Example 1
Here is an example of an XML element (<shoesize>) that contains text-only:

<shoesize country="france">35</shoesize>
The following example declares a complexType, "shoesize", with its content defined as a integer data type and
with a country attribute:
<xsd:element name="shoesize">
<xsd:complexType>
<xsd:simpleContent>
<xsd:extension base="xsd:integer">
<xsd:attribute name="country" type="xsd:string" />
</xsd:extension>
</xsd:simpleContent>
</xsd:complexType>
</xsd:element>
The simpleType Element
The simpleType element defines a simple type and specifies the constraints and information about the values
of attributes or text-only elements.
Element Information
• Parent elements: attribute, element, list, restriction, schema, union
Syntax
<simpleType
id=ID
name=NCName
any attributes
>
(annotation?,(restriction|list|union))
</simpleType>
(The ? sign declares that the element can occur zero or one time inside the simpleType element)
name Specifies a name for the element. This attribute is required if the simpleType
element is a child of the schema element, otherwise it is not allowed
Example 1
This example defines an element called "age" that is a simple type with a restriction. The value of age can
NOT be lower than 0 or greater than 100:
<xs:simpleType>
</xs:restriction>
</xs:simpleType>
</xs:element>
The union Element
The union element defines a simple type as a collection (union) of values from specified simple data types.
Element Information
• Parent elements: simpleType
Syntax
<union
id=ID
memberTypes="list of QNames"
any attributes
>
(annotation?,(simpleType*))
</union>
(The ? sign declares that the element can occur zero or one time inside the union element)
memberTypes Optional. Specifies a list of built-in data types or simpleType elements defined in
a schema
Example 1
This example shows a simple type that is a union of two simple types:
<xsd:element name="jeans_size">
<xsd:simpleType>
<xsd:union memberTypes="sizebyno sizebystring" />
</xsd:simpleType>
</xsd:element>
<xsd:simpleType name="sizebyno">
<xsd:restriction base="xsd:positiveInteger">
<xsd:maxInclusive="42"/>
</xsd:restriction>
</xsd:simpleType>
<xsd:simpleType name="sizebystring">
<xsd:restriction base="xsd:string">
<xsd:enumeration value="small"/>
<xsd:enumeration value="medium"/>
<xsd:enumeration value="large"/>
</xsd:restriction>
</xsd:simpleType>
The unique Element
The unique element defines that an element or an attribute value must be unique within the scope.
The unique element MUST contain the following (in order):
Element Information
Syntax
<unique
id=ID
name=NCName
any attributes
>
</unique>
(The ? sign declares that the element can occur zero or one time inside the unique element)
name Required. Specifies a name for the element

XML Schema Tutorial

Uploaded by

XML Schema Tutorial

Uploaded by

XML Schema Tutorial

Introduction to XML Schemas

XML Schema References

XML Schema Content Models - References

Introduction to XML Schema

XML Schema is an XML based alternative to DTD.

What You Should Already Know

What is an XML Schema?

• defines elements that can appear in a document

XML Schemas are the Successors of DTDs

XML Schema is a W3C Recommendation

XML Schemas - Why?

XML Schema has Support for Data Types

 It is easier to describe permissible document content

XML Schemas use XML Syntax

 You don't have to learn another language

XML Schemas Secure Data Communication

XML Schemas are Extensible

 Reuse your Schema in other Schemas

Well-Formed is not Enough

• must begin with the XML declaration

XML documents can have a reference to a DTD or an XML Schema.

A Simple XML Document

Look at this simple XML document called "note.xml":

A Simple XML Schema

This XML document has a reference to a DTD:

This XML document has a reference to an XML Schema:

XSD - The <schema> Element

The <schema> element is the root element of every XML Schema!

The <schema> Element

The <schema> element is the root element of every XML Schema:

Referencing a Schema in an XML Document

This XML document has a reference to an XML Schema:

XSD Simple Elements

XML Schemas define the elements of your XML files.

What is a Simple Element?

The syntax for defining a simple element is:

Common XML Schema Data Types

Declare Default and Fixed Values for Simple Elements

Simple elements can have a default value OR a fixed value set.

All attributes are declared as simple types.

How to Define an Attribute

The syntax for defining an attribute is:

Common XML Schema Data Types

Declare Default and Fixed Values for Attributes

Attributes can have a default value OR a fixed value specified.

Creating Optional and Required Attributes

Restrictions on a Set of Values

Restrictions on a Series of Values

Other Restrictions on a Series of Values

Some other restrictions that can be defined by the pattern constraint:

Restrictions for Datatypes

XSD Complex Elements

A complex element contains other elements and/or attributes.

What is a Complex Element?

Note: Each of these elements may contain attributes as well!

A complex XML element, "product", which is empty:

How to Define a Complex Element

XSD Complex Empty Elements

Define Complex Types for Empty Elements

An empty XML element:

XSD Complex Type Elements Only

Define Complex Types with Elements Only

An XML element, "person", that contains only other elements:

XSD Complex Text-Only Elements

A complex text element can contain both attributes and text.

Define Complex Text-Only Elements

XSD Complex Types With Mixed Content

XSD Complex Types Indicators

We can control HOW elements are to be used in documents with indicators.

We have seven types of indicators:

Order indicators are used to define how elements should occur.

Group indicators are used to define related sets of elements.

XSD The <any> Element

The <any> Element

XSD The <anyAttribute> Element

It is easier to describe permissible document content

You don't have to learn another language

Reuse your Schema in other Schemas