XML Schema, XSD, Notes

Intro

XML Schema is an XML based alternative to DTD

An XML Schema describes the structure of an XML document

The XML language is also referred to as XML Schema Definition (XSD)
- 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
- Reasons XML Schema replaces DTD
  
  XML Schemas are extensible for future additions
  
  XML Schemas are richer and more useful
  
  XML Schemas are written in XML
  
  XML Schemas support data types
  
  XML Schemas support Namespaces
- XML Schema is a W3C Recommendation
With support for data types:

It's easier to describe permissible document content

It's easier to validate data

It's easier to work with data from a database

It's easier to define restrictions on data

It's easier to define data formats

It's easier to convert data between data types
XML Schemas use XML Syntax

So you don't have to learn another language

You can use the XML editor to edit the Schema files

You can use the XML Parser to parse the Schema files

You can manipulate the Schema with the XML DOM

You can transform the Schema with XSLT
XML Schemas Secure Data Communications
The sender can describe the data in a way the receiver will understand
Example:
```
              <date type = "date">1999-03-11</date>
            
```
This ensures an understanding of the content because the XML data type date

Requires the format CCYY-MM-DD
XML Schemas are Extensible

Because they are written in XML

So you can reuse them in other Schemas

You can create your own data types derived from standard types

You can reference multiple Schemas from the same document
Requirements
- Must begin with the XML Declaration
- Must have one Unique Root Element
- All Start-Tags Must Match End-Tags
- XML Tags are Case Sensitive
- All Elements Must be Closed
- All Elements Must be Properly Nested
- All Attribute Values Must be Quoted
- XML Entities Must be used for Special Characters

Examples:

XML Document

              <?xml version = "1.0"?>
              <note>
              <to>Bob</to>
              <from>Bill</from>
              <heading>Reminder</heading>
              <body>Don't forget me this weekend!</body>
              </note>

Matching DTD

              <!ELEMENT note (to, from, heading, body)>
              <!ELEMENT to (#PCDATA)>
              <!ELEMENT from (#PCDATA)>
              <!ELEMENT heading (#PCDATA)>
              <!ELEMENT body (#PCDATA)>

XML Schema to replace the DTD

              <?xml version = "1.0"?>
              <xs:schema xmlns:xs = "http://www.w3.org/2001/XMLSchema"
                    targetNamespace = "http://www.w3schools.com"
                              xmlns = "http://www.w3schools.com"
                 elementFormDefault = "qualified">
                <xs:element name = "note">
                  <xs:complexType>
                    <xs:sequence>
                      <xs:element name = "to" type = "xs:string" />
                      <xs element name = "from" type = "xs:string" />
                      <xs:element name = "heading" type = "xs:string" />
                      <xs:element name = "body" type = 'xs:string" />
                    </xs:sequence>
                  </xs:complexType>
                </xs:element>
              </xs:schema>

The note Element is a Complex Type because it contains other elements

XML document's reference to a DTD

              <?xml version = "1.0"?>
              <!DOCTYPE note SYSTEM "http://www.w3schools.com/dtd/notd.dtd">
              <note>
                <to>Bob</to>
                <from>Bill</from>
                <heading>Reminder</heading>
                <body>Don't forget me this weekend!</body>
              </note>

XML document's Reference to an XSD

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

The <schema> Element

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

The <schema> element can have attributes
- Example/Definition:
```
              <?xml version = '1.0"?>
              <xs:schema xmlns:xs = "http://www.w3.org/2001/XMLSchema"
                           targetNamespace = 'http://www.w3schools.com"
                           xmlns = "http://www/w3schools.com"
                           elementFormDefault = "qualified">
              ...
              ...
              </xs:schema>
            
```
  xmlns:xs = "http://www.w3.org/2001/XMLSchema"
  
  This indicates that the elements and data types used in the schema
  
  all come from that namespace and should be prefixed with xs:
  
  targetNamespace = "http://www.w3schools.com"
  
  This indicates that the elements defined by this schema
  
  all come from the same namespace
  
  xmlns = "http://www.w3schools.com"
  
  This indicates the default namespace
- Referencing a Schema from an XML Document
```
              <?xml version = "1.0"?>
              <note xmlns = "http://www.w3schools.com"
                      xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
                      xsi:schemaLocation = "http://www.w3schools.com note.xsd">
              <note>
                <to>Bob</to>
                <from>Bill</from>
                <heading>Reminder</heading>
                <body>Don't forget me this weekend!</body>
              </note>
            
```
  xmlns = "http://www.w3schools.com"
  
  This specifies the default namespace declaration and tells the
  
  Schema-validator that all elements used in this XML document are
  
  declared in that namespace
  
  xmlns:xsi = "http://www/w3.org/2001/XMLSchema-instance"
  
  Once you have the XML Schema instance namespace available
  
  You can use the schemaLocation attribute like below
  
  xsi:schemaLocation = "http://www.w3schools.com note.xsd"
  
  The first value is the namespace
  
  The second is the location of the schema to use for that namespace
Simple XSD Elements

A Simple Element is an XML Element that can contain only Text.

It Cannot Contain Any other Elements or Attributes

But it can be of any different type defined in the XML Schema Definition

Or it can be of a type "User" defined

You can also add restrictions, (facets), to a data type to limit it's content

You can require the data to match a predefined pattern
- Syntax
  
  <xs:element name = "elementname" type = "elementtype" />
- Example XML Elements:
```
              <lastname>Allard</lastname>
              <age>42</age>
              <birthdate>1960-11-05</birthdate>
            
```
- Corresponding Simple XSD Element Definitions:
```
              <xs:element name = "lastname" type = "xs:string" />
              <xs:element name = "age" type = "xs:integer" />
              <xs:element name = "birthdate" type = "xs:date" />
            
```
Common XML Schema Data Types
- xs:string
- xs:decimal
- xs:integer
- xs:boolean
- xs:date
- xs:time
Declaring Default and Fixed Values for Simple Elements

Simple elements can have a default value or a fixed value set

A default value is automatically assigned to the element

when no other value is specified

<xs:element name = "color" type = "xs:string" default = "red" />

Fixed values are automatically assigned to the element and

you cannot specify another value

<xs:element name = "color" type = "xs:string" fixed = "red" />
XSD Attributes

All Attributes are declared as Simple Types

Only Complex Elements can have Attributes
- Syntax
  <xs:attribute name = "attributename" type = "attributetype" />
  
  XML Element with an Attribute
  
  <lastname lang = "EN">Allard</lastname>
  
  XSD Attribute definition:
  <xs:attribute name = "lang" type = "xs:string" />
Declaring Default and Fixed Values for Attributes

Attributes can have a default value or a fixed value specified

<xs:attribute name = "lang" type = "xs:string" default = "EN" />

Fixed values are automatically assigned to the attribute

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

All attributes are optional by default

To specify optional or required use the "use" attribute

<xs:attribute name = "lang" type = "xs:string" use = "optional" />

<xs:attribute name = "lang" type = "xs:string" use = "required" />

Restrictions/Facets

Restrictions are used to control acceptable values for XML elements or attributes

Restrictions on XML elements are called Facets

Restrictions on Content

The element or attribute will not validate if it's content isn't of the type specified

minInclusive and maxInclusive - Restrictions on Values

Inclusive Example: - sets a min/max

                <xs:element name = "age">
                <xs:simpleType>
                  <xs:restriction base = "xs:integer">
                    <xs:minInclusive value = "0" />
                    <xs:maxInclusive value = "100" />
                  <xs:restriction>
                <xs:simpleType>
                <xs:element>

Enumeration - Restrictions on a Set of Values

Enumeration Example: - creates a set of acceptable values

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

This could also have been written

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

Description:

In this case the type "carType" can be used by other elements because it is not a part of the "car" element

pattern - Restrictions on a Series of Values

Pattern Example:

                <xs:element name = "letter">
                  <xs:simpleType>
                    <xs:restriction base = "xs:string">
                      <xs:pattern value = "[a-z]" />
                    </xs:restriction>
                  </xs:simpleType>
                </xs:element>

Description:

The "letter" element is a simple type with a restriction that the only acceptable value is only one of the lowercase letters from a to z.

Pattern Example:

                <xs:element name = "initials">
                  <xs:simpleType>
                    <xs:restriction base = "xs:string">
                      &xs:pattern value = "a-zA-Z][a-zA-Z][a-zA-Z]" />
                    </xs:restriction>
                  </xssimpleType>
                </xs:element>

Description:

The "initials" element is a simple type with a restriction that the only acceptable value is 3 of the lower or uppercase letters of the alphabet.

Pattern Example:

                <xs:element name = "choice">
                  <xs:simpleType>
                    <xs:restriction base = "xs:string">
                      <xs:pattern value = "[xyz]" />
                    </xs:restriction>
                  <xs:simpleType>
                </xs:element>

Description:

The "choice" element is a simple type with a restriction that the only acceptable value is either x, y or z.

Pattern Example:

                <xs:element name = "prodid">
                  <xs:simpleType>
                    <xs:restriction base = "xs:integer">
                      <xs:pattern value = "[0-9][0-9][0-9][0-9][0-9]" />
                    </xs:restriction>
                  </xs:simpleType>
                </xs:element>

Description:

The "prodid" element is a simple type with a restriction that the only acceptable value is 5 digits within the range of 0 to 9.

Pattern Example:

                <xs:element name = "letter">
                  <xs:simpleType>
                    <xs:restriction base = "xs:string">
                      <xs:pattern value = "([a-z])" />
                    </xs:restriction>
                  </xs:simpleType>
                </xs:element>

Description:

The "letter" element is a simple type with a restriction that the only acceptable value is zero or more occurrences of lowercase letters of the alphabet.

Pattern Example:

                <xs:element name = "gender">
                  <xs:simpleType>
                    <xs:restriction base = "xs:string">
                      <xs:pattern value = "mail|femail" />
                    </xs:restriction>
                  </xs:simpleType>
                </xs:element>

Description:

The "gender" element is a simple type with a restriction that the only acceptable value is male or femail

Pattern Example:

                <xs:element name = "password">
                  <xs:simpleType>
                    <xs:restriction base = "xs:string">
                      <xs:pattern value = "[a-zA-Z0-9(8)" />
                    </xs:restriction>
                  </xs:simpleType>
                </xs:element>

Description:

The "password" element is a simple type with a restriction that there must be exactly 8 characters in a row and those characters must be lowercase or uppercase alphanumeric.

whiteSpace - Restrictions on White Space Characters

whiteSpace Example:

                <xs:element name = "address">
                  <xs:simpleType>
                    <xs:restriction base = "xs:string">
                      <xs:whiteSpace value = "preserve" />
                    </xs:restriction>
                  </xs:simpleType>
                </xs:element>

Description:

The "address" element is a simple type with a restriction that the XML processor will not remove and white space characters.

whiteSpace Example:

                <xs:element name = "address">
                  <xs:simpleType>
                    <xs:restriction base = "xs:string">
                      <xs:whiteSpace value = "collapse" />
                    </xs:restriction>
                  </xs:simpleType>
                </xs:element>

Description:

The "address" element is a simple type with a restriction that the XML processor will remove all white space characters (line feeds, tabs, spaces, carriage returns are replaced with spaces, leading and trailing spaces are removed, multiple spaces are reduced to a single space).

length, minLength and maxLength - Restrictions on Length

length Example:

                <xs:element name = "password">
                  <xs:simpleType>
                    <xs:restriction base = "xs:string">
                      <xs:length value = "8" />
                    </xs:restriction>
                  </xs:simpleType>
                </xs:element>

Description:

The "password" element is a simple type with a restriction that the length must be exactly 8 characters.

minLength and maxLength Example:

                <xs:element name = "password">
                  <xs:simpleType>
                    <xs:restriction base = "xs:string">
                      <xs:minLength value = "5" />
                      <xs:maxLength value = "8" />
                    </xs:restriction>
                  </xs:simpleType>
                </xs:element>

Description:

The "password" element is a simple type with a restriction that the length must be between 5 and 8 characters inclusive.

Restrictions for DataTypes

Constraint	Description
enumeration	defines a list of acceptble values
fractionDigits	Specifies the maximum number of decimal places allowed. Must be equal to or greater than zero.
length	Specifies the exact number of characters or list items allowed. Must be equal to or greater than zero
maxExclusive	Specifies the upper bounds for numeric values The values must be lower than this value
maxInclusive	Specifies the upper bounds for numeric values. The value must be equal to or less than this value
maxLength	Specifies the maximum number of characters or list items allowed. Must be equal to or greater than zero
minExclusive	Specifies lower bounds for numeric values The value must be greater than this value
minInclusive	Specifies the lower bounds for numeric values The value must be equal to or greater than this value
minLength	Specifies the minimum number of characters or list items allowed. Must be equal to or greater than zero.
pattern	Defines the exact sequence of characters that are acceptable
totalDigits	Specifies the exact number of digits allowed. Must be greater than zero.
whiteSpace	Specifies how white space is handled

XSD Complex Elements

A Complex Element is an XML Element that contains other elements and/or attributes

4 kinds of Complex Elements

Examples

1) Empty Element

              <product pid = "1345" />

2) Complex XML Element "employee" which contains only other elements.

              <employee>
                <firstname>Doug</firstname>
                <lastname>Allard</lastname>
              </employee>

3) Complex XML Element "food" which contains only text

              <food type = "dessert">Ice Cream</food>

4) Complex XML Element "description" which contains elements and text

              <description>
                It happened on <date lang = "english">12/10/99</date>
              </description>

Defining Complex Elements

Given the above complex xml element "employee"

Example 1:
The element can be declared directly by naming the element

                <xs:element name = "employee">
                  <xs:complexType>
                    <xs:sequence>
                      <xs:element name = "firstname" type = "xs:string" />
                      <xs:element name = "lastname" type = "xs:string />
                    </xs:sequence>
                  </xs:complexType>
                </xs:element>

If you use the method above, only the "employee" element can use the specified complex type. The child elements "firstname" and "lastname" are surronded by the <sequence> indicator. This means that the child elements must appear in the same order as they are declared

Example 2:
The element can have a type attribute that refers to the name of the complex type to use:

                <xs:element name = "employee" type = "personinfo" />
                <xs:complexType name = "personinfo">
                  <xs:sequence>
                    <xs:element name = "firstname" type = "xs:string" />
                    <xs:element name = "lastname"  type = "xs:string" />
                  </xs:sequence>
                </xs:complexType>

If you use the method above, several elements can refer to the same complex type... like this:

                <xs:element name = "employee" type = "personinfo" />
                <xs:element name = "student"  type = "personinfo" />
                <xs:element name = "member"   type = "personinfo" />

                <xs:complexType name = "personinfo">
                  <xs:sequence>
                    <xs:element name = "firstname" type = "xs:string" />
                    <xs:element name = "lastname type = "xs:string" />
                  </xs:sequence>
                </xs:complexType>

You can also base a cmplex type element on an existing complex type and add elements... like this:

                <xs:element name = "employee" type = "fullpersoninfo" />

                <xs:complexType name = "personinfo">
                  <xs:sequence>
                    <xs:element name = "firstname" type = "xs:string" />
                    <xs:element name = "lastname" type = "xs:string />
                  </xs:sequence>

                <xs:complexType 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 Complex Elements

Empty complex elements can contain attributes but cannot have any content between the opening and closing tags

Defining complex types for empty elements

The following "product" element has no content:

                <product prodid = "1345" />

To define a type with no content, you must define a type that allows only elements in it's content, but then... not actually declare any elements... like this:

                <xs:element name = "product">
                  <xs:complexType>
                    <xs:complexContent>
                      <xs:restrinction base = "xs:integer">
                        <xs:attribute name = "prodid" type = "xs:positiveInteger" />
                      </xs:restriction>
                    </xs:complexContent>
                  </xs:complexType>
                </xs:element>

In the example above we defined a complexType having complexContent i.e. only elements. The complexContent element signals that we intend to restrict or extend the content model of a complex type, and the restriction of integer declares one attribute but but does not introduce any element content.

However it is possible to declare the product element more compactly... like this

                <xs:element name = "product">
                  <xs:complexType>
                    <xs:attribute name = "prodid" type = "xs:positiveInteger" />
                  </xs:complexType>
                </xs:element>

Or you can give the complexType element a name and let the "product" element have a type attribute that refers to the name of the complexType.

(If you use this method, several elements can refer to the same complex type)

                <xs:element name = "product" type = "prodtype" />

                <xs:complexType name = "prodtype">
                  <xs:attribute name = "prodid" type = "xs:positiveInteger" />
                </xs:complexType>

XSD Complex Type Elements Only

An "elements only" complex type contains an element that contains only other elements

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

            <person>
              <firstname>Doug</firstname>
              <lastname>Allard</lastname>
            </person>

The schema definition looks like this:

            <xs:element name = "person">
              <xs:complexType>
                <xs:sequenct>
                  <xs:element name = "firstname" type = "xs:string" />
                  <xs:element name = "lastname"  type = "xs:string" />
                </xs:sequence>
              </xs:complexType>
            </xs:element>

Notice that the <xs:sequence> tag means that the elements defined ("firstname" and "lastname") must appear in that order inside a "person" element

Or you can give the complexType element a name and let the "person" element have a type attribute that refers to the name of the complexType

(If you use this method, several elements can refer to the same complex type)

            <xs:element name = "person" type = "persontype" />

            <xs:complexType name = "pserontype">
              <xs:sequence>
                <xs:element name = "firstname" type = "xs:string" />
                <xs:element name = "lsastname" type = "xs:string" />
              </xs:sequence>
            </xs:complexType>

XSD complex Text-Only Elements

A complext text element can contain both attributes and text

This type contains only simple content (text and attributes), therefore we add a simpleContent element around the content.

When using simple content, you must define an extension OR a restriction witin the simpleContent element... like this:

            <xs:element name = "somename">
              <xs:complexType>
                <xs:simpleContent>
                  <xs:extension base = "basetype">
                    ...
                    ...
                  </xs:extension>
                </xs:simpleContent>
              </xscomplexType>
            <xs:element>

            <xs:element name = "somename">
              <xs:complexType>
                <xs:simpleContent>
                  <xs:restriction base = "basetype">
                    ...
                    ...
                  </xs:restriction>
                </xs:sompleContent>
              </xs:complexType>
            </xs:element>

Use the extension element to expand on the base simple type for the element and use the restriction element to limit the base simple type for the element

Example

An XML element "shoesize" that contains text-only

            <shoesize country = "france">35</shoesize>

The following example declares a complexType "shoesize".

The content is defined as an integer data type and the "shoesize" element also contains an attribute name "country"

            <xs:element name = "shoesize">
              <xs:complexType>
                <xs:simpleContent>
                  <xs:extension base = "xs:integer">
                    <xs:attribute name = "country type = "xs:string" />
                  </xs:extension>
                </xs:simpleContent>
              </xs:complexType>
            </xs:element>

We could also give the comlexType element a name and let the "shoesize" element have a type attribute that refers to the name of the complexType

If you use this method several elements can refer to the same complex type

            <xs:element name = "shoesize" type = "shoetype" />

            <xs:complexType name = "shoetype">
              <xs:simpleContent>
                <xs:extension base = "xs:integer">
                  <xs:attribute name = "country" type = "xs:string" />
                </xs:extension>
              </xs:simpleContent>
            </xs:complexType>

XSD Complex Type With Mixed Content

A mixed complex type element can contain attributes, elements and text.

Example Definitions:

An XML element, "letter", that contains other elements and text

                <letter>
                  Dear Mr.<name>John Smith</name>.
                  Your order <orderid>1032</orderid>
                  will be shipped on <shipdate>2001-07-13</shipdate>.
                </letter>

Notice that the text appears between the elements, "name, "orderid", and "shipdate" which are all children of "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:compexType>
                </xs:element>

To enable character data to appear between the child-elements of "letter" the mixed attribute must be set to "true".... remember the <sequence> tag.

We could also give the complexType element a name and let the "letter" element have a type attribute that refers to the name of the complexType

If you use this method several elements can refer to the same complex type

                <xs:element name = "letter" type = "lettertype" />

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

XSD Indicators

7 types of Indicators to control how elements are to be used in documents

Order Indicators

Order indicators define how elements should occur

All

The <all> indicator specifies by default that the child elements can appear in any order and that each child element must occur once and only once.

Example:

                    <xs:element name = "person">
                      <xs:complexType>
                        <xs:all>
                          <xs:element name = "firstname" type = "xs:string" />
                          <xs:element name = "lastname" type = "xs:string" />
                        </xs:all>
                      </xs:complexType>
                    </xs:element>

Note that 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

Choice

The <choice> indicator specifies that either one child element or another can occur

                    <xs:element name = "person">
                      <xs:complexType>
                        <xs:choice>
                          <xs:element name = "employee" type = "employee" />
                          <xs:element name = "member" type = "member" />
                        </xs:choice>
                      </xs:complexType>
                    </xs:element>

Sequence

The <sequence> indicator specifies that the child elements must appear in a specific order

                    <xs:element name = "person"<
                      <xs:complexType>
                        <xs:sequence>
                          <xs:element name = "firstname" type = "xs:string" />
                          <xs:elmeent name = "lastname" type = "xs:string" />
                        </xs:sequence>
                      </xs:complexType>
                    </xs:element>

Occurance Indicators

The Occurance indicators define how often an element can occur

For all "order" and "Group" indocators, (any, all, choice, sequence group name, and group reference), the default value for maxOccurs and minOccurs is 1.

maxOccurs

The maxOccurs indicator specifies the max number of times an element can occur

                    <xs:element name = "person">
                      <xs:complexType>
                        <xs:sequence>
                          <xs:element name = "full_name" type = "xs:string" />
                          <xs:element name = "child_name" type = "xs:string" maxOccurs = "10" />
                        </xs:sequence>
                      </xs:complexType>
                    </xs:element>

The above example indicates that the "child_name" element can occur a minimum of 1 time, (default), and a maximum of 10 times inside a "person" element

minOccurs

The minOccurs indicator specifies the min number of times an element can occur

                    <xs:element name = "person">
                      <xs:complexType>
                        <xs:sequence>
                          <xs:element name = "full_name" type = "xs:string" />
                          <xs:element name = "child_name" type = "xs:string maxOccurs = "10" minOccurs = "0" />
                        </xs:sequence>
                      </xs:complexType>
                    </xs:element>

The above example indicates the "child_name" element can occur a min of 0 times and a max of 10 times in a "person" element.

To allow an element to appear an unlimited number of times, use the maxOccurs = "unbounded" statement

Example

An XML file called "myfamily.xml"

                  <?xml version="1.0" encoding="ISO-8859-1"?>
                  <persons xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
                  xsi:noNamespaceSchemaLocation="family.xsd">

                  <person>
                    <full_name>Hege Refsnes</full_name>
                    <child_name>Cecilie</child_name>
                  </person>

                  <person>
                    <full_name>Tove Refsnes</full_name>
                    <child_name>Hege</child_name>
                    <child_name>Stale</child_name>
                    <child_name>Jim</child_name>
                    <child_name>Borge</child_name>
                  </person>

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

                  </persons>

The XML file above contains a root element name "persons".

Inside this root element are defined several "person" elements.

Each "person" element must contain a "full_name" child element and it can contain up to 5 "child_name" child elements.

Here is the Schema file "family.xsd":

                  <?xml version="1.0" encoding="ISO-8859-1"?>
                  <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
                  elementFormDefault="qualified">

                    <xs:element name="persons">
                      <xs:complexType>
                        <xs:sequence>
                          <xs:element name="person" maxOccurs="unbounded">
                            <xs:complexType>
                              <xs:sequence>
                                <xs:element name="full_name" type="xs:string"/>
                                <xs:element name="child_name" type="xs:string"
                                minOccurs="0" maxOccurs="5"/>
                              </xs:sequence>
                            </xs:complexType>
                          </xs:element>
                        </xs:sequence>
                      </xs:complexType>
                    </xs:element>
                  </xs:schema>

Group Indicators

Group indicators are used to define related sets of elements

Group name - Defining element groups

                  <xs:group name = "groupname">
                    ...
                  </xs:group>

You must deine an all, choice, or sequence element inside the group declaration.

The following example defines a group named "persongroup" that defines a group of elements that must occur in an exact sequence:

                  <xs:group name="persongroup">
                    <xs:sequence>
                      <xs:element name="firstname" type="xs:string"/>
                      <xs:element name="lastname" type="xs:string"/>
                      <xs:element name="birthday" type="xs:date"/>
                    </xs:sequence>
                  </xs:group>

After you have defined a goup, you can reference it in another goup or complex type definition... like this:

                  <xs:group name="persongroup">
                    <xs:sequence>
                      <xs:element name="firstname" type="xs:string"/>
                      <xs:element name="lastname" type="xs:string"/>
                      <xs:element name="birthday" type="xs:date"/>
                    </xs:sequence>
                  </xs:group>

                  <xs:element name="person" type="personinfo"/>

                  <xs:complexType name="personinfo">
                    <xs:sequence>
                      <xs:group ref="persongroup"/>
                      <xs:element name="country" type="xs:string"/>
                    </xs:sequence>
                  </xs:complexType>

attributeGroup name - Defining Attribute Groups

                  <xs:attributeGroup name = "groupname">
                    ...
                  </xs:attributeGroup>

The following defines an attribute group named "personattrgroup"

                  <xs:attributeGroup name="personattrgroup">
                    <xs:attribute name="firstname" type="xs:string"/>
                    <xs:attribute name="lastname" type="xs:string"/>
                    <xs:attribute name="birthday" type="xs:date"/>
                  </xs:attributeGroup>

After you have defined an attribute group, you can reference it in another group or complex type dedinition... like this:

                  <xs:attributeGroup name="personattrgroup">
                    <xs:attribute name="firstname" type="xs:string"/>
                    <xs:attribute name="lastname" type="xs:string"/>
                    <xs:attribute name="birthday" type="xs:date"/>
                  </xs:attributeGroup>

                  <xs:element name="person">
                    <xs:complexType>
                      <xs:attributeGroup ref="personattrgroup"/>
                    </xs:complexType>
                  </xs:element>

XSD the <any> Element

The <any> element is used to extend XML documents with elements not specified by the schema

The following example is a fragment of an XML schema called "family.xsd".

It shows a declaration for the "person" element.

By using the <any> element you can extend, (after <lastname>), the content of "person" with any element:

          <xs:element name="person">
            <xs:complexType>
              <xs:sequence>
                <xs:element name="firstname" type="xs:string"/>
                <xs:element name="lastname" type="xs:string"/>
                <xs:any minOccurs="0"/>
              </xs:sequence>
            </xs:complexType>
          </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 with an additonal schema file called "children.xsd"

          <?xml version="1.0" encoding="ISO-8859-1"?>
          <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
          targetNamespace="http://www.w3schools.com"
          xmlns="http://www.w3schools.com"
          elementFormDefault="qualified">

          <xs:element name="children">
            <xs:complexType>
              <xs:sequence>
                <xs:element name="childname" type="xs:string"
                maxOccurs="unbounded"/>
              </xs:sequence>
            </xs:complexType>
          </xs:element>

          </xs:schema>

The XML file below called "myfamily.xml" uses components from both schemas

          <?xml version="1.0" encoding="ISO-8859-1"?>

          <persons xmlns="http://www.microsoft.com"
          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
          xsi:SchemaLocation="http://www.microsoft.com family.xsd
          http://www.w3schools.com children.xsd">

            <person>
              <firstname>Hege</firstname>
              <lastname>Refsnes</lastname>
              <children>
                <childname>Cecilie</childname>
              </children>
            </person>

            <person>
              <firstname>Stale</firstname>
              <lastname>Refsnes</lastname>
            </person>
          </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 declard in the main XML schema

XSD The <anyAttribute> Element

The <anyAttribute> element is used to extend XML documents with attributes not specified by the schemas.

The following fragment from an XML schema called "family.xsd" shows a declaration for the "person" element.

By using the <anyAttribute> element you can add any number of attributes to the "person" element.

            <xs:element name="person">
              <xs:complexType>
                <xs:sequence>
                  <xs:element name="firstname" type="xs:string"/>
                  <xs:element name="lastname" type="xs:string"/>
                </xs:sequence>
                <xs:anyAttribute/>
              </xs:complexType>
            </xs:element>

The "gender" attribute is be declared in another schema file/dd>

            <?xml version="1.0" encoding="ISO-8859-1"?>
            <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
            targetNamespace="http://www.w3schools.com"
            xmlns="http://www.w3schools.com"
            elementFormDefault="qualified">

            <xs:attribute name="gender">
              <xs:simpleType>
                <xs:restriction base="xs:string">
                  <xs:pattern value="male|female"/>
                </xs:restriction>
              </xs:simpleType>
            </xs:attribute>

            </xs:schema>

And in the XML file, reference to both schema's will add the "gender" attribute onto the "person" element

            <?xml version="1.0" encoding="ISO-8859-1"?>

            <persons xmlns="http://www.microsoft.com"
              xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
              xsi:SchemaLocation="http://www.microsoft.com family.xsd
              http://www.w3schools.com attribute.xsd">
              <person gender="female">
                <firstname>Hege</firstname>
                <lastname>Refsnes</lastname>
              </person>
              <person gender="male">
                <firstname>Stale</firstname>
                <lastname>Refsnes</lastname>
              </person>
            </persons>

XSD Element Substitution

Using the substitutionGroup attribute

Example 1:

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

In the above example the "name" element is the head element and the "navn" element is a substitution for "name".

Example 2:

XSD file

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

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

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

Possible XML declarations

          <customer>
            <name>Doug Allard</name>
          </customer>

          <kunde>
            <navn>Doug Allard</navn>
          </kunde>

Blocking Element Substitution

To prevent other elements from substituting with a specified element use the block attribute

Example 1:

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

Example 2:

              <xs:element name="name" type="xs:string" block="substitution"/>
              <xs:element name="navn" substitutionGroup="name"/>

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

              <xs:element name="customer" type="custinfo" block="substitution"/>
              <xs:element name="kunde" substitutionGroup="customer"/>

Only this XML declaration would be valid

              <customer>
                <name>Doug Allard</name>
              </customer>

The type of the substitution elements must be the same as, or derived from, the type of the head element.

If the types are the same, you will not have to specifiy the type of the subsitution element

Global elements are elements that are immediate children of the "schema" element

Local elements are elements nested within other elements

Examples

)

Given the following XML "shiporder.xml"

              <?xml version="1.0" encoding="ISO-8859-1"?>

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

The XML document consists of a root element, "shiporder", that contains a required attribute called "orderid".

The "shiporder" element contains 3 different child elements, "orderperson", "shipto", and "item".

The "item" element appears twice and it contains a "title", an optional "note", a "quantity" and "price" elements.

The line, 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 the same folder as "shiporder.xml".

To create the Schema for the above XML by following the XML's structure

1) Create a new file called "shiporder.xsd".

Start the definition with the standard XML declaration
followed by the xs:schema element used to define schemas.

                <?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.

2) Define the "shiporder" element.

This element has an attribute and contains other elements
therefore it is a complex type.

The child elements of "shiporder" are surrounded by an 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>

3) Define the "orderperson" element.

It is a simple type (no attributes or other elements).

The type, xs:string, is prefixed with the namespace prefix
associated with XML Schema indicating a predefined schema data type

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

4) Define the "shipto" element.

It is a complex element type

                <xs:element name="shipto">
                 <xs:complexType>
                  <xs:sequence>
                   <xs:element name="name" type="xs:string"/>
                   <xs:element name="address" type="xs:string"/>
                   <xs:element name="city" type="xs:string"/>
                   <xs:element name="country" type="xs:string"/>
                  </xs:sequence>
                 </xs:complexType>
                </xs:element>

With schemas we can define the number of possible occurrences for
an element with the maxOccurs and the minOccurs attributes.

The default value for both is 1

5) Define the "item" element

It is a complex type and can appear multiple times inside
a "shiporder" element because maxOccurs is set to "unbounded".

The "note" element is optional because minOccurs is 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>

7) Declare the attribute "orderid" of the "shiporder" element.

Since this is a required attribute we specify use="required".

Note that the attribute declarations must always come last.

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

Here is the complete schema

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

                <xs:element name="shiporder">
                 <xs:complexType>
                  <xs:sequence>
                   <xs:element name="orderperson" type="xs:string"/>
                   <xs:element name="shipto">
                    <xs:complexType>
                     <xs:sequence>
                      <xs:element name="name" type="xs:string"/>
                      <xs:element name="address" type="xs:string"/>
                      <xs:element name="city" type="xs:string"/>
                      <xs:element name="country" type="xs:string"/>
                     </xs:sequence>
                    </xs:complexType>
                   </xs:element>
                   <xs:element name="item" maxOccurs="unbounded">
                    <xs:complexType>
                     <xs:sequence>
                      <xs:element name="title" type="xs:string"/>
                      <xs:element name="note" type="xs:string" minOccurs="0"/>
                      <xs:element name="quantity" type="xs:positiveInteger"/>
                      <xs:element name="price" type="xs:decimal"/>
                     </xs:sequence>
                    </xs:complexType>
                   </xs:element>
                  </xs:sequence>
                  <xs:attribute name="orderid" type="xs:string" use="required"/>
                 </xs:complexType>
                </xs:element>

                </xs:schema>

Dividing the Schema can make it easier

Define all elements and attributes first, then refer to them using the ref attribute

                <?xml version="1.0" encoding="ISO-8859-1" ?>
                <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
                
                <xs:element name="orderperson" type="xs:string"/>
                <xs:element name="name" type="xs:string"/>
                <xs:element name="address" type="xs:string"/>
                <xs:element name="city" type="xs:string"/>
                <xs:element name="country" type="xs:string"/>
                <xs:element name="title" type="xs:string"/>
                <xs:element name="note" type="xs:string"/>
                <xs:element name="quantity" type="xs:positiveInteger"/>
                <xs:element name="price" type="xs:decimal"/>
                
                <xs:attribute name="orderid" type="xs:string"/>
                
                <xs:element name="shipto">
                 <xs:complexType>
                  <xs:sequence>
                   <xs:element ref="name"/>
                   <xs:element ref="address"/>
                   <xs:element ref="city"/>
                   <xs:element ref="country"/>
                  </xs:sequence>
                 </xs:complexType>
                </xs:element>
                <xs:element name="item">
                 <xs:complexType>
                  <xs:sequence>
                   <xs:element ref="title"/>
                   <xs:element ref="note" minOccurs="0"/>
                   <xs:element ref="quantity"/>
                   <xs:element ref="price"/>
                  </xs:sequence>
                 </xs:complexType>
                </xs:element>

                <xs:element name="shiporder">
                 <xs:complexType>
                  <xs:sequence>
                   <xs:element ref="orderperson"/>
                   <xs:element ref="shipto"/>
                   <xs:element ref="item" maxOccurs="unbounded"/>
                  </xs:sequence>
                  <xs:attribute ref="orderid" use="required"/>
                 </xs:complexType>
                </xs:element>

                </xs:schema>

Or you can use Named Types to define classes or types which allows you to reuse element definitions. This is done by nameing the simpleTypes and complexTypes elements and then pointing to them with the type attribute of the element.

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

                <xs:simpleType name="stringtype">
                 <xs:restriction base="xs:string"/>
                </xs:simpleType>

                <xs:simpleType name="inttype">
                 <xs:restriction base="xs:positiveInteger"/>
                </xs:simpleType>

                <xs:simpleType name="dectype">
                 <xs:restriction base="xs:decimal"/>
                </xs:simpleType>

                <xs:simpleType name="orderidtype">
                 <xs:restriction base="xs:string">
                  <xs:pattern value="[0-9]{6}"/>
                 </xs:restriction>
                </xs:simpleType>

                <xs:complexType name="shiptotype">
                 <xs:sequence>
                  <xs:element name="name" type="stringtype"/>
                  <xs:element name="address" type="stringtype"/>
                  <xs:element name="city" type="stringtype"/>
                  <xs:element name="country" type="stringtype"/>
                 </xs:sequence>
                </xs:complexType>

                <xs:complexType name="itemtype">
                 <xs:sequence>
                  <xs:element name="title" type="stringtype"/>
                  <xs:element name="note" type="stringtype" minOccurs="0"/>
                  <xs:element name="quantity" type="inttype"/>
                  <xs:element name="price" type="dectype"/>
                 </xs:sequence>
                </xs:complexType>

                <xs:complexType name="shipordertype">
                 <xs:sequence>
                  <xs:element name="orderperson" type="stringtype"/>
                  <xs:element name="shipto" type="shiptotype"/>
                  <xs:element name="item" maxOccurs="unbounded" type="itemtype"/>
                 </xs:sequence>
                 <xs:attribute name="orderid" type="orderidtype" use="required"/>
                </xs:complexType>

                <xs:element name="shiporder" type="shipordertype"/>

                </xs:schema>

The restriction element indicates that the datatype is derived from a W3C
XML Schema namespace datatype so the fragment <xs:restriction base = "xs:string"> means that the value of the element or attribute must be a string value.

The restriction element is more often used to apply restrictions on elements.

                <xs:simpleType name="orderidtype">
                 <xs:restriction base="xs:string">
                  <xs:pattern value="[0-9]{6}"/>
                 </xs:restriction>
                </xs:simpleType>

The above indicates that the value of the element or attribute must be a string and it must be exactly six characters in a row with values ranging from 0 to 9.

XSD String Datatypes

The String datatype can contain characters, line feeds, charriage returns, and tabs

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

The corresponding XML element might look like this

            <customer>Doug Allard</customer>

Or look like this

            <customer>    Doug Allard    </customer>

The XML procesor will not modify the value of string datatypes

normalizedString Datatypes
It is derived from the String datatype

It can also contain characters but the XML processor will remove line feeds, and carriage returns, and replace tabs with spaces.
```
                <xs:element name = "customer" type = "xs:normalizedString" />
              
```
token datatypes
token is also derived from the string datatype.

It can also contain characters, but the XML processor will remove line feeds, carriage returns, tabs, leading/trailing spaces and multiple spaces.
```
                <xs:element name = "customer" type = "xs:token" />
              
```

String Datatypes

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
language	String that contains a valid language id
Name	String that contains a valid XML name
NCName
NMTOKEN	String that represents the NMTOKEN attribute in XML Only used with schema attributes
NMTOKENS
normalizedString	String that doesn't contain line feeds, carriage returns, or tabs
QName
string	A string
token	A string that doesn't contain lie feeds, carriage returns, tabs, leading/trailing or multiple spaces

Restrictions that can be used on String Datatypes

enumeration

length

maxLength

minLength

pattern (NMTOKENS, IDREFS, and ENTITIES cannot use this constraint)

whiteSpace

XSD Date and Time Datatypes

Date: specified by "CCYY-MM-DD"

All components are required.

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

The XML element might look like this

            <start>2002-09-24</start>

Time Zones

To specify a time zone you acn enter a date in UTC time by adding a "Z"

                <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

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

Time Datatypes

Time is specified by "hh:mm:ss".

All components are required.

Example:

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

The element might look like this:

                <start>09:30:10</start>

                <start>09:30:10.5</start>

Time Zone Entry is the same as with dates.

DateTime Datatypes

Specified with "CCYY-MM-DDThh:mm:ss"

All components are required

Time Zones apply
Duration Datatype
Used to specify a time interval

Specified with "PnYnMnDTnHnMnS"

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 the time specification

nH indicates the number of hours

nM indicates the number of minutes

nS indicates the number of seconds

Example:
```
                <xs:element name = "period" type = "xs:duration" />
              
```
The document element might look like this
```
                <period>P5Y</period>
              
```
```
                <period>P5Y2M10D</period>
              
```
period = 5 years, 2 months and 10 days
```
                <period>P5Y2M10DT15H</period>
              
```
period = 5 years, 2 months, 10 days and 15 hours

To specify a negative duration put a - in front of the P
```
                <period>-P10D</period>
              
```
This indicates a period of minus 10 days

Date and Time Datatypes

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 - teh year (CCYY)
gYearMonth	Defines a part of a date - teh year and month (CCYY-MM)
time	defines a time value

Restrictions that apply on Date Datatypes

enueration

maxExclusive

maxInclusive

minExclusive

minInclusive

pattern

whiteSpace

XSD Numeric Datatypes

Decimals

Example:

              <xs:element name = "price" type = "xs:decimal" />

The XML elements might look like these:

              <price>999.50</price>
              <price>+999.5450</price>
              <price>-999.5230</price>
              <price>0</price>
              <price>14</price>

The maximum numbers you can specify is 18

Integers

Example:

              <xs:element name = "price" type = "xs:integer" / >

The XML elements might look like these

              <price>999</price>
              <price>+999</price>
              <price>-999</price>
              <price>0</price>

Numeric Datatypes

All the data types below are derived from the Decimal datatype

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
nonNegativeInteger	An integer containing only non negative values
nonPositiveInteger	An inteer containing only non-positive values
positiveInteger	An integer containing only positive values
short	A signed 16 bit integer
unsignedLong	An unsigned 64 bit integer
unsignedInt	An unsigned 32 bit integer
unsignedShort	An unsigned 15 bit integer
unsignedByte	An unsigned 8 bit integer

Restrictions that apply to Numeric Datatypes

enumeration

fractionDigits

maxExclusive

maxInclusive

minExclusive

minInclusive

pattern

totalDigits

whiteSpace

XSD Micsellaneious Datatypes

Boolean Datatype

Used to specify true or false

              <xs:attribute name = "disabled" type = "xs:boolean" />

The corresponding XML element might look like this

              <price disabled = "true">999</price>

Legal values are true, false, 1, 0

Binary Datatype

Used to express binary formatted data

They can be base64Binary or hexBinary

Example:

              <xs:element name = "blobarc" type = "xs:hexBinary" />

AnyURI Datatype

Used to specify a URI

              <xs:attrib name = "src" type = "xs:anyURI" />

The corresponding XML element might look like this

              <pic src = "http://www.w3schools.com/images/smiley.gif" />

If a URI has spaces, replace them with %20

Miscellaneous Datatypes

Name	Description
anyURI
base64Binary
boolean
double
float
hexBinary
NOTATION
QName

Restrictions that apply to Miscellaneous Datatypes

enumeration (except boolean)

length (except boolean)

maxLength (except boolean)

minLength (except boolean)

pattern

whiteSpace

Hosted by www.Geocities.ws