XML schema used for defining the restriction on XML data structure. It is adding the highly validated data structure and useful for defining the types for the data in XML files. In a normal practice, first a developer creates a XSD (schema) with validations or enforcement for the XML structure, later all the XML files created will use that XSD for validating the rules. In some scenarios, we have a valid XML file and we need to create a schema file for that XML structure. This tutorial explains how to create a XSD file using existing XML file. We will use a tool called trang for achieving this.

Download Trang

It is an open source API for working with XML files. One of the functionality it offers is to generate a XSD file using XML file. You can download the JAR file from here.

[code]
//java -jar <trang JAR file path> <XML file name> <XSD file name>
java -jar D:/trang.jar Sample.xml Sample.xsd
[/code]

I have used the below sample XML and XSD files for this tutorial. If you have any questions, please write it in the comments section.

XML File

[code lang=”xml”]
<?xml version="1.0" encoding="UTF-8"?>
<company>
<branch>
<employee id="001">
<name>Name 1</name>
<designation>Engineer</designation>
</employee>
<employee id="002">
<name>Name 2</name>
<designation>Engineer</designation>
</employee>
</branch>
</company>
[/code]

Generate XML Schema

[code lang=”xml”]
<?xml version="1.0" encoding="UTF-8"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" elementFormDefault="qualified">
<xs:element name="company">
<xs:complexType>
<xs:sequence>
<xs:element ref="branch"/>
</xs:sequence>
</xs:complexType>
</xs:element>
<xs:element name="branch">
<xs:complexType>
<xs:sequence>
<xs:element maxOccurs="unbounded" ref="employee"/>
</xs:sequence>
</xs:complexType>
</xs:element>
<xs:element name="employee">
<xs:complexType>
<xs:sequence>
<xs:element ref="name"/>
<xs:element ref="designation"/>
</xs:sequence>
<xs:attribute name="id" use="required" type="xs:integer"/>
</xs:complexType>
</xs:element>
<xs:element name="name" type="xs:string"/>
<xs:element name="designation" type="xs:NCName"/>
</xs:schema>
[/code]

Complex Elements

Complex elements are those which contain other elements as children or these elements have attributes. Empty elements and elements containing only text are also considered complex. The following is an examples of complex element

[code lang=”xml”]
<employee grade="senior">
<id>745821</id>
<empName>Tim</empName>
<salary>35000</salary>
<domain>Insurance</domain>
</employee>
[/code]

Define Complex Type in XML schema

Complex types can be defined in XML schema as demonstrated in this example:

[code lang=”xml”]
<xs:element name="employee">
<xs:complexType>
<xs:sequence>
<xs:element name="id" type="xs:string"/>
<xs:element name="empName" type="xs:string"/>
<xs:element name="salary" type="xs:string"/>
<xs:element name="domain" type="xs:string"/>
</xs:sequence>
</xs:complexType>
</xs:element>
[/code]

Define empty elements

Consider the following XML element:

[code lang=”xml”]
<employee empId="157117" />
[/code]

This empty element can be defined in XML schema as follows:

[code lang=”xml”]
<xs:element name="employee">
<xs:complexType>
<xs:attribute name="empId" type="xs:positiveInteger"/>
</xs:complexType>
</xs:element>
[/code]

Here we can see that in the definition we dont define any child elements. We just define the attribute.

Define text only elements

Consider the following XML element:

[code lang=”xml”]
<domain>BFS</domain>
[/code]

The above element can be defined in XML schema as follows:

[code lang=”xml”]
<xs:element name="domain">
<xs:complexType>
<xs:simpleContent>
<xs:extension base="xs:string" />
</xs:simpleContent>
</xs:complexType>
</xs:element>
[/code]

Here, we define that the content of the complex type is simple. In schema terms simple means plain text. The xs:extension is used to declare the type of the data.

Define Mixed Content

Sometimes an XML element can contain elements and text combined. Consider the following example:

[code lang=”xml”]
<employeeInfo>
The employee <id>134567</id>
belongs to <domain>BFS</domain>
and his salary is <salary>56430</salary>
</employeeInfo>
[/code]

The above fragment can be defined in XML schema as follows:

[code lang=”xml”]
<xs:element name="employeeInfo">
<xs:complexType mixed="true">
<xs:sequence>
<xs:element name="id" type="xs:positiveInteger"/>
<xs:element name="domain" type="xs:string"/>
<xs:element name="salary" type="xs:positiveInteger"/>
</xs:sequence>
</xs:complexType>
</xs:element>
[/code]

In the defined XML schema we use the attribute mixed and set its value as true. This indicates that the XML element can contain other elements and simple text as it children

XSD Indicators

Using XSD Indicator a desicion can be made about how to use Complex types elements in a XML document. The indicators are basically divided into three groups :

• Order indicators
• Occurrence indicators
• Group indicators

Let us know look at each of these categories.

Order Indicators

The order indicators define the ordering of the elements or the sequence in which the elements appear in the XML document. This group of indicators has three types of indicators :

• All
• Choice
• Sequence

All

Using the All indicator allows the child elements to appear in any order. However, it sets a restriction that each child must appear only once. Lets look at an example :

[code lang=”xml”]
<xs:element name="employee">
<xs:complexType>
<xs:all>
<xs:element name="empId" type="xs:string"/>
<xs:element name="name" type="xs:string"/>
<xs:element name="salary" type="xs:integer"/>
<xs:element name="domain" type="xs:string"/>
</xs:all>
</xs:complexType>
</xs:element>
[/code]

Choice

The Choice indicators specifies that out of all the child elements one can appear. Lets look at an example:

[code lang=”xml”]
<xs:element name="employee">
<xs:complexType>
<xs:choice>
<xs:element name="manager" type="manager"/>
<xs:element name="member" type="member"/>
</xs:choice>
</xs:complexType>
</xs:element>
[/code]

Sequence

This indicator specfies that the child elements should follow the specified order :

[code lang=”xml”]
<xs:element name="employee">
<xs:complexType>
<xs:sequence>
<xs:element name="empId" type="xs:string"/>
<xs:element name="name" type="xs:string"/>
<xs:element name="salary" type="xs:integer"/>
<xs:element name="domain" type="xs:string"/>
</xs:sequence>
</xs:complexType>
</xs:element>
[/code]

Occurrence Indicators

The occurrence indiactor defines the number of times an element can appear. This group has two differetn types:

• maxOccurs
• minOccurs

maxOccurs

The maxOccurs element sets an upper limit on the number of times an element can upper. Lets looks at an example:

[code lang=”xml”]
<xs:element name="employee">
<xs:complexType>
<xs:sequence>
<xs:element name="empId" type="xs:string"/>
<xs:element name="name" type="xs:string"/>
<xs:element name="salary" type="xs:integer"/>
<xs:element name="domain" type="xs:string"/>
<xs:element name="project" type="xs:string" maxOccurs="10"/>
</xs:sequence>
</xs:complexType>
</xs:element>
[/code]

minOccurs

The minOccurs element sets the lower imit on the number of times an element can upper. Lets looks at an example:

[code lang=”xml”]
<xs:element name="employee">
<xs:complexType>
<xs:sequence>
<xs:element name="empId" type="xs:string"/>
<xs:element name="name" type="xs:string"/>
<xs:element name="salary" type="xs:integer"/>
<xs:element name="domain" type="xs:string"/>
<xs:element name="project" type="xs:string" maxOccurs="10" minOccurs="0"/>
</xs:sequence>
</xs:complexType>
</xs:element>
[/code]

Group Indicators

Group indicators allow us to define a group of elements

• Group name
• attributeGroup name

Group Name

The group indicator is used to define a group of elements. Once defined the group can be referenced in other places within the XML schema. Lets look at an example :

[code lang=”xml”]
<xs:group name="projectGroup">
<xs:sequence>
<xs:element name="projectname" type="xs:string"/>
<xs:element name="technology" type="xs:string"/>
</xs:sequence>
</xs:group>
[/code]

In the above example we define a group named projectGroup. Now we will see how to refer this group in other places :

[code lang=”xml”]
<xs:element name="employee">
<xs:complexType>
<xs:sequence>
<xs:element name="empId" type="xs:string"/>
<xs:element name="name" type="xs:string"/>
<xs:element name="salary" type="xs:integer"/>
<xs:element name="domain" type="xs:string"/>
<xs:group ref="projectGroup"/>
</xs:sequence>
</xs:complexType>
</xs:element>
[/code]

After making a reference to the projectGroup the employee element gets a total of six child elements:
empId, name, salary, domain, projectname, technology.

Attribute Groups

The attribute group is used to group together a set of attributes. Once defined the group can be referenced in other elements to define the attributes for a element. Lets look at an example :

[code lang=”xml”]
<xs:attributeGroup name="empAttrGroup">
<xs:attribute name="designation" type="xs:string"/>
</xs:attributeGroup>

<xs:complexType name="employee">
<xs:attributeGroup ref="empAttrGroup"/>
</xs:complexType>

[/code]

The Element
With the use of the any element an XML schema can can extend another XML schema. Lets look at an example :

Filename : employee.xsd
[code lang=”xml”]
<xs:element name="employee">
<xs:complexType>
<xs:sequence>
<xs:element name="empId" type="xs:positiveinteger"/>
<xs:element name="name" type="xs:string"/>
<xs:element name="salary" type="xs:positiveinteger"/>
<xs:element name="domain" type="xs:string"/>
<xs:any minOccurs="0"/>
</xs:sequence>
</xs:complexType>
</xs:element>
[/code]

Filename : children.xsd

[code lang=”xml”]
<xs:element name="project">
<xs:complexType>
<xs:sequence>
<xs:element name="projectName" type="xs:string" />
<xs:element name="technologyUsed" type="xs:string" />
</xs:sequence>
</xs:complexType>
</xs:element>
[/code]

The XML file can use components from both the files:

[code lang=”xml”]
<employee>
<empId>143233</empId>
<name>John</name>
<salary>34500</salary>
<domain>Insurance</domain>
<project>
<projectName>ISD</projectName>
<technologyUsed>.NET</technologyUsed>
</project>
</employee>
[/code]

XSD Data Types

String
The string data type is used to store characters and strings. For e.g:

[code lang=”xml”]
<table border="1">
<tr>
<td>XML Schema</td>
<td><xs:element name="name" type="xs:string"/></td>
</tr>
<tr>
<td>XML</td>
<td><name>John</name></td>
</tr>
</table>
[/code]

Date

The date type represents a date. The date represented by using the date datatype is specified in the following format : YYYY-MM-DD.
For e.g:

[code lang=”xml”]
<table border="1">
<tr>
<td>XML Schema</td>
<td><xs:element name="joiningDate" type="xs:date"/>
</td>
</tr>
<tr>
<td>XML</td>
<td><joiningDate>2007-03-27</joiningDate></td>
</tr>
</table>
[/code]

Numeric
The numeric data types are of two types:

• Decimal

The decimal data type is used to represent decimal numbers. For e.g:
[code lang=”xml”]
<table border="1">
<tr>
<td>XML Schema</td>
<td><xs:element name="price" type="xs:decimal"/></td>
</tr>
<tr>
<td>XML</td>
<td><price>678.50</price></td>
</tr>
</table>
[/code]

• Integer

The integer data type is used to represent integers. For e.g:
[code lang=”xml”]
<table border="1">
<tr>
<td>XML Schema</td>
<td><xs:element name="salary" type="xs:integer"/></td>
</tr>
<tr>
<td>XML</td>
<td><salary>678.50</salary></td>
</tr>
</table>
[/code]

Other Datatypes

• Boolean

The boolean datatype represents the value true or false.E.g:

XML Schema
XML	John

[Note: If one wants to test these examples then you should have a suitable XML editor. By simply copying the files in your system and executing them in the browser wont produce the expected output.]

also read:

• XML Tutorials
• How to Parse XML file using DOM Parser?
• How to Parse XML file using SAX Parser?

XML schema is a language for describing the contents and structure of a XML document. It basically creates a blue print of the actual XML document by describing everything about the elements which can appear in the document. By creating a XML schema we make the XML document conform to the rules defined in the XML schema. It essentially says that the XML document cant break the rules defined in the XML schema document.

also read:

• XML Tutorials
• How to Parse XML file using DOM Parser?
• How to Parse XML file using SAX Parser?

Lets create a sample XML schema document empSchema.xsd:
[code lang=”xml”]
<?xml version="1.0" encoding="ISO-8859-1" ?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:element name="employee">
<xs:complexType>
<xs:sequence>
<xs:element name="id" type="xs:string"/>
<xs:element name="empName" type="xs:string"/>
<xs:element name="salary" type="xs:string"/>
<xs:element name="domain" type="xs:string"/>
</xs:sequence>
</xs:complexType>
</xs:element>
</xs:schema>
[/code]

Lets create a XML document employee.xml:
[code lang=”xml”]
<?xml version="1.0"?>
<employee
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:noNamespaceSchemaLocation="empSchema.xsd">
<id>745821</id>
<empName>Tim</empName>
<salary>35000</salary>
<domain>Insurance</domain>
</employee>
[/code]

In the XML document above we see that the document is referring to a XSD document[xsi:noNamespaceSchemaLocation=”empSchema.xsd”]. XSD is nothing but a file which defines XML schema.
I will explain the details of the XML schema document as we go along. The above example is just supposed to give you a feel of what an XML schema looks like and how to refer to the XSD from a XML file.

XML Schema Elements

schema

Every XML schema starts with element as the root. The attribute xmlns:xs=”http://www.w3.org/2001/XMLSchema” says that the elements in the XML document belong to the “http://www.w3.org/2001/XMLSchema” namespace and each of the elements that belong to this namespace should be prefixed with the xs.

Simple Type

A simple type element cannot contain any other elements or attributes. It can contain only text data. For E.g:
[code lang=”xml”]
<table>
<tr>
<td>Syntax:</td>
<td><xs:element name="element-name" type="data-type"/></td>
</tr>
<tr>
<td>XML Schema:</td>
<td><xs:element name="empName" type="xs:string"/></td>
</tr>
<tr>
<td>XML:</td>
<td><empName>Daniel</empName></td>
</tr>
</table>
[/code]
The allowed datatypes in XML schema are :

xs:string

xs:decimal

xs:integer

xs:boolean

xs:date

xs:time

Attributes

An attribute provides additional information about the element. Simple types cannot have attributes. However the attribute itself are of type simple. Let us now look at the syntax and an example of how to define attributes in XML Schema:
[code lang=”xml”]
<table>
<tr>
<td>Syntax:</td>
<td><xs:attribute name="attribute-name" type="data-type"/></td>
</tr>
<tr>
<td>XML Schema:</td>
<td><xs:attribute name="grade" type="xs:string"/></td>
</tr>
<tr>
<td>XML:</td>
<td><employee grade="senior">Daniel</employee></td>
</tr>
</table>
[/code]

Content Restrictions

When an element or an attribute is defined with a particular data type, it essentially means that the element or attribute cant be assigned a value which is of some other type. In XML schema we can define custom restrictions on elements. Such restrictions are called facets.

• Value restrictions

Using value restrictions the XML schema places a restriction that the value of the element should be between a allowed range.In the following example element a restriction is placed on the salary element that its value cannot be less that zero and more than 85000.
In case it happens then the XML document will not validate:
[code lang=”xml”]
<xs:element name="salary">
<xs:simpleType>
<xs:restriction base="xs:integer">
<xs:minInclusive value="0"/>
<xs:maxInclusive value="85000"/>
</xs:restriction>
</xs:simpleType>
</xs:element>
[/code]

• Restriction on a set

In set restriction the value of an element should be set from only an allowed set of values. In the following example the value of the domain element is limited to a certain set of values:
[code lang=”xml”]
<xs:element name="domain">
<xs:simpleType>
<xs:restriction base="xs:string">
<xs:enumeration value="BFS"/>
<xs:enumeration value="Insurance"/>
<xs:enumeration value="Manlog"/>
<xs:enumeration value="Life Sciences"/>
</xs:restriction>
</xs:simpleType>
</xs:element>
[/code]

• Restriction on a series

In such type of restriction we can use any valid regular expression syntax to define the restrictions. In the following example we define a restriction that the number should be between 0 and 9.
[code lang=”xml”]
<xs:element name="number">
<xs:simpleType>
<xs:restriction base="xs:string">
<xs:pattern value="[0-9]"/>
</xs:restriction>
</xs:simpleType>
</xs:element>
[/code]

• Restriction on a whitespace characters

These restrictions define how the whitespace characters are handled in the XML document. The restriction can be placed using the following syntax:
[code lang=”xml”]
<xs:whiteSpace value="preserve"/>
or
<xs:whiteSpace value="replace"/>
[/code]
The attribute value preserve says that the whitespace characters will not be removed by the XML processor. The attribute value replace says that the following characters will be replaced by spaces :
line feeds, tabs, spaces, and carriage returns. Lets looks at an example now :
[code lang=”xml”]
<xs:element name="feedback"/>
<xs:simpleType>
<xs:restriction base="xs:string"/>
<xs:whiteSpace value="preserve"/>
</xs:restriction/>
</xs:simpleType/>
</xs:element/>
[/code]

• Restriction on the length

This places a restriction on the allowed numbers of characters. The following example places a restriction that the employee id cannot be more than 6 characters
[code lang=”xml”]
<xs:element name="empId">
<xs:simpleType>
<xs:restriction base="xs:integer">
<xs:length value="6"/>
</xs:restriction>
</xs:simpleType>
</xs:element>
[/code]