A DTD File: XML Schema 1

XML SCHEMA
XML documents can have a reference to a

DTD or to an XML Schema.
"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>
An XML Schema
A DTD File
The following example is a DTD file called
"note.dtd"
<!ELEMENT note (to, from, heading,
body)>
<!ELEMENT to (#PCDATA)>
<!ELEMENT from (#PCDATA)>
<!ELEMENT heading (#PCDATA)>
<!ELEMENT body (#PCDATA)>
The following example is an 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.w
3schools.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>
This XML document has a reference to a DTD:
<!DOCTYPE note SYSTEM note.dtd">
<note>
<to>Tove</to>
<from>Jani</from>
<heading>Reminder</heading>
<body>Don't forget me this weekend!</body>
</note>
A Reference to an XML Schema This XML document has a reference to an XML Schema:
<note xmlns=http://www.w3schools.com xmlns:xsi=http://www.w3.org/2001/XMLSchemainstance xsi:schemaLocation="note.xsd">
<to>Tove</to> <from>Jani</from>
<heading>Reminder</heading> <body>Don't forget me this weekend!</body>
</note>
XML SCHEMA
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.
Defining a Simple Element
The syntax for defining a simple element is:
<xs:element name="xxx" type="yyy"/>
where xxx is the name of the element and yyy is the data type of the element.
XML Schema has a lot of built-in data types. The most common types are:
xs:string
xs:boolean
xs:decimal
xs:date
xs:integer
Example
xs:time
<lastname>Refsnes</lastname>
<age>36</age>
<dateborn>1970-03-27</dateborn>
And here are the corresponding simple element definitions:
<xs:element name="lastname" type="xs:string"/>
<xs:element name="age" type="xs:integer"/>
<xs:element name="dateborn" type="xs:date"/>
Default and Fixed Values for Simple Elements
In the following example the default value is "red":
<xs:element name="color" type="xs:string" default="red"/>
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.
XML SCHEMA
What is an Attribute?
Simple elements cannot have attributes. If an element has attributes, it is considered to be of a
complex type. But the attribute itself is always declared as a simple type.
How to Define an Attribute?

The syntax for defining an attribute is:
<xs:attribute name="xxx" type="yyy"/>
XML Schema has a lot of built-in data types. The most common types are:
xs:string
xs:boolean
xs:decimal
xs:date
xs:integer
Example
xs:time
Here is an XML element with an attribute:
<lastname lang="EN">Smith</lastname>
<xs:attribute name="lang" type="xs:string"/
>
Default and Fixed Values for Attributes

<xs:attribute name="lang" type="xs:string" default="EN"/>
<xs:attribute name="lang" type="xs:string" fixed="EN"/>
Optional and Required Attributes

Attributes are optional by default. To specify that the attribute is required, use the "use" attribute:
<xs:attribute name="lang" type="xs:string" use="required"/>
Restrictions on Content
XML SCHEMA
When an XML element or attribute has a data type defined, it puts restrictions on the element's or
attribute's content. If an XML element is of type "xs:date" and contains a string like "Hello
World", the element will not validate.
Restrictions on Values:
The value of age cannot be lower than 0 or greater than 120:
<xs:element name="age">
<xs:simpleType>
<xs:restriction base="xs:integer">
<xs:minInclusive value="0"/>
<xs:maxInclusive value="120"/>
</xs:restriction>
</xs:simpleType>
</xs:element>
Restrictions on a Set of Values
The example below defines an element called "car" with a restriction. The only acceptable values
are: Audi, Golf, BMW:
<xs:element name="car">
<xs:simpleType>
<xs:restriction base="xs:string">
<xs:enumeration value="Audi"/>
<xs:enumeration value="Golf"/>
<xs:enumeration value="BMW"/>
</xs:restriction>
</xs:simpleType>
</xs:element>
<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>
The example above could also have been

written like this:
Other Restrictions on a Series of Values
The acceptable value is zero or more
letter followed by an upper case letter. For
occurrences of lowercase letters from a to z:

<xs:element name="letter">
<xs:simpleType>
<xs:pattern value="([a-z])*"/>
</xs:restriction>
</xs:simpleType>
</xs:element>
ex, "sToP" will be validated, but not
The acceptable value is one or more pairs of

letters, each pair consisting of a lower case
"Stop"/"STOP"/"stop":
<xs:simpleType>
<xs:pattern value="([a-z][A-Z])+"/>
</xs:restriction>
</xs:simpleType>
</xs:element>
XML SCHEMA
The next example defines an element called "password" with a restriction. There must be
exactly eight characters in a row and those characters must be lowercase or uppercase letters
from a to z, or a number from 0 to 9:
<xs:element name="password">
<xs:simpleType>
<xs:pattern value="[a-zA-Z0-9]{8}"/>
</xs:restriction>
</xs:simpleType>
</xs:element>
<xs:element name="address">
<xs:simpleType>
<xs:whiteSpace value="preserve"/>
</xs:restriction>
</xs:simpleType>
</xs:element>
Restrictions on Whitespace Characters

This example defines an element called "address" with a restriction. The whiteSpace constraint is
set to "preserve", which means that the XML processor WILL NOT remove any white space
characters: 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:
<xs:whiteSpace value="replace"/>
The whiteSpace constraint is set to "collapse", which means that the XML processor WILL
REMOVE all white space characters.
<xs:whiteSpace value="collapse"/>
Restrictions on Length
To limit the length of a value in an element, we would use the length, maxLength, and
minLength constraints. The value must be exactly eight characters:
<xs:element name="password">
<xs:simpleType>
<xs:length value="8"/> [<xs:minLength value="5"/>
<xs:maxLength value="8"/>]
</xs:restriction> </xs:simpleType> </xs:element>
A mixed complex type element can contain attributes, elements, and text.
Complex Types with Mixed Content
The following schema declares the "letter"
An XML element, "letter", that contains
element:
<xs:complexType mixed="true">
<xs:sequence>
<xs:element name="name" type="xs:stri
ng"/>
<xs:element name="orderid" type="xs:p
ositiveInteger"/>
<xs:element name="shipdate" type="xs:
both text and other elements:

<letter>
Dear Mr.<name>John Smith</name>.
Your order <orderid>1032</orderid>
will be shipped on <shipdate>2001-0713</shipdate>.
</letter>
XML SCHEMA
date"/>
</xs:sequence>
</xs:complexType>
</xs:element>
XSD Indicators
We can control HOW elements are to be used in documents with indicators.
Indicators
There are seven indicators:
Order indicators:
All
Choice
Sequence
Occurrence indicators:
maxOccurs
minOccurs
Group indicators:
Group name
attributeGroup name
Order Indicators
Order indicators are used to define the order of the elements.
All Indicator
The <all> indicator specifies that the child elements can appear in any order, and that each child
element must occur only once:
<xs:element name="person">
<xs:complexType>
<xs:all>
<xs:element name="firstname" type="xs:string"/>

</xs:all>
XML SCHEMA
</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 element 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:element name="firstname" type="xs:string
"/>
<xs:element name="lastname" type="xs:string"
/>
</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:strin

g"/>
<xs:element name="child_name" type="xs:st
ring" maxOccurs="10"/>
</xs:sequence>
</xs:complexType>
</xs:element>
XML SCHEMA
The <minOccurs> indicator specifies the

minimum number of times an element can
occur:
<xs:complexType>
<xs:sequence>
<xs:element name="full_name" type="xs:strin

g"/>
<xs:element name="child_name" type="xs:st
ring"
maxOccurs="10" minOccurs="0"/>
</xs:sequence>
</xs:complexType>
</xs:element>
Tip: To allow an element to appear an unlimited number of times, use the

maxOccurs="unbounded" statement:
An XML file called "Myfamily.xml":

<?xml version="1.0" encoding="UTF-8"?>
<persons xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:noNamespaceSchemaLocation="family.xsd">
<person>
<full_name>Hege Refsnes</full_name>
<child_name>Cecilie</child_name>
</person>
<person>
<full_name>Tove Refsnes</full_name>
<child_name>Hege</child_name>
<child_name>Stale</child_name>
<child_name>Jim</child_name>
<child_name>Borge</child_name>
</person>
<person>
<full_name>Stale Refsnes</full_name>
XML SCHEMA
</person>
</persons>
The XML file above contains a root element named "persons". Inside this root element we have
defined three "person" elements. Each "person" element must contain a "full_name" element and
it can contain up to five "child_name" elements. Here is the schema file "family.xsd":
<xs:schema xmlns:xs=http://www.w3.org/2001/XMLSchema elementFormDefault="qualified">
<xs:element name="persons">
<xs:complexType>
<xs:sequence>
<xs:element name="person" maxOccurs="unbounded">
<xs:complexType>
<xs:sequence>
<xs:element name="full_name" type="xs:string"/>
<xs:element name="child_name" type="xs:string"
minOccurs="0" maxOccurs="5"/>
</xs:sequence>
</xs:complexType>
</xs:element>
</xs:sequence>
</xs:complexType>
</xs:element>
</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:
XML SCHEMA
<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 definition, like this:
<xs:element name="person" type="personinfo"/>
<xs:complexType name="personinfo">
<xs:sequence>
<xs:group ref="persongroup"/>
<xs:element name="country" type="xs:string"/>
</xs:sequence>
</xs:complexType>
Attribute Groups
Attribute groups are defined with the attributeGroup declaration, like this:
<xs:attributeGroup name="groupname">
...
</xs:attributeGroup>
The following example defines an attribute group named "personattrgroup":
<xs:attributeGroup name="personattrgroup">
<xs:attribute name="firstname" type="xs:string"/>
<xs:attribute name="lastname" type="xs:string"/>
<xs:attribute name="birthday" type="xs:date"/>
</xs:attributeGroup>
After you have defined an attribute group, you can reference it in another definition, like this:
<xs:complexType>
<xs:attributeGroup ref="personattrgroup"/> </xs:complexType> </xs:element>
10
XML SCHEMA
11
XSD The <any> Element

The <any> element enables us to extend the XML document with elements not specified by the
schema.
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:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"targetNamespace=http://www.w3
schools.com xmlns=http://www.w3schools.com elementFormDefault="qualified">
<xs:element name="children">
<xs:complexType>
<xs:sequence>
<xs:element name="childname" type="xs:string" maxOccurs="unbounded"/>
</xs:sequence>
</xs:complexType>
</xs:element>
</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"xmlns:xsi="http://www.w3.org/2001/XMLSchemainstance"xsi:schemaLocation="http://www.microsoft.com family.xsd children.xsd">
<person>
<firstname>Hege</firstname>
<children>
<childname>Cecilie</childname>
</children>
</person>
<person>
XML SCHEMA
12
<firstname>Stale</firstname>
<lastname>Refsnes</lastname></person></persons>
The <anyAttribute> Element
The <anyAttribute> element enables us to extend the XML document with attributes not
specified by the schema.
"family.xsd"
<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.
"attribute.xsd":
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"elementFormDefault="qualified"
>
<xs:attribute name="gender">
<xs:simpleType>
<xs:pattern value="male|female"/>
</xs:restriction>
</xs:simpleType>
</xs:attribute></xs:schema>
"Myfamily.xml": uses components from two different schemas; "family.xsd" and
"attribute.xsd":
<persons xmlns="http://www.microsoft.com"
xmlns:xsi=http://www.w3.org/2001/XMLSchema-instance xsi:SchemaLocation="family.xsd
attribute.xsd">
<person gender="female">
<firstname>Hege</firstname>
</person>
<person gender="male">
<firstname>Stale</firstname>
</person></persons>
Let's have a look at this XML document called "shiporder.xml":

<shiporder orderid="889923"
xmlns:xsi=http://www.w3.org/2001/XMLSc
hema-instance
xsi:noNamespaceSchemaLocation="shipord
er.xsd">
XML SCHEMA
<orderperson>John Smith</orderperson>
<shipto>
<name>Ola Nordmann</name>
<address>Langgt 23</address>
<item>
<title>Empire Burlesque</title>
<note>Special Edition</note>
<quantity>1</quantity>
<price>10.90</price>
</item>
13
<city>4000 Stavanger</city>
<country>Norway</country>
</shipto>
<item>
<title>Hide your heart</title>
<quantity>1</quantity>
<price>9.90</price>
</item>
</shiporder>
Create an XML Schema "shiporder.xsd":

<?xml version="1.0" encoding="UTF-8" ?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:element name="shiporder">
<xs:complexType>
<xs:sequence>
<xs:element name="orderperson" type="xs:string"/>
<xs:element name="shipto">
<xs:complexType>
<xs:sequence>
<xs:element name="name" type="xs:string"/>
<xs:element name="address" type="xs:string"/>
<xs:element name="city" type="xs:string"/>
</xs:sequence>
</xs:complexType>
</xs:element>
<xs:element name="item" maxOccurs="unbounded">
<xs:complexType>
<xs:sequence>
<xs:element name="title" type="xs:string"/>
<xs:element name="note" type="xs:string" minOccurs="0"/>
<xs:element name="quantity" type="xs:positiveInteger"/>
<xs:element name="price" type="xs:decimal"/>
</xs:sequence>
</xs:complexType>
</xs:element>
</xs:sequence>
<xs:attribute name="orderid" type="xs:string" use="required"/>
</xs:complexType>
</xs:element>
</xs:schema>
Divide the Schema
XML SCHEMA
Here is the new design of the schema file ("shiporder.xsd"):

<?xml version="1.0" encoding="UTF-8" ?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">

<xs:element name="orderperson" type="xs:string"/>
<xs:element name="name" type="xs:string"/>
<xs:element name="address" type="xs:string"/>
<xs:element name="city" type="xs:string"/>
<xs:element name="title" type="xs:string"/>
<xs:element name="note" type="xs:string"/>
<xs:element name="quantity" type="xs:positiveInteger"/>
<xs:element name="price" type="xs:decimal"/>

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

<xs:element name="shipto">
<xs:complexType>
<xs:sequence>
<xs:element ref="name"/>
<xs:element ref="address"/>
<xs:element ref="city"/>
<xs:element ref="country"/>
</xs:sequence>
</xs:complexType>
</xs:element>
<xs:element name="item">
<xs:complexType>
<xs:sequence>
<xs:element ref="title"/>
<xs:element ref="note" minOccurs="0"/>
<xs:element ref="quantity"/>
<xs:element ref="price"/>
</xs:sequence>
</xs:complexType>
</xs:element>
<xs:element name="shiporder">
<xs:complexType>
<xs:sequence>
<xs:element ref="orderperson"/>
<xs:element ref="shipto"/>
<xs:element ref="item" maxOccurs="unbounded"/>
14
XML SCHEMA
15
</xs:sequence>
<xs:attribute ref="orderid" use="required"/>
</xs:complexType>
</xs:element>
</xs:schema>
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"/>
An element in your document might look like this:
<prize disabled="true">999</prize>
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"/>
An element in your document might look like this:
<pic src="http://www.w3schools.com/images/smiley.gif" />
Note: If a URI has spaces, replace them with %20.
UNION: Definition and Usage

The union element defines a simple type as a collection (union) of values from specified simple
data types. 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)
XML SCHEMA
16
Attribute
Description
id
Optional. Specifies a unique ID for the element
memberTypes
Optional. Specifies a list of built-in data types or simpleType elements defined in a sche
any attributes
Optional. Specifies any other attributes with non-schema namespace
This example shows a simple type that is a union of two simple types:
<xs:element name="jeans_size">
<xs:simpleType>
<xs:union memberTypes="sizebyno sizebystring" />
</xs:simpleType>
</xs:element>
<xs:simpleType name="sizebyno">
<xs:restriction base="xs:positiveInteger">
<xs:maxInclusive value="42"/>
</xs:restriction>
</xs:simpleType>
<xs:simpleType name="sizebystring">
<xs:enumeration value="small"/>
<xs:enumeration value="medium"/>
<xs:enumeration value="large"/>
</xs:restriction>
</xs:simpleType>

A DTD File: XML Schema 1

Uploaded by

Copyright:

Available Formats

A DTD File: XML Schema 1

Uploaded by

Document Information

Original Description:

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

A DTD File: XML Schema 1

Uploaded by

Copyright:

Available Formats

XML SCHEMA

XML documents can have a reference to a

What is a Simple Element?

How to Define an Attribute?

Here is an XML element with an attribute:

Default and Fixed Values for Attributes

Optional and Required Attributes

<xs:element name="car" type="carType"/>

The example above could also have been

letter followed by an upper case letter. For

occurrences of lowercase letters from a to z:

ex, "sToP" will be validated, but not

The acceptable value is one or more pairs of

Restrictions on Whitespace Characters

The following schema declares the "letter"

An XML element, "letter", that contains

both text and other elements:

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

<xs:element name="full_name" type="xs:strin

The <minOccurs> indicator specifies the

<xs:element name="full_name" type="xs:strin

Tip: To allow an element to appear an unlimited number of times, use the

An XML file called "Myfamily.xml":

XSD The <any> Element

Let's have a look at this XML document called "shiporder.xml":

Create an XML Schema "shiporder.xsd":

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

hexBinary (hexadecimal-encoded binary data)

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

UNION: Definition and Usage

Optional. Specifies a unique ID for the element

Optional. Specifies any other attributes with non-schema namespace

You might also like