Xml material

XML
XML stands for eXtensible Markup Language.
XML is designed to transport and store data.
XML is important to know, and very easy to learn.
HTML was designed to display data.
What You Should Already Know
Before you continue you should have a basic understanding of the following:
 HTML
 JavaScript
What is XML?
 XML stands for EXtensible Markup Language
 XML is a markup language much like HTML
 XML was designed to carry data, not to display data
 XML tags are not predefined. You must define your own tags
 XML is designed to be self-descriptive
 XML is a W3C Recommendation
W3C Stands for the World Wide Web Consortium.
The Difference Between XML and HTML
XML is not a replacement for HTML.
XML and HTML were designed with different goals:
 XML was designed to transport and store data, with focus on what data is
 HTML was designed to display data, with focus on how data looks
HTML is about displaying information, while XML is about carrying information
SOA SOLUTIONS, Near S.R Nagar E Seva, Ph no 9030118861

XML Does Not DO Anything
Maybe it is a little hard to understand, but XML does not DO anything. XML was created to
structure, store, and transport information.
The following example is a note to Tove, from Jani, stored as XML:
<note>
<to>Tove</to>
<from>Jani</from>
<heading>Reminder</heading>
<body>Don't forget me this weekend!</body>
</note>
The note above is quite self descriptive. It has sender and receiver information, it also has a
heading and a message body.
But still, this XML document does not DO anything. It is just information wrapped in tags.
Someone must write a piece of software to send, receive or display it.
With XML You Invent Your Own Tags
The tags in the example above (like <to> and <from>) are not defined in any XML standard.
These tags are "invented" by the author of the XML document.
That is because the XML language has no predefined tags.
The tags used in HTML are predefined. HTML documents can only use tags defined in the
HTML standard (like <p>, <h1>, etc.).
XML allows the author to define his/her own tags and his/her own document structure.
XML is Not a Replacement for HTML
XML is a complement to HTML.
It is important to understand that XML is not a replacement for HTML. In most web
applications, XML is used to transport data, while HTML is used to format and display the data.
My best description of XML is this:
XML is a software- and hardware-independent tool for carrying information.

XML is a W3C Recommendation
XML became a W3C Recommendation on February 10, 1998.
XML is Everywhere
XML is now as important for the Web as HTML was to the foundation of the Web.
XML is the most common tool for data transmissions between all sorts of applications.
How Can XML be Used?
XML is used in many aspects of web development, often to simplify data storage and sharing.
XML Separates Data from HTML
If you need to display dynamic data in your HTML document, it will take a lot of work to edit
the HTML each time the data changes.
With XML, data can be stored in separate XML files. This way you can concentrate on using
HTML for layout and display, and be sure that changes in the underlying data will not require
any changes to the HTML.
With a few lines of JavaScript code, you can read an external XML file and update the data
content of your web page.
XML Simplifies Data Sharing
In the real world, computer systems and databases contain data in incompatible formats.
XML data is stored in plain text format. This provides a software- and hardware-independent
way of storing data.
This makes it much easier to create data that can be shared by different applications

XML Simplifies Data Transport
One of the most time-consuming challenges for developers is to exchange data between
incompatible systems over the Internet.
Exchanging data as XML greatly reduces this complexity, since the data can be read by different
incompatible applications.
XML Simplifies Platform Changes
Upgrading to new systems (hardware or software platforms), is always time consuming. Large
amounts of data must be converted and incompatible data is often lost.
XML data is stored in text format. This makes it easier to expand or upgrade to new operating
systems, new applications, or new browsers, without losing data.
XML Makes Your Data More Available
Different applications can access your data, not only in HTML pages, but also from XML data
sources.
With XML, your data can be available to all kinds of "reading machines" (Handheld computers,
voice machines, news feeds, etc), and make it more available for blind people, or people with
other disabilities.
XML is Used to Create New Internet Languages
A lot of new Internet languages are created with XML.
Here are some examples:
 XHTML
 WSDL for describing available web services
 WAP and WML as markup languages for handheld devices
 RSS languages for news feeds
 RDF and OWL for describing resources and ontology
 SMIL for describing multimedia for the web
If Developers Have Sense
If they DO have sense, future applications will exchange their data in XML.
The future might give us word processors, spreadsheet applications and databases that can read
each other's data in XML format, without any conversion utilities in between.

XML documentsformatree structure that starts at "the root" and branchesto "the leaves".
An Example XML Document
XML documents use a self-describing and simple syntax:
<?xml version="1.0" encoding="ISO-8859-1"?>
<note>
<to>Tove</to>
<from>Jani</from>
</note>
The first line is the XML declaration. It defines the XML version (1.0) and the encoding used
(ISO-8859-1 = Latin-1/West European character set).
The next line describes the root element of the document (like saying: "this document is a
note"):
<note>
The next 4 lines describe 4 child elements of the root (to, from, heading, and body):
<to>Tove</to>
<from>Jani</from>
And finally the last line defines the end of the root element:
</note>
You can assume, from this example, that the XML document contains a note to Tove from Jani.
Don't you agree that XML is pretty self-descriptive?
XML Documents Form a Tree Structure
XML documents must contain a root element. This element is "the parent" of all other elements.
The elements in an XML document form a document tree. The tree starts at the root and
branches to the lowest level of the tree.

All elements can have sub elements (child elements):
<root>
<child>
<subchild>.....</subchild>
</child>
</root>
The terms parent, child, and sibling are used to describe the relationships between elements.
Parent elements have children. Children on the same level are called siblings (brothers or sisters).
All elements can have text content and attributes (just like in HTML).
Example:
The image above represents one book in the XML below:
<bookstore>
<book category="COOKING">
<title lang="en">Everyday Italian</title>
<author>Giada De Laurentiis</author>
<year>2005</year>
<price>30.00</price>
</book>
<book category="CHILDREN">
<title lang="en">Harry Potter</title>
<author>J K. Rowling</author>
<year>2005</year>
</book>

<book category="WEB">
<title lang="en">Learning XML</title>
<author>Erik T. Ray</author>
<year>2003</year>
</book>
</bookstore>
The root element in the example is <bookstore>. All <book> elements in the document are
contained within <bookstore>.
The <book> element has 4 children: <title>,< author>, <year>, <price>.
XML Syntax Rules
The syntax rules of XML are very simple and logical. The rules are easy to learn, and easy to
use.
All XML Elements Must Have a Closing Tag
In HTML, some elements do not have to have a closing tag:
<p>This is a paragraph.
<br>
In XML, it is illegal to omit the closing tag. All elements must have a closing tag:
<p>This is a paragraph.</p>
<br />
Note: You might have noticed from the previous example that the XML declaration did not have
a closing tag. This is not an error. The declaration is not a part of the XML document itself, and
it has no closing tag.
XML Tags are Case Sensitive
XML tags are case sensitive. The tag <Letter> is different from the tag <letter>.
Opening and closing tags must be written with the same case:
<Message>This is incorrect</message>
<message>This is correct</message>

Note: "Opening and closing tags" are often referred to as "Start and end tags". Use whatever you
prefer. It is exactly the same thing.
XML Elements Must be Properly Nested
In HTML, you might see improperly nested elements:
<b><i>This text is bold and italic</b></i>
In XML, all elements must be properly nested within each other:
<b><i>This text is bold and italic</i></b>
In the example above, "Properly nested" simply means that since the <i> element is opened
inside the <b> element, it must be closed inside the <b> element.
XML Documents Must Have a Root Element
XML documents must contain one element that is the parent of all other elements. This element
is called the root element.
<root>
<child>
<subchild>.....</subchild>
</child>
</root>
XML Attribute Values Must be Quoted
XML elements can have attributes in name/value pairs just like in HTML.
In XML, the attribute values must always be quoted.
Study the two XML documents below. The first one is incorrect, the second is correct:
<note date=12/11/2007>
<to>Tove</to>
<from>Jani</from>
</note>
<note date="12/11/2007">
<to>Tove</to>
<from>Jani</from>
</note>

The error in the first document is that the date attribute in the note element is not quoted.
Entity References
Some characters have a special meaning in XML.
If you place a character like "<" inside an XML element, it will generate an error because the
parser interprets it as the start of a new element.
This will generate an XML error:
<message>if salary < 1000 then</message>
To avoid this error, replace the "<" character with an entity reference:
<message>if salary < 1000 then</message>
There are 5 predefined entity references in XML:
< < less than
> > greater than
& & ampersand
' ' apostrophe
" " quotation mark
Note: Only the characters "<" and "&" are strictly illegal in XML. The greater than character is
legal, but it is a good habit to replace it.
Comments in XML
The syntax for writing comments in XML is similar to that of HTML.

White-space is Preserved in XML
HTML truncates multiple white-space characters to one single white-space:
HTML: Hello Tove
Output: Hello Tove
With XML, the white-space in a document is not truncated.

XML Stores New Line as LF
In Windows applications, a new line is normally stored as a pair of characters: carriage return
(CR) and line feed (LF). In Unix applications, a new line is normally stored as an LF character.
Macintosh applications also use an LF to store a new line.
XML stores a new line as LF.
XML Elements
An XML documentcontainsXML Elements.
What is an XML Element?
An XML element is everything from (including) the element's start tag to (including) the
element's end tag.
An element can contain:
 other elements
 text
 attributes
 or a mix of all of the above...
<bookstore>
<title>Harry Potter</title>
<year>2005</year>
</book>
<title>Learning XML</title>
<year>2003</year>
</book>
</bookstore>
In the example above, <bookstore> and <book> have element contents, because they contain
other elements. <book> also has an attribute (category="CHILDREN"). <title>, <author>,
<year>, and <price> have text content because they contain text.

XML Naming Rules
XML elements must follow these naming rules:
 Names can contain letters, numbers, and other characters
 Names cannot start with a number or punctuation character
 Names cannot start with the letters xml (or XML, or Xml, etc)
 Names cannot contain spaces
Any name can be used, no words are reserved.
Best Naming Practices
Make names descriptive. Names with an underscore separator are nice: <first_name>,
<last_name>.
Names should be short and simple, like this: <book_title> not like this: <the_title_of_the_book>.
Avoid "-" characters. If you name something "first-name," some software may think you want to
subtract name from first.
Avoid "." characters. If you name something "first.name," some software may think that "name"
is a property of the object "first."
Avoid ":" characters. Colons are reserved to be used for something called namespaces (more
later).
XML documents often have a corresponding database. A good practice is to use the naming rules
of your database for the elements in the XML documents.
Non-English letters like éòá are perfectly legal in XML, but watch out for problems if your
software vendor doesn't support them.
XML Elements are Extensible
XML elements can be extended to carry more information.
Look at the following XML example:
<note>
<to>Tove</to>
<from>Jani</from>
</note>

Let's imagine that we created an application that extracted the <to>, <from>, and <body>
elements from the XML document to produce this output:
MESSAGE
To: Tove
From: Jani
Don't forget me this weekend!
Imagine that the author of the XML document added some extra information to it:
<note>
<date>2008-01-10</date>
<to>Tove</to>
<from>Jani</from>
</note>
Should the application break or crash?
No. The application should still be able to find the <to>, <from>, and <body> elements in the
XML document and produce the same output.
One of the beauties of XML, is that it can be extended without breaking applications.
XML Attributes
XML elements can have attributes, just like HTML.
Attributes provide additional information about an element.
XML Attributes
In HTML, attributes provide additional information about elements:
<img src="computer.gif">
<a href="demo.asp">

Attributes often provide information that is not a part of the data. In the example below, the file
type is irrelevant to the data, but can be important to the software that wants to manipulate the
element:
<file type="gif">computer.gif</file>
XML Attributes Must be Quoted
Attribute values must always be quoted. Either single or double quotes can be used. For a
person's sex, the person element can be written like this:
<person sex="female">
or like this:
<person sex='female'>
If the attribute value itself contains double quotes you can use single quotes, like in this example:
<gangster name='George "Shotgun" Ziegler'>
or you can use character entities:
<gangster name="George "Shotgun" Ziegler">
XML Elements vs. Attributes
Take a look at these examples:
<person sex="female">
<firstname>Anna</firstname>
<lastname>Smith</lastname>
</person>
<person>
<sex>female</sex>
<firstname>Anna</firstname>
</person>
In the first example sex is an attribute. In the last, sex is an element. Both examples provide the
same information.
There are no rules about when to use attributes or when to use elements. Attributes are handy in
HTML. In XML my advice is to avoid them. Use elements instead.

My Favorite Way
The following three XML documents contain exactly the same information:
A date attribute is used in the first example:
<note date="10/01/2008">
<to>Tove</to>
<from>Jani</from>
</note>
A date element is used in the second example:
<note>
<date>10/01/2008</date>
<to>Tove</to>
<from>Jani</from>
</note>
An expanded date element is used in the third: (THIS IS MY FAVORITE):
<note>
<date>
<day>10</day>
<month>01</month>
<year>2008</year>
</date>
<to>Tove</to>
<from>Jani</from>
</note>
Avoid XML Attributes?
Some of the problems with using attributes are:
 attributes cannot contain multiple values (elements can)
 attributes cannot contain tree structures (elements can)
 attributes are not easily expandable (for future changes)

Attributes are difficult to read and maintain. Use elements for data. Use attributes for information
that is not relevant to the data.
Don't end up like this:
<note day="10" month="01" year="2008"
to="Tove" from="Jani" heading="Reminder"
body="Don't forget me this weekend!">
</note>
XML Attributes for Metadata
Sometimes ID references are assigned to elements. These IDs can be used to identify XML
elements in much the same way as the id attribute in HTML. This example demonstrates this:
<messages>
<note id="501">
<to>Tove</to>
<from>Jani</from>
</note>
<note id="502">
<to>Jani</to>
<from>Tove</from>
<heading>Re: Reminder</heading>
<body>I will not</body>
</note>
</messages>
The id attributes above are for identifying the different notes. It is not a part of the note itself.
What I'm trying to say here is that metadata (data about data) should be stored as attributes, and
the data itself should be stored as elements.
XML Validation
XML with correct syntax is "Well Formed" XML.
XML validated against a DTD is "Valid" XML.
Well Formed XML Documents
A "Well Formed" XML document has correct XML syntax.

The syntax rules were described in the previous chapters:
 XML documents must have a root element
 XML elements must have a closing tag
 XML tags are case sensitive
 XML elements must be properly nested
 XML attribute values must be quoted
<note>
<to>Tove</to>
<from>Jani</from>
</note>
Valid XML Documents
A "Valid" XML document is a "Well Formed" XML document, which also conforms to the rules
of a Document Type Definition (DTD):
<!DOCTYPE note SYSTEM "Note.dtd">
<note>
<to>Tove</to>
<from>Jani</from>
</note>
The DOCTYPE declaration in the example above, is a reference to an external DTD file. The
content of the file is shown in the paragraph below.
XML DTD
The purpose of a DTD is to define the structure of an XML document. It defines the structure
with a list of legal elements:
<!DOCTYPE note
[
<!ELEMENT note (to,from,heading,body)>
<!ELEMENT to (#PCDATA)>
<!ELEMENT from (#PCDATA)>
<!ELEMENT heading (#PCDATA)>

<!ELEMENT body (#PCDATA)>
]>
XML Schema
W3C supports an XML-based alternative to DTD, called XML Schema:
<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>
A General XML Validator
To help you check the syntax of your XML files, we have created an XML validator to syntax-
check your XML.
XML Validator
XML Errors Will Stop You
Errors in XML documents will stop your XML applications.
The W3C XML specification states that a program should stop processing an XML document if
it finds an error. The reason is that XML software should be small, fast, and compatible.
HTML browsers will display documents with errors (like missing end tags). HTML browsers are
big and incompatible because they have a lot of unnecessary code to deal with (and display)
HTML errors.
With XML, errors are not allowed.

Syntax-Check Your XML
To help you syntax-check your XML, we have created an XML validator.
Paste your XML into the text area below.and you can validate your XML.
<?xml version="1.0" ?>
<note>
<to>Tove</to>
<from>Jani</Ffrom>
</note>
Note: This only checks if your XML is "Well formed". If you want to validate your XML
against a DTD, see the last paragraph on this page.
Syntax-Check an XML File
You can syntax-check an XML file by typing the URL of the file into the input field below, and
You can check further validated or not.
Filename:
http://www.w3schools.com/xml/note.xml
Validate Your XML Against a DTD
If you know DTD, and you run Internet Explorer, you can validate your XML in the text area
below.
Justadd the DOCTYPE declarationtoyour XML and clickthe "Validate"button:
<?xml version="1.0"?>
<!DOCTYPE note [
<!ELEMENT note (to,from,heading,body)>

<!ELEMENT heading(#PCDATA)>
]>
<note>
<to>Tove</to>
<from>Jani</from>
<message>Don'tforgetme thisweekend!</message>
</note>
XML Namespaces
XML Namespaces provide a method to avoid element name conflicts.
Name Conflicts
In XML, element names are defined by the developer. This often results in a conflict when trying
to mix XML documents from different XML applications.
This XML carries HTML table information:
Name Conflicts
In XML, element names are defined by the developer. This often results in a conflict when trying
to mix XML documents from different XML applications.
<table>
<tr>
<td>Apples</td>
<td>Bananas</td>
</tr>
</table>

This XML carries information about a table (a piece of furniture):
<table>
<name>African Coffee Table</name>
<width>80</width>
<length>120</length>
</table>
If these XML fragments were added together, there would be a name conflict. Both contain a
<table> element, but the elements have different content and meaning.
An XML parser will not know how to handle these differences.
Solving the Name Conflict Using a Prefix
Name conflicts in XML can easily be avoided using a name prefix.
This XML carries information about an HTML table, and a piece of furniture:
<h:table>
<h:tr>
<h:td>Apples</h:td>
<h:td>Bananas</h:td>
</h:tr>
</h:table>
<f:table>
<f:name>African Coffee Table</f:name>
<f:width>80</f:width>
<f:length>120</f:length>
</f:table>
In the example above, there will be no conflict because the two <table> elements have different
names.
XML Namespaces - The xmlns Attribute
When using prefixes in XML, a so-called namespace for the prefix must be defined.
The namespace is defined by the xmlns attribute in the start tag of an element.
The namespace declaration has the following syntax. xmlns:prefix="URI".

<root>
<h:table xmlns:h="http://www.w3.org/TR/html4/">
<h:tr>
<h:td>Apples</h:td>
</h:tr>
</h:table>
<f:table xmlns:f="http://www.w3schools.com/furniture">
</f:table>
</root>
In the example above, the xmlns attribute in the <table> tag give the h: and f: prefixes a qualified
namespace.
When a namespace is defined for an element, all child elements with the same prefix are
associated with the same namespace.
Namespaces can be declared in the elements where they are used or in the XML root element:
<root
xmlns:h="http://www.w3.org/TR/html4/"
xmlns:f="http://www.w3schools.com/furniture">
<h:table>
<h:tr>
<h:td>Apples</h:td>
</h:tr>
</h:table>
<f:table>
</f:table>
</root>

Note: The namespace URI is not used by the parser to look up information.
The purpose is to give the namespace a unique name. However, often companies use the
namespace as a pointer to a web page containing namespace information.
Uniform Resource Identifier (URI)
A Uniform Resource Identifier (URI) is a string of characters which identifies an Internet
Resource.
The most common URI is the Uniform Resource Locator (URL) which identifies an Internet
domain address. Another, not so common type of URI is the Universal Resource Name (URN).
In our examples we will only use URLs.
Default Namespaces
Defining a default namespace for an element saves us from using prefixes in all the child
elements. It has the following syntax:
xmlns="namespaceURI"
<table xmlns="http://www.w3.org/TR/html4/">
<tr>
<td>Apples</td>
<td>Bananas</td>
</tr>
</table>
This XML carries information about a piece of furniture:
<table xmlns="http://www.w3schools.com/furniture">
<name>African Coffee Table</name>
<width>80</width>
<length>120</length>
</table>
Namespaces in Real Use
XSLT is an XML language that can be used to transform XML documents into other formats,
like HTML.
In the XSLT document below, you can see that most of the tags are HTML tags.

The tags that are not HTML tags have the prefix xsl, identified by the namespace
xmlns:xsl="http://www.w3.org/1999/XSL/Transform":
<xsl:stylesheet version="1.0"
xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:template match="/">
<html>
<body>
<h2>My CD Collection</h2>
<table border="1">
<tr>
<th align="left">Title</th>
<th align="left">Artist</th>
</tr>
<xsl:for-each select="catalog/cd">
<tr>
<td><xsl:value-of select="title"/></td>
<td><xsl:value-of select="artist"/></td>
</tr>
</xsl:for-each>
</table>
</body>
</html>
</xsl:template>
</xsl:stylesheet>
XML CDATA
All text in an XML document will be parsed by the parser.
But text inside a CDATA section will be ignored by the parser.
PCDATA - Parsed Character Data
XML parsers normally parse all the text in an XML document.
When an XML element is parsed, the text between the XML tags is also parsed:
<message>This text is also parsed</message>

The parser does this because XML elements can contain other elements, as in this example,
where the <name> element contains two other elements (first and last):
<name><first>Bill</first><last>Gates</last></name>
and the parser will break it up into sub-elements like this:
<name>
<first>Bill</first>
<last>Gates</last>
</name>
Parsed Character Data (PCDATA) is a term used about text data that will be parsed by the XML
parser.
CDATA - (Unparsed) Character Data
The term CDATA is used about text data that should not be parsed by the XML parser.
Characters like "<" and "&" are illegal in XML elements.
"<" will generate an error because the parser interprets it as the start of a new element.
"&" will generate an error because the parser interprets it as the start of an character entity.
Some text, like JavaScript code, contains a lot of "<" or "&" characters. To avoid errors script
code can be defined as CDATA.
Everything inside a CDATA section is ignored by the parser.
A CDATA section starts with "<![CDATA[" and ends with "]]>":
<script>
<![CDATA[
function matchwo(a,b)
{
if (a < b && a < 0) then
{
return 1;
}
else
{
return 0;
}
}

]]>
</script>
In the example above, everything inside the CDATA section is ignored by the parser.
Notes on CDATA sections:
A CDATA section cannot contain the string "]]>". Nested CDATA sections are not allowed.
The "]]>" that marks the end of the CDATA section cannot contain spaces or line breaks.
XML Encoding
ML documents can contain non ASCII characters, like Norwegian æ ø å , or French ê è é.
To avoid errors, specify the XML encoding, or save XML files as Unicode.
XML Encoding Errors
If you load an XML document, you can get two different errors indicating encoding problems:
An invalid character was found in text content.
You get this error if your XML contains non ASCII characters, and the file was saved as single-
byte ANSI (or ASCII) with no encoding specified.
Single byte XML file with encoding attribute.
Same single byte XML file with no encoding attribute.
Switch from current encoding to specified encoding not supported.
You get this error if your XML file was saved as double-byte Unicode (or UTF-16) with a
single-byte encoding (Windows-1252, ISO-8859-1, UTF-8) specified.
You also get this error if your XML file was saved with single-byte ANSI (or ASCII), with
double-byte encoding (UTF-16) specified.
Double byte XML file without encoding.
Same double byte XML file with single byte encoding.

Windows Notepad
Windows Notepad save files as single-byte ANSI (ASCII) by default.
If you select "Save as...", you can specify double-byte Unicode (UTF-16).
Save the XML file below as Unicode (note that the document does not contain any encoding
attribute):
<note>
<from>Jani</from>
<to>Tove</to>
<message>Norwegian: æøå. French: êèé</message>
</note>
The file above, note_encode_none_u.xml will NOT generate an error. But if you specify a
single-byte encoding it will.
The following encoding (open it), will give an error message:
<?xml version="1.0" encoding="windows-1252"?>
<?xml version="1.0" encoding="UTF-8"?>
The following encoding (open it), will NOT give an error:
<?xml version="1.0" encoding="UTF-16"?>
Conclusion
 Always use the encoding attribute
 Use an editor that supports encoding
 Make sure you know what encoding the editor uses
 Use the same encoding in your encoding attribute

Web Services:
Web Services can convert your application into a Web-application, which can publish its
function or message to the rest of the world.
The basic Web Services platform is XML + HTTP.
Web Services can convert your applications into Web-applications.
Web Services are published, found, and used through the Web.
Before you continue, you should have a basic understanding of the following:
 HTML
 XML
What are Web Services?
 Web services are application components
 Web services communicate using open protocols
 Web services are self-contained and self-describing
 Web services can be discovered using UDDI
 Web services can be used by other applications
 XML is the basis for Web services
How Does it Work?
The basic Web services platform is XML + HTTP.
XML provides a language which can be used between different platforms and programming
languages and still express complex messages and functions.
The HTTP protocol is the most used Internet protocol.
Web services platform elements:
 SOAP (Simple Object Access Protocol)
 UDDI (Universal Description, Discovery and Integration)
 WSDL (Web Services Description Language)
Web Services have Two Types of Uses

Reusable application-components.
There are things applications need very often. So why make these over and over again?
Web services can offer application-components like: currency conversion, weather reports, or
even language translation as services.
Connect existing software.
Web services can help to solve the interoperability problem by giving different applications a
way to link their data.
With Web services you can exchange data between different applications and different
platforms.
Web Services have three basic platform elements: SOAP, WSDL and UDDI.
Web Services have three basic platform elements: SOAP, WSDL and UDDI.
What is SOAP?
SOAP is an XML-based protocol to let applications exchange information over HTTP.
Or more simple: SOAP is a protocol for accessing a Web Service.
 SOAP stands for Simple Object Access Protocol
 SOAP is a communication protocol
 SOAP is a format for sending messages
 SOAP is designed to communicate via Internet
 SOAP is platform independent
 SOAP is language independent
 SOAP is based on XML
 SOAP is simple and extensible
 SOAP allows you to get around firewalls
 SOAP is a W3C standard
What is WSDL?
WSDL is an XML-based language for locating and describing Web services.
 WSDL stands for Web Services Description Language
 WSDL is based on XML
 WSDL is used to describe Web services
 WSDL is used to locate Web services
 WSDL is a W3C standard

What is UDDI?
UDDI is a directory service where companies can register and search for Web services.
 UDDI stands for Universal Description, Discovery and Integration
 UDDI is a directory for storing information about web services
 UDDI is a directory of web service interfaces described by WSDL
 UDDI communicates via SOAP
 UDDI is built into the Microsoft .NET platform
Any application can have a Web Service component.
Web Services can be created regardless of programming language.
Web Services Summary
This tutorial has taught you how to convert your applications into web-applications.
You have learned how to use XML to send messages between applications.
You have also learned how to export a function (create a web service) from your application.
Now You Know Web Services, What's Next?
The next step is to learn about WSDL and SOAP.
WSDL
WSDL is an XML-based language for describing Web services and how to access them.
WSDL describes a web service, along with the message format and protocol details for the web
service.
SOAP
SOAP is a simple XML-based protocol that allows applications to exchange information over
HTTP.
Or more simply: SOAP is a protocol for accessing a web service.
WSDL (Web Services DescriptionLanguage)is an XML-based language for
describing Web services andhow to accessthem

WSDL is an XML-based language for describing Web services and how to access them.
 XML
 XML Namespaces
 XML Schema
What is WSDL?
 WSDL stands for Web Services Description Language
 WSDL is written in XML
 WSDL is an XML document
 WSDL is used to describe Web services
 WSDL is also used to locate Web services
 WSDL is a W3C recommendation
WSDL Describes Web Services
WSDL stands for Web Services Description Language.
WSDL is a document written in XML. The document describes a Web service. It specifies the
location of the service and the operations (or methods) the service exposes.
WSDL document is just a simple XML document.
It contains set of definitions to describe a web service.
The WSDL Document Structure
A WSDL document describes a web service using these major elements:
Element Defines
<types> The data types used by the web service
<message> The messages used by the web service
<portType> The operations performed by the web service
<binding> The communication protocols used by the web service

The main structure of a WSDL document looks like this:
<definitions>
<types>
definition of types........
</types>
<message>
definition of a message....
</message>
<portType>
definition of a port.......
</portType>
<binding>
definition of a binding....
</binding>
</definitions>
A WSDL document can also contain other elements, like extension elements, and a service
element that makes it possible to group together the definitions of several web services in one
single WSDL document.
WSDL Ports
The <portType> element is the most important WSDL element.
It describes a web service, the operations that can be performed, and the messages that are
involved.
The <portType> element can be compared to a function library (or a module, or a class) in a
traditional programming language.
WSDL Messages
The <message> element defines the data elements of an operation.
Each message can consist of one or more parts. The parts can be compared to the parameters of a
function call in a traditional programming language.

WSDL Types
The <types> element defines the data types that are used by the web service.
For maximum platform neutrality, WSDL uses XML Schema syntax to define data types.
WSDL Bindings
The <binding> element defines the message format and protocol details for each port.
WSDL Example
This is a simplified fraction of a WSDL document:
<message name="getTermRequest">
<part name="term" type="xs:string"/>
</message>
<message name="getTermResponse">
<part name="value" type="xs:string"/>
</message>
<portType name="glossaryTerms">
<operation name="getTerm">
<input message="getTermRequest"/>
<output message="getTermResponse"/>
</operation>
</portType>
In this example the <portType> element defines "glossaryTerms" as the name of a port, and
"getTerm" as the name of an operation.
The "getTerm" operation has an input message called "getTermRequest" and an output
message called "getTermResponse".
The <message> elements define the parts of each message and the associated data types.
Compared to traditional programming, glossaryTerms is a function library, "getTerm" is a
function with "getTermRequest" as the input parameter, and getTermResponse as the return
parameter.
A WSDL portdescribes the interfaces (legal operations) exposed by a web service.

WSDL Ports
The <portType> element is the most important WSDL element.
It defines a web service, the operations that can be performed, and the messages that are
involved.
The port defines the connection point to a web service. It can be compared to a function library
(or a module, or a class) in a traditional programming language. Each operation can be compared
to a function in a traditional programming language.
Operation Types
The request-response type is the most common operation type, but WSDL defines four types:
Type Definition
One-way The operation can receive a message but will not return a response
Request-response The operation can receive a request and will return a response
Solicit-response The operation can send a request and will wait for a response
Notification The operation can send a message but will not wait for a response
One-Way Operation
A one-way operation example:
<message name="newTermValues">
</message>
<operation name="setTerm">
<input name="newTerm" message="newTermValues"/>
</operation>
</portType >
In the example above, the port "glossaryTerms" defines a one-way operation called "setTerm".
The "setTerm" operation allows input of new glossary terms messages using a "newTermValues"
message with the input parameters "term" and "value". However, no output is defined for the
operation.

Request-Response Operation
A request-response operation example:
<message name="getTermRequest">
</message>
<message name="getTermResponse">
</message>
<operation name="getTerm">
<input message="getTermRequest"/>
<output message="getTermResponse"/>
</operation>
</portType>
In the example above, the port "glossaryTerms" defines a request-response operation called
"getTerm".
The "getTerm" operation requires an input message called "getTermRequest" with a parameter
called "term", and will return an output message called "getTermResponse" with a parameter
called "value".
The binding element has two attributes - name and type.
The name attribute (you can use any name you want) defines the name of the binding, and the
type attribute points to the port for the binding, in this case the "glossaryTerms" port.
The soap: binding element has two attributes - style and transport.
The style attribute can be "rpc" or "document". In this case we use document. The transport
attribute defines the SOAP protocol to use. In this case we use HTTP.
The operation element defines each operation that the port exposes.
For each operation the corresponding SOAP action has to be defined. You must also specify how
the input and output are encoded. In this case we use "literal".

Universal Description, Discovery and Integration (UDDI) is a directory service where businesses
can register and search for Web services.
What is UDDI
UDDI is a platform-independent framework for describing services, discovering businesses, and
integrating business services by using the Internet.
 UDDI stands for Universal Description, Discovery and Integration
 UDDI is a directory for storing information about web services
 UDDI is a directory of web service interfaces described by WSDL
 UDDI communicates via SOAP
 UDDI is built into the Microsoft .NET platform
What is UDDI BasedOn?
UDDI uses World Wide Web Consortium (W3C) and Internet Engineering Task Force (IETF)
Internet standards such as XML, HTTP, and DNS protocols.
UDDI uses WSDL to describe interfaces to web services
Additionally, cross platform programming features are addressed by adopting SOAP, known as
XML Protocol messaging specifications found at the W3C Web site.
UDDI Benefits
Any industry or businesses of all sizes can benefit from UDDI.
Before UDDI, there was no Internet standard for businesses to reach their customers and partners
with information about their products and services. Nor was there a method of how to integrate
into each other's systems and processes.
Problems the UDDI specification can help to solve:
 Making it possible to discover the right business from the millions currently online
 Defining how to enable commerce once the preferred business is discovered
 Reaching new customers and increasing access to current customers
 Expanding offerings and extending market reach
 Solving customer-driven need to remove barriers to allow for rapid participation in the
global Internet economy
 Describing services and business processes programmatically in a single, open, and
secure environment

 How can UDDI be Used
 If the industry published an UDDI standard for flight rate checking and reservation, airlines
could register their services into an UDDI directory. Travel agencies could then search the
UDDI directory to find the airline's reservation interface. When the interface is found, the
travel agency can communicate with the service immediately because it uses a well-defined
reservation interface.

 Who is Supporting UDDI?
 UDDI is a cross-industry effort driven by all major platform and software providers like Dell,
Fujitsu, HP, Hitachi, IBM, Intel, Microsoft, Oracle, SAP, and Sun, as well as a large community
of marketplace operators, and e-business leaders.
 Over 220 companies are members of the UDDI community.
SOAP Tutorial
 SOAP is a simple XML-based protocol to let applications exchange information over
HTTP.
 In our SOAP tutorial, you will learn what SOAP is, and how it uses XML to exchange
information between applications.
SOAP is a simple XML-based protocol to let applications exchange information over HTTP.
Or more simply: SOAP is a protocol for accessing a Web Service.
Before you study SOAP you should have a basic understanding of XML and XML Namespaces.
What is SOAP?
 SOAP stands for Simple Object Access Protocol
 SOAP is a communication protocol
 SOAP is for communication between applications
 SOAP is a format for sending messages
 SOAP communicates via Internet
 SOAP is platform independent
 SOAP is language independent
 SOAP is based on XML
 SOAP is simple and extensible
 SOAP allows you to get around firewalls
 SOAP is a W3C recommendation
SOAP Building Blocks
A SOAP message is an ordinary XML document containing the following elements:
 An Envelope element that identifies the XML document as a SOAP message
 A Header element that contains header information

 A Body element that contains call and response information
 A Fault element containing errors and status information
Syntax Rules
Here are some important syntax rules:
 A SOAP message MUST be encoded using XML
 A SOAP message MUST use the SOAP Envelope namespace
 A SOAP message MUST use the SOAP Encoding namespace
 A SOAP message must NOT contain a DTD reference
 A SOAP message must NOT contain XML Processing Instructions
 The SOAP Envelope element is the root element of a SOAP message.

 The SOAP Envelope Element
 The required SOAP Envelope element is the root element of a SOAP message. This
element defines the XML document as a SOAP message.
 Example
 <?xml version="1.0"?>
<soap:Envelope
xmlns:soap="http://www.w3.org/2001/12/soap-envelope"
soap:encodingStyle="http://www.w3.org/2001/12/soap-encoding">
...
Message information goes here
...
</soap:Envelope>
SOAP Header Element
The SOAP Header element contains header information.
The SOAP Header Element
The optional SOAP Header element contains application-specific information (like
authentication, payment, etc) about the SOAP message.
If the Header element is present, it must be the first child element of the Envelope element.
Note: All immediate child elements of the Header element must be namespace-qualified.
<soap:Envelope

<soap:Header>
<m:Trans xmlns:m="http://www.w3schools.com/transaction/"
soap:mustUnderstand="1">234
</m:Trans>
</soap:Header>
...
...
</soap:Envelope>
SOAP Body Element
The SOAP Body element contains the actual SOAP message.
The SOAP Body Element
The required SOAP Body element contains the actual SOAP message intended for the ultimate
endpoint of the message.
Immediate child elements of the SOAP Body element may be namespace-qualified.
Example
<soap:Envelope
<soap:Body>
<m:GetPrice xmlns:m="http://www.w3schools.com/prices">
<m:Item>Apples</m:Item>
</m:GetPrice>
</soap:Body>
</soap:Envelope>
The example above requests the price of apples. Note that the m:GetPrice and the Item elements
above are application-specific elements. They are not a part of the SOAP namespace.
A SOAP response could look something like this:

<soap:Envelope
<soap:Body>
<m:GetPriceResponse xmlns:m="http://www.w3schools.com/prices">
<m:Price>1.90</m:Price>
</m:GetPriceResponse>
</soap:Body>
</soap:Envelope>
SOAP Fault Element
The SOAP Fault element holds errors and status information for a SOAP message.
The SOAP Fault Element
The optional SOAP Fault element is used to indicate error messages.
If a Fault element is present, it must appear as a child element of the Body element. A Fault
element can only appear once in a SOAP message.
The SOAP Fault element has the following sub elements:
Sub Element Description
<faultcode> A code for identifying the fault
<faultstring> A human readable explanation of the fault
<faultactor> Information about who caused the fault to happen
<detail> Holds application specific error information related to the Body element
SOAP Fault Codes
The faultcode values defined below must be used in the faultcode element when describing
faults:

Error Description
VersionMismatch Found an invalid namespace for the SOAP Envelope element
MustUnderstand An immediate child element of the Header element, with the
mustUnderstand attribute set to "1", was not understood
Client The message was incorrectly formed or contained incorrect information
Server There was a problem with the server so the message could not proceed
SOAP HTTP Binding
SOAP Example
A SOAP Example
In the example below, a GetStockPrice request is sent to a server. The request has a StockName
parameter, and a Price parameter that will be returned in the response. The namespace for the
function is defined in "http://www.example.org/stock".
A SOAP request:
POST /InStock HTTP/1.1
Host: www.example.org
Content-Type: application/soap+xml; charset=utf-8
Content-Length: nnn
<soap:Envelope
<soap:Body xmlns:m="http://www.example.org/stock">
<m:GetStockPrice>
<m:StockName>IBM</m:StockName>
</m:GetStockPrice>
</soap:Body>
</soap:Envelope>

The SOAP response:
HTTP/1.1 200 OK
Content-Type: application/soap+xml; charset=utf-8
Content-Length: nnn
<soap:Envelope
<soap:Body xmlns:m="http://www.example.org/stock">
<m:GetStockPriceResponse>
<m:Price>34.5</m:Price>
</m:GetStockPriceResponse>
</soap:Body>
</soap:Envelope>
XSD
An XML Schema describes the structure of an XML document.
In this tutorial you will learn how to create XML Schemas, why XML Schemas are more
powerful than DTDs, and how to use XML Schema in your application.
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).
 HTML / XHTML
 XML and XML Namespaces
 A basic understanding of DTD
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 ofDTDs
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 powerful 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 became a W3C Recommendation 02. May 2001.
Why Use XML Schemas?
XML Schemas are much more powerful than DTDs.
XML Schemas Support Data Types
One of the greatest strength of XML Schemas is the support for data types.
With support for data types:
 It is easier to describe allowable document content
 It is easier to validate the correctness of data
 It is easier to work with data from a database
 It is easier to define data facets (restrictions on data)
 It is easier to define data patterns (data formats)

 It is easier to convert data between different data types
XML Schemas use XML Syntax
Another great strength about XML Schemas is that they are written in XML.
Some benefits of that XML Schemas are written in XML:
 You don't have to learn a new language
 You can use your XML editor to edit your Schema files
 You can use your XML parser to parse your Schema files
 You can manipulate your Schema with the XML DOM
 You can transform your Schema with XSLT
XML Schemas Secure Data Communication
When sending data from a sender to a receiver, it is essential that both parts have the same
"expectations" about the content.
With XML Schemas, the sender can describe the data in a way that the receiver will understand.
A date like: "03-11-2004" will, in some countries, be interpreted as 3.November and in other
countries as 11.March.
However, an XML element with a data type like this:
<date type="date">2004-03-11</date>
ensures a mutual understanding of the content, because the XML data type "date" requires the
format "YYYY-MM-DD".
XML Schemas are Extensible
XML Schemas are extensible, because they are written in XML.
With an extensible Schema definition you can:
 Reuse your Schema in other Schemas
 Create your own data types derived from the standard types
 Reference multiple schemas in the same document
Well-Formedis not Enough
A well-formed XML document is a document that conforms to the XML syntax rules, like:

 it must begin with the XML declaration
 it must have one unique root element
 start-tags must have matching end-tags
 elements are case sensitive
 all elements must be closed
 all elements must be properly nested
 all attribute values must be quoted
 entities must be used for special characters
Even if documents are well-formed they can still contain errors, and those errors can have
serious consequences.
Think of the following 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 to an XML Schema.
A Simple XML Document
Look at this simple XML document called "note.xml":
<note>
<to>Tove</to>
<from>Jani</from>
</note>
A DTD File
The following example is a DTD file called "note.dtd" that defines the elements of the XML
document above ("note.xml"):
<!ELEMENT note (to, from, heading, body)>
<!ELEMENT heading (#PCDATA)>
The first line defines the note element to have four child elements: "to, from, heading, body".

Line 2-5 defines the to, from, heading, body elements to be of type "#PCDATA".
An XML Schema
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.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 a complex type because it contains other elements. The other elements (to,
from, heading, body) are 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 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 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
the elements used in this XML document are declared in the "http://www.w3schools.com"
namespace.
Once you have the XML Schema Instance namespace available:
you can use the schemaLocation attribute. This attribute has two values. The first value is the
namespace to use. The second value is the location of the XML schema to use for that
namespace:
xsi:schemaLocation="http://www.w3schools.com note.xsd"
XSD Simple Elements
XML Schemas define the elements of your XML files.
A simple element is an XML element that contains 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 included in the XML Schema definition (boolean, string, date, etc.), or
it can be a custom type that you can define yourself.
You can also add restrictions (facets) to a data type in order to limit its content, or you can
require the data to match a specific pattern.

Defining a Simple Element
The syntax for defining a simple element is:
<xs:element name="xxx" type="yyy"/>
where xxx is the name of the element and yyy is the data type of the element.
XML Schema has a lot of built-in data types. The most common types are:
 xs:string
 xs:decimal
 xs:integer
 xs:boolean
 xs:date
 xs:time
Example
Here are some XML elements:
<lastname>Refsnes</lastname>
<age>36</age>
<dateborn>1970-03-27</dateborn>
And here are the corresponding simple element definitions:
<xs:element name="lastname" type="xs:string"/>
<xs:element name="age" type="xs:integer"/>
<xs:element name="dateborn" type="xs:date"/>
Default and Fixed Values for Simple Elements
Simple elements may have a default value OR a fixed value specified.
A default value is automatically assigned to the element when no other value is specified.
In the following example the default value is "red":
<xs:element name="color" type="xs:string" default="red"/>

A fixed value is also automatically assigned to the element, and you cannot specify another
value.
In the following example the fixed value is "red":
<xs:element name="color" type="xs:string" fixed="red"/>
XSD Attributes
All attributes are declared as simple types.
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"/>
where xxx is the name of the attribute and yyy specifies the data type of the attribute.
XML Schema has a lot of built-in data types. The most common types are:
 xs:string
 xs:decimal
 xs:integer
 xs:boolean
 xs:date
 xs:time
Example
Here is an XML element with an attribute:
<lastname lang="EN">Smith</lastname>
And here is the corresponding attribute definition:
<xs:attribute name="lang" type="xs:string"/>
Default and Fixed Values for Attributes

Attributes may have a default value OR a fixed value specified.
A default value is automatically assigned to the attribute when no other value is specified.
In the following example the default value is "EN":
<xs:attribute name="lang" type="xs:string" default="EN"/>
A fixed value is also automatically assigned to the attribute, and you cannot specify another
value.
In the following example the fixed value is "EN":
<xs:attribute name="lang" type="xs:string" fixed="EN"/>
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 onContent
When an XML element or attribute has a data type defined, it puts restrictions on the element's
or attribute's content.
If an XML element is of type "xs:date" and contains a string like "Hello World", the element will
not validate.
With XML Schemas, you can also add your own restrictions to your XML elements and
attributes. These restrictions are called facets. You can read more about facets in the next
chapter.
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 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>
</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 two different ways:
1. The "employee" element can be declared directly by naming the element, like this:

<xs:element name="employee">
<xs:complexType>
<xs:sequence>
<xs:element name="firstname" type="xs:string"/>
</xs:sequence>
</xs:complexType>
</xs:element>
If you use the method described above, only the "employee" element can use the specified
complex type. Note that the child elements, "firstname" and "lastname", are surrounded by the
<sequence> indicator. This means that the child elements must appear in the same order as they
are declared. You will learn more about indicators in the XSD Indicators chapter.
2. The "employee" element can have a type attribute that refers to the name of the complex type
to use:
<xs:element name="employee" type="personinfo"/>
<xs:complexType name="personinfo">
<xs:sequence>
</xs: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 element on an existing complex element 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 Empty Elements
An empty complex element cannot have contents, only attributes.
Complex Empty Elements
An empty XML element:
<product prodid="1345" />
The "product" element above has no content at all. To define a type with no content, we must
define a type that allows elements in its content, but we do not actually declare any elements,
like this:
<xs:element name="product">
<xs:complexType>
<xs:complexContent>
<xs:restriction base="xs:integer">
<xs:attribute name="prodid" type="xs:positiveInteger"/>
</xs:restriction>
</xs:complexContent>

</xs:complexType>
</xs:element>
In the example above, we define a complex type with a complex content. The complexContent
element signals that we intend to restrict or extend the content model of a complex type, and the
restriction of integer declares one attribute but does not introduce any element content.
However, it is possible to declare the "product" element more compactly, like this:
<xs:element name="product">
<xs:complexType>
</xs: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 ElementsOnly
An "elements-only" complex type contains an element that contains only other elements.
Complex Types Containing Elements Only
An XML element, "person", that contains only other elements:
<person>
</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
<xs:element name="person" type="persontype"/>
<xs:complexType name="persontype">
<xs:sequence>
</xs:sequence>
</xs:complexType>
XSD Text-Only Elements
A mixed complex type element can contain attributes, elements, and text.
Complex Types with Mixed Content
An XML element, "letter", that contains both text and other elements:
<letter>
Dear Mr.<name>John Smith</name>.
Your order <orderid>1032</orderid>
will be shipped on <shipdate>2001-07-13</shipdate>.
</letter>
The following schema declares the "letter" element:
<xs:element name="letter">
<xs:complexType mixed="true">
<xs:sequence>
<xs:element name="name" type="xs:string"/>

<xs:element name="orderid" type="xs:positiveInteger"/>
<xs:element name="shipdate" type="xs:date"/>
</xs:sequence>
</xs:complexType>
</xs:element>
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
<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 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: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 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: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.
maxOccursIndicator
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 occur a minimum of one time
(the default value for minOccurs is 1) and a maximum of ten times in the "person" element.
minOccurs Indicator
The <minOccurs> indicator specifies the minimum number of times an element can occur:
<xs: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 occur a minimum of zero times
and a maximum of ten times in the "person" element.
Tip: To allow an element to appear an unlimited number of times, use the
maxOccurs="unbounded" statement:
A working example:
An XML file called "Myfamily.xml":
<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 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: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.
ElementGroups
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 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>
AttributeGroups
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 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:restriction base="xs:string">
<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 ability to let the user choose whether he or she would like to use the Norwegian element
names or the English element names in the XML document.
To solve this problem, we could define 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 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>
</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 want to create a schema for the XML document above.
We start by opening a new file that we will call "shiporder.xsd". To create the schema we could
simply follow the structure in the XML document and define each element as we find it. We will
start with the standard XML declaration followed by the xs:schema element that defines a
schema:
<?xml version="1.0" encoding="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 difficult to read and maintain when
documents are complex.
The next design method is based on defining all elements and attributes first, and then referring
to them using the ref attribute.
Here is the new design 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>
XSD String Data Types
String data types are used for values that contains character strings.
String Data Type
The string data typecan 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 XMLprocessor 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 derive from the String data type (except for 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 cannot use this constraint)
 whiteSpace
XSD Date and Time Data Types
Date and time data types are used for values that contain date and time.
Date Data Type
The date data type is used to specify a date.
The date is specified in the following form "YYYY-MM-DD" where:
 YYYY 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>
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 "YYYY-MM-DDThh:mm:ss" where:
 YYYY indicates the year
 MM indicates the month
 DD indicates the day
 T indicates the start of the required time section
 hh indicates the hour
 mm indicates the minute
 ss indicates the second
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>
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 (YYYY)
gYearMonth Defines a part of a date - the year and month (YYYY-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 derive from the Decimal data type (except for 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 MiscellaneousData 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 cannot use this constraint)
 length (a Boolean data type cannot use this constraint)
 maxLength (a Boolean data type cannot use this constraint)
 minLength (a Boolean data type cannot use this constraint)
 pattern
 whiteSpace
XSLT
XSL stands for EXtensible Stylesheet Language, and is a style sheet language
for XML documents.
XSLT stands for XSL Transformations. In this tutorial you will learn how to use
XSLT to transform XML documents into other formats, like XHTML.
XSL Languages
It started with XSL and ended up with XSLT, XPath, and XSL-FO.
It Started with XSL
XSL stands for EXtensible Stylesheet Language.
The World Wide Web Consortium (W3C) started to develop XSL because there was a need for
an XML-based Stylesheet Language.
CSS = Style Sheets for HTML
HTML uses predefined tags, and the meaning of each tag is well understood.
The <table> tag in HTML defines a table - and a browser knows how to display it.
Adding styles to HTML elements are simple. Telling a browser to display an element in a special
font or color, is easy with CSS.

XSL = Style Sheets for XML
XML does not use predefined tags (we can use any tag-names we like), and therefore the
meaning of each tag is not well understood.
A <table> tag could mean an HTML table, a piece of furniture, or something else - and a
browser does not know how to display it.
XSL describes how the XML document should be displayed!
XSL - More Than a Style Sheet Language
XSL consists of three parts:
 XSLT - a language for transforming XML documents
 XPath - a language for navigating in XML documents
 XSL-FO - a language for formatting XML documents
XSLT Introduction
XSLT is a language for transforming XML documents into XHTML documents or to other XML
documents.
XPath is a language for navigating in XML documents.
 HTML / XHTML
 XML / XML Namespaces
 XPath.
What is XSLT?
 XSLT stands for XSL Transformations
 XSLT is the most important part of XSL
 XSLT transforms an XML document into another XML document
 XSLT uses XPath to navigate in XML documents

 XSLT is a W3C Recommendation
XSLT = XSL Transformations
XSLT is the most important part of XSL.
XSLT is used to transform an XML document into another XML document, or another type of
document that is recognized by a browser, like HTML and XHTML. Normally XSLT does this
by transforming each XML element into an (X)HTML element.
With XSLT you can add/remove elements and attributes to or from the output file. You can also
rearrange and sort elements, perform tests and make decisions about which elements to hide and
display, and a lot more.
A common way to describe the transformation process is to say that XSLT transforms an XML
source-tree into an XML result-tree.
XSLT Uses XPath
XSLT uses XPath to find information in an XML document. XPath is used to navigate through
elements and attributes in XML documents.
How Does it Work?
In the transformation process, XSLT uses XPath to define parts of the source document that
should match one or more predefined templates. When a match is found, XSLT will transform
the matching part of the source document into the result document.
XSLT is a W3C Recommendation
XSLT became a W3C Recommendation 16. November 1999.
XSLT – Transformation
Example study: How to transform XML into XHTML using XSLT.

The details of this example will be explained in the next chapter.
Correct Style Sheet Declaration
The root element that declares the document to be an XSL style sheet is <xsl:stylesheet> or
<xsl:transform>.
Note: <xsl:stylesheet> and <xsl:transform> are completely synonymous and either can be used!
The correct way to declare an XSL style sheet according to the W3C XSLT Recommendation is:
or:
<xsl:transform version="1.0"
To get access to the XSLT elements, attributes and features we must declare the XSLT
namespace at the top of the document.
The xmlns:xsl="http://www.w3.org/1999/XSL/Transform" points to the official W3C XSLT
namespace. If you use this namespace, you must also include the attribute version="1.0".
Start with a Raw XML Document
We want to transform the following XML document ("cdcatalog.xml") into XHTML:
<catalog>
<cd>
<artist>Bob Dylan</artist>
<country>USA</country>
<company>Columbia</company>
<year>1985</year>
</cd>
.

.
</catalog>
Viewing XML Files in Firefox and Internet Explorer: Open the XML file (typically by
clicking on a link) - The XML document will be displayed with color-coded root and child
elements. A plus (+) or minus sign (-) to the left of the elements can be clicked to expand or
collapse the element structure. To view the raw XML source (without the + and - signs), select
"View Page Source" or "View Source" from the browser menu.
Viewing XML Files in Netscape 6: Open the XML file, then right-click in XML file and select
"View Page Source". The XML document will then be displayed with color-coded root and child
elements.
Viewing XML Files in Opera 7: Open the XML file, then right-click in XML file and select
"Frame" / "View Source". The XML document will be displayed as plain text.
View "cdcatalog.xml"
Create an XSL Style Sheet
Then you create an XSL Style Sheet ("cdcatalog.xsl") with a transformation template:
<html>
<body>
<table border="1">
<tr bgcolor="#9acd32">
<th>Title</th>
<th>Artist</th>
</tr>
<tr>
</tr>

</xsl:for-each>
</table>
</body>
</html>
</xsl:template>
</xsl:stylesheet>
View "cdcatalog.xsl"
Link the XSL Style Sheet to the XML Document
Add the XSL style sheet reference to your XML document ("cdcatalog.xml"):
<?xml-stylesheet type="text/xsl" href="cdcatalog.xsl"?>
<catalog>
<cd>
<artist>Bob Dylan</artist>
<country>USA</country>
<company>Columbia</company>
<year>1985</year>
</cd>
.
.
</catalog>
If you have an XSLT compliant browser it will nicely transform your XML into XHTML.
XSLT <xsl:template> Element
An XSL style sheet consists of one or more set of rules that are called templates.
A template contains rules to apply when a specified node is matched.
The <xsl:template> Element
The <xsl:template> element is used to build templates.

The match attribute is used to associate a template with an XML element. The match attribute
can also be used to define a template for the entire XML document. The value of the match
attribute is an XPath expression (i.e. match="/" defines the whole document).
Ok, let's look at a simplified version of the XSL file from the previous chapter:
Example
<html>
<body>
<table border="1">
<th>Title</th>
<th>Artist</th>
</tr>
<tr>
<td>.</td>
<td>.</td>
</tr>
</table>
</body>
</html>
</xsl:template>
</xsl:stylesheet>
Try it yourself »
Example Explained
Since an XSL style sheet is an XML document, it always begins with the XML declaration:
<?xml version="1.0" encoding="ISO-8859-1"?>.
The next element, <xsl:stylesheet>, defines that this document is an XSLT style sheet document
(along with the version number and XSLT namespace attributes).

The <xsl:template> element defines a template. The match="/" attribute associates the
template with the root of the XML source document.
The content inside the <xsl:template> element defines some HTML to write to the output.
The last two lines define the end of the template and the end of the style sheet.
The result from this example was a little disappointing, because no data was copied from the
XML document to the output. In the next chapter you will learn how to use the <xsl:value-of>
element to select values from the XML elements
XSLT <xsl:value-of> Element
The <xsl:value-of> element is used to extract the value of a selected node.
The <xsl:value-of> Element
The <xsl:value-of> element can be used to extract the value of an XML element and add it to the
output stream of the transformation:
Example
<html>
<body>
<table border="1">
<th>Title</th>
<th>Artist</th>
</tr>
<tr>
<td><xsl:value-of select="catalog/cd/title"/></td>
<td><xsl:value-of select="catalog/cd/artist"/></td>
</tr>
</table>
</body>
</html>

</xsl:template>
</xsl:stylesheet>
XSLT <xsl:for-each> Element
The <xsl:for-each> element allows you to do looping in XSLT.
The <xsl:for-each> Element
The XSL <xsl:for-each> element can be used to select every XML element of a specified node-
set:
Example
<html>
<body>
<table border="1">
<th>Title</th>
<th>Artist</th>
</tr>
<tr>
</tr>
</xsl:for-each>
</table>
</body>
</html>
</xsl:template>
</xsl:stylesheet>

Note: The value of the select attribute is an XPath expression. An XPath expression works like
navigating a file system; where a forward slash (/) selects subdirectories.
Filtering the Output
We can also filter the output from the XML file by adding a criterion to the select attribute in the
<xsl:for-each> element.
<xsl:for-each select="catalog/cd[artist='Bob Dylan']">
Legal filter operators are:
 = (equal)
 != (not equal)
 < less than
 > greater than
Take a look at the adjusted XSL style sheet:
Example
<html>
<body>
<table border="1">
<th>Title</th>
<th>Artist</th>
</tr>
<xsl:for-each select="catalog/cd[artist='Bob Dylan']">
<tr>
</tr>
</xsl:for-each>
</table>

</body>
</html>
</xsl:template>
</xsl:stylesheet>
XSLT <xsl:sort> Element
The <xsl:sort> element is used to sort the output.
Where to put the Sort Information
To sort the output, simply add an <xsl:sort> element inside the <xsl:for-each> element in the
XSL file:
Example
<html>
<body>
<table border="1">
<th>Title</th>
<th>Artist</th>
</tr>
<xsl:sort select="artist"/>
<tr>
</tr>
</xsl:for-each>
</table>
</body>

</html>
</xsl:template>
</xsl:stylesheet>
The <xsl:if> element is used to put a conditional test against the content of the XML file.
The <xsl:if> Element
To put a conditional if test against the content of the XML file, add an <xsl:if> element to the
XSL document.
Syntax
<xsl:if test="expression">
...some output if the expression is true...
</xsl:if>
Where to Put the <xsl:if> Element
To add a conditional test, add the <xsl:if> element inside the <xsl:for-each> element in the XSL
file:
Example
<html>
<body>
<table border="1">
<th>Title</th>
<th>Artist</th>
</tr>
<xsl:if test="price > 10">
<tr>

</tr>
</xsl:if>
</xsl:for-each>
</table>
</body>
</html>
</xsl:template>
</xsl:stylesheet>
XSLT <xsl:choose> Element
The <xsl:choose> element is used in conjunction with <xsl:when> and <xsl:otherwise> to express
multiple conditional tests.
The <xsl:choose> Element
Syntax
<xsl:choose>
<xsl:when test="expression">
... some output ...
</xsl:when>
<xsl:otherwise>
... some output ....
</xsl:otherwise>
</xsl:choose>
Where to put the Choose Condition
To insert a multiple conditional test against the XML file, add the <xsl:choose>, <xsl:when>,
and <xsl:otherwise> elements to the XSL file:
Example

<html>
<body>
<table border="1">
<th>Title</th>
<th>Artist</th>
</tr>
<tr>
<xsl:choose>
<xsl:when test="price > 10">
<td bgcolor="#ff00ff">
<xsl:value-of select="artist"/></td>
</xsl:when>
<xsl:otherwise>
</xsl:otherwise>
</xsl:choose>
</tr>
</xsl:for-each>
</table>
</body>
</html>
</xsl:template>
</xsl:stylesheet>
XSLT <xsl:apply-templates>Element
The <xsl:apply-templates> element applies a template to the current element or to the current element's
child nodes.
The <xsl:apply-templates> Element
The <xsl:apply-templates> element applies a template to the current element or to the current
element's child nodes.
If we add a select attribute to the <xsl:apply-templates> element it will process only the child
element that matches the value of the attribute. We can use the select attribute to specify the
order in which the child nodes are processed.

Look at the following XSL style sheet:
Example
<html>
<body>
<xsl:apply-templates/>
</body>
</html>
</xsl:template>
<xsl:template match="cd">
<p>
<xsl:apply-templates select="title"/>
<xsl:apply-templates select="artist"/>
</p>
</xsl:template>
<xsl:template match="title">
Title: <span style="color:#ff0000">
<xsl:value-of select="."/></span>
<br />
</xsl:template>
<xsl:template match="artist">
Artist: <span style="color:#00ff00">
<xsl:value-of select="."/></span>
<br />
</xsl:template>
</xsl:stylesheet>

XPath
XPath is used to navigate through elements and attributes in an XML document.
XPath is a major element in W3C's XSLT standard - and XQuery and XPointer are both built on
XPath expressions.
XPath is a language for finding information in an XML document.
 HTML / XHTML
XPathSyntax
XPath uses path expressions to select nodes or node-sets in an XML document. The node is
selected by following a path or steps.
The XML Example Document
We will use the following XML document in the examples below.
<bookstore>
<book>
<title lang="eng">Harry Potter</title>
</book>
<book>
<title lang="eng">Learning XML</title>
</book>
</bookstore>

XPathExamples
Let's try to learn some basic XPath syntax by looking at some examples.
"books.xml":
<bookstore>
<book category="COOKING">
<title lang="en">Everyday Italian</title>
<author>Giada De Laurentiis</author>
<year>2005</year>
</book>
<title lang="en">Harry Potter</title>
<year>2005</year>
</book>
<title lang="en">XQuery Kick Start</title>
<author>James McGovern</author>
<author>Per Bothner</author>
<author>Kurt Cagle</author>
<author>James Linn</author>
<author>Vaidyanathan Nagarajan</author>
<year>2003</year>
</book>
<title lang="en">Learning XML</title>
<year>2003</year>
</book>

</bookstore>
Loading the XML Document
Using XMLHttpRequest to load XML documents is supported in all modern browsers.
Code for most modern browsers:
var xmlhttp=newXMLHttpRequest()
Code for old Microsoft browsers (IE 5 and 6):
var xmlhttp=newActiveXObject("Microsoft.XMLHTTP")
Selecting Nodes
Unfortunately, there are different ways of dealing with XPath in Internet Explorer and other
browsers.
In our examples we have included code that should work with most major browsers.
Internet Explorer uses the selectNodes() method to select nodes from the XML document:
xmlDoc.selectNodes(xpath);
Firefox, Chrome, Opera and Safari use the evaluate() method to select nodes from the XML
document:
xmlDoc.evaluate(xpath,xmlDoc,null,XPathResult.ANY_TYPE,null);
Select all the titles
The following example selects all the title nodes:
Example

/bookstore/book/title
Try it yourself »
Select the title of the first book
The following example selects the title of the first book node under the bookstore element:
Example
/bookstore/book[1]/title
Try it yourself »
There is a problem with this. The example above shows different results in IE and other
browsers.
IE5 and later has implemented that [0] should be the first node, but according to the W3C
standard it should have been [1]!!
A Workaround!
To solve the [0] and [1] problem in IE5+, you can set the SelectionLanguage to XPath.
The following example selects the title of the first book node under the bookstore element:
Example
xml.setProperty("SelectionLanguage","XPath");
xml.selectNodes("/bookstore/book[1]/title");
Try it yourself »
Select all the prices

The following example selects the text from all the price nodes:
Example
/bookstore/book/price/text()
Try it yourself »
Select price nodes with price>35
The following example selects all the price nodes with a price higher than 35:
Example
/bookstore/book[price>35]/price
Try it yourself »
Select title nodes with price>35
The following example selects all the title nodes with a price higher than 35:
Example
/bookstore/book[price>35]/title
Try it yourself »
XQuery
XQuery is to XML what SQL is to database tables.
XQuery was designed to query XML data.

Introductionto XQuery
XQuery is to XML what SQL is to database tables.
XQuery is designed to query XML data - not just XML files, but anything that can appear as
XML, including databases.
 HTML / XHTML
 XPath
XQuery Example
Let's try to learn some basic XQuery syntax by looking at an example.
"books.xml":
<?xml version="1.0"encoding="ISO-8859-1"?>
<bookstore>
<bookcategory="COOKING">
<title lang="en">EverydayItalian</title>
<author>GiadaDe Laurentiis</author>
<year>2005</year>
</book>
<bookcategory="CHILDREN">

<title lang="en">HarryPotter</title>
<author>JK. Rowling</author>
<year>2005</year>
</book>
<bookcategory="WEB">
<title lang="en">XQueryKickStart</title>
<author>JamesMcGovern</author>
<author>PerBothner</author>
<author>KurtCagle</author>
<author>JamesLinn</author>
<author>VaidyanathanNagarajan</author>
<year>2003</year>
</book>
<bookcategory="WEB">
<title lang="en">LearningXML</title>
<author>ErikT. Ray</author>
<year>2003</year>
</book>
</bookstore>
View the "books.xml" file in your browser.
How to Select Nodes From "books.xml"?
Functions
XQuery uses functions to extract data from XML documents.
The doc() function is used to open the "books.xml" file:
doc("books.xml")
Path Expressions
XQuery uses path expressions to navigate through elements in an XML document.
The following path expression is used to select all the title elements in the "books.xml" file:

doc("books.xml")/bookstore/book/title
(/bookstore selects the bookstore element, /book selects all the book elements under the
bookstore element, and /title selects all the title elements under each book element)
The XQuery above will extract the following:
<title lang="en">EverydayItalian</title>
<title lang="en">XQueryKickStart</title>
<title lang="en">LearningXML</title>
Predicates
XQuery uses predicates to limit the extracted data from XML documents.
The following predicate is used to select all the book elements under the bookstore element that
have a price element with a value that is less than 30:
doc("books.xml")/bookstore/book[price<30]
The XQuery above will extract the following:
<bookcategory="CHILDREN">
<year>2005</year>
</book>
XQuery Terms
In XQuery, there are seven kinds of nodes: element, attribute, text, namespace, processing-
instruction, comment, and document (root) nodes.
XQuery Terminology

Nodes
In XQuery, there are seven kinds of nodes: element, attribute, text, namespace, processing-
instruction, comment, and document (root) nodes. XML documents are treated as trees of nodes.
The root of the tree is called the document node (or root node).
Look at the following XML document:
<?xml version="1.0"encoding="ISO-8859-1"?>
<bookstore>
<book>
<year>2005</year>
</book>
</bookstore>
Example of nodes in the XML document above:
<bookstore>(documentnode)
<author>J K.Rowling</author>(elementnode)
lang="en"(attribute node)
Atomicvalues
Atomic values are nodes with no children or parent.
Example of atomic values:
J K. Rowling
"en"
Items
Items are atomic values or nodes.

Relationship of Nodes
Parent
Each element and attribute has one parent.
In the following example; the book element is the parent of the title, author, year, and price:
<book>
<title>HarryPotter</title>
<year>2005</year>
</book>
Children
Element nodes may have zero, one or more children.
In the following example; the title, author, year, and price elements are all children of the book
element:
<book>
<year>2005</year>
</book>
Siblings
Nodes that have the same parent.
In the following example; the title, author, year, and price elements are all siblings:
<book>
<year>2005</year>
</book>

Ancestors
A node's parent, parent's parent, etc.
In the following example; the ancestors of the title element are the book element and the
bookstore element:
<bookstore>
<book>
<year>2005</year>
</book>
</bookstore>
Descendants
A node's children, children's children, etc.
In the following example; descendants of the bookstore element are the book, title, author, year,
and price elements:
<bookstore>
<book>
<year>2005</year>
</book>
</bookstore>
XQuery Syntax
XQuery is case-sensitive and XQuery elements, attributes, and variables must be valid XML
names.

XQuery Basic Syntax Rules
Some basic syntax rules:
 XQuery is case-sensitive
 XQuery elements, attributes, and variables must be valid XML names
 An XQuery string value can be in single or double quotes
 An XQuery variable is defined with a $ followed by a name, e.g. $bookstore
 XQuery comments are delimited by (: and :), e.g. (: XQuery Comment :)
XQuery Conditional Expressions
"If-Then-Else" expressions are allowed in XQuery.
Look at the following example:
for $x in doc("books.xml")/bookstore/book
return if ($x/@category="CHILDREN")
then <child>{data($x/title)}</child>
else <adult>{data($x/title)}</adult>
Notes on the "if-then-else" syntax: parentheses around the if expression are required. else is
required, but it can be just else ().
The result of the example above will be:
<adult>Everyday Italian</adult>
<child>Harry Potter</child>
<adult>Learning XML</adult>
<adult>XQuery Kick Start</adult>
XQuery Comparisons
In XQuery there are two ways of comparing values.
1. General comparisons: =, !=, <, <=, >, >=
2. Value comparisons: eq, ne, lt, le, gt, ge
The difference between the two comparison methods are shown below.

The following expression returns true if any q attributes have a value greater than 10:
$bookstore//book/@q > 10
The following expression returns true if there is only one q attribute returned by the expression,
and its value is greater than 10. If more than one q is returned, an error occurs:
$bookstore//book/@q gt 10

Xml material

More Related Content

What's hot

Similar to Xml material

More from prathap kumar

Recently uploaded

Xml material