Язык XML Schema (XSD)

Будилов В.

Ранее мы уже многократно сталкивались с форматом XML. Язык XML позволяет определять документы в широком диапазоне возможностей описания хранимых данных. Полезно бывает иметь средство, позволяющее проверить корректность того или иного XML-документа. Чтобы такая проверка стала возможной, необходимо иметь описание структуры XML-документа. Описание структуры XML-документа можно осуществить при помощи нескольких общепринятых механизмов, одним из которых является язык XML Schema.

Язык XML Schema создан для описания структуры XML документа. Он представляет собой альтернативу языку DTD. Для языка XML Schema часто используется альтернативное название XSD, что является аббревиатурой слов XML Schema Definition. Чтобы понять то, как устроен язык XSD, необходимо иметь представление о языке XML и о пространствах имен namespaces.

Язык XSD определяет, из каких элементов может состоять XML документ, какие атрибуты могут быть заданы для того или иного элемента, какие дочерние элементы может содержать тот или иной элемент, определяя вложенность дочерних элементов друг в друга, количество допустимых дочерних элементов, может ли элемент быть пустым или должен включать текст, задает типы данных для элементов и атрибутов, устанавливает значения элементов и атрибутов, используемых по умолчанию.

Предполагается, что язык XSD вытеснит DTD в сфере разработки Web приложений. Такое заключение основывается на следующих фактах. XML Schema – это расширяемый язык, он много богаче, чем DTD; он создан на основе XML, в нем поддерживаются типы данных и пространства имен. XML Schema является официальным стандартом, рекомендованным консорциумом W3C.

Помимо этих причин, существует целый ряд факторов, которые делают язык XSD более привлекательным в сравнении с DTD. С помощью XSD описание допустимых в документе элементов осуществляется наиболее легко, легче производится проверка документа на корректность, легче производится работа с данными из баз данных. В нем легче определять ограничения, которые необходимо выполнять при работе с данными, а также легче задавать форматы используемых данных, легче производить преобразования данных от одного типа в другой.

Существуют также и другие преимущества. Поскольку XSD написан на XML, то нет необходимости изучать какой-либо совершенно новый язык. Для редактирования файлов XSD можно использовать наиболее подходящий и понравившийся вам редактор XML файлов. Для проверки созданных файлов можно использовать XML парсер, можно манипулировать элементами XSD файла с использованием объектной модели XML DOM. Наконец, файл XML Schema можно преобразовывать с помощью XSLT. С применением XSD увеличивается уровень безопасности, поскольку при передаче сообщений как отправитель, так и получатель предполагают, что структура документа будет такой, как они ее себе «представляют». Созданные XSD файлы могут быть использованы неоднократно и повторно, вставлены в новые файлы XSD, типы, используемые в XSD, могут быть произвольными, основанными на стандартных типах, один и тот же документ XML может иметь ссылки на различные документы XML Schema.

Каждый документ XSD должен быть корректно составлен, но этого еще недостаточно. Корректность документа подразумевает, что в этом документе соблюдаются следующие правила:

Документ должен начинаться с объявления того, что это документ XML;
Документ должен иметь единственный корневой элемент;
Каждому открывающему тегу должен соответствовать парный ему закрывающий тег;
В документе должно быть учтено, что названия тегов чувствительны к регистру;
Элементы должны быть корректно вложены друг в друга;
Все значения атрибутов должны быть указаны в кавычках;
Для отображения специальных символов должны быть использованы сущности.

XML документы могут содержать ссылки на документы DTD или XML Schema.
В качестве примера будем рассматривать XML документ, содержащий заметку (файл zametka.xml).

Файл zametka.xml

<?xml version="1.0"?>
<zametka>
<to>Tebe</to>
<from>Otmenya</from>
<heading>Napominanie</heading>
<body>Ne zabud!</body>
</zametka>

С этим файлом можно связать документ DTD (файл zametka.dtd), который будет определять структуру XML документа.

Фргамент файла zametka.dtd

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

В этом файле в первой строке записано, что элемент zametka может состоять из четырех вложенных в него элементов: "to, from, heading, body". В следующих строках определено, что элемент to состоит из данных типа PCDATA, равно как и все другие элементы.

Вместо описания DTD документ zametka.xml может быть описан средствами XSD. Описание приведено в файле zametka.xsd.

Файл zametka.xsd

<?xml version="1.0"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
targetNamespace="http://www.e-olymp.com"
xmlns="http://www.e-olymp.com"
elementFormDefault="qualified">
<xs:element name="zametka">
<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>

В файле указано, что элемент zametka имеет сложный тип.
Ссылка на файл DTD вставляется так, как показано в примере ниже.

<?xml version="1.0"?>
<!DOCTYPE note SYSTEM
"zametka.dtd">
<zametka>
<to>Tebe</to>
<from>Otmenya</from>
<heading>Napominanie</heading>
<body>Ne zabud!</body>
</zametka>

Здесь мы вставили ссылку на файл zametka.dtd во второй и третьей строках. Аналогичным способом делается ссылка на документ XSD (файл zametkaxsd.xml).

Файл zametkaxsd.xml

<?xml version="1.0"?>
<zametka
xmlns="http://www.e-olymp.com"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation=
"http://www.e-olymp.com zametka.xsd">
<to>Tebe</to>
<from>Otmenya</from>
<heading>Napominanie</heading>
<body>Ne zabud!</body>
</zametka>

Здесь ссылка указывается в виде атрибутов корневого элемента. Рассмотрим строение документов XSD более подробно.

Элемент <schema>

Элемент <schema> - это корневой элемент всякого документа XML Schema:
<?xml version="1.0"?>
<xs:schema>
...
...
</xs:schema>

Элемент <schema> может иметь некоторые атрибуты, например:

<?xml version="1.0"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
targetNamespace="http://www.e-olymp.com.com"
xmlns="http://www.e-olymp.com"
elementFormDefault="qualified">
...
...
</xs:schema>

Фрагмент кода xmlns:xs=http://www.w3.org/2001/XMLSchema задает пространство имен. Это пространство имен будет связано со всеми элементами и данными, используемыми в данном документе XSD. Все элементы, которые связываются с данным пространством имен, будут содержать префикс xs.

Фрагмент targetNamespace=http://www.e-olymp.com показывает, что все элементы документа (в нашем случае такими элементами будут zametka, to, from, heading, body), относятся к пространству имен "http://www.e-olymp.com".

В документе zametkaxsd.xml мы имеем ссылку на документ zametka.xsd. Здесь фрагмент xmlns= “http://www.e-olymp.com.com” задает пространство имен, используемое по умолчанию. Эта запись сообщает, что все элементы, используемые в документе XML , будут относиться именно к этому пространству имен.

Фрагмент xmlns:xsi=”http://www.w3.org/2001/XMLSchema-instance” сообщает, что значение атрибута schameLocation должно рассматриваться в контексте пространства имен XMLSchema-instance.

Фрагмент xsi:schemaLocation=”http://www.e-olymp.com zametka.xsd” сообщает, что пространство имен http://www.e-olymp.com определено в документе zametka.xsd.

Простые элементы

В документе XSD описываются элементы, из которых может состоять файл XML. Простым элементом называется такой элемент, который может состоять только из простого текста. Простой элемент не может содержать дочерних элементов и атрибутов. «Простым текстом» может быть булев литерал, строка, дата и т.п. В качестве простого текста может выступать пользовательский тип данных, определенный разработчиком. Можно наложить определенные ограничения на тип используемых в простом текстовом элементе данных.

Синтаксис описания простого элемента несложен.

Синтаксис описания простого элемента

<xs:element name="xxx" type="yyy"/>

Здесь xxx будет именем элемента, а ууу – типом данных, используемых в элементе. Пусть в XML файле используются такие элемент, как показано ниже:

Пример простых элементов

<familiya>Petrov</familiya>
<vozrast>34</vozrast>
<datarozhdeniya>1968-03-27</datarozhdeniya>

Описание этих элементов (это простые элементы) может быть осуществлено таким способом.

Пример описания простых элементов

<xs:element name="familiya" type="xs:string"/>
<xs:element name="vozrast" type="xs:integer"/>
<xs:element name="datarozhdeniya" type="xs:date"/>

Здесь везде указывается префикс xs, т.е. XML Schema.

Стандартные типы данных, используемых в XML Schema.

В языке XML Schema используется большое количество встроенных типов данных. Ниже приведены наиболее употребительные типы:

xs:string
xs:decimal
xs:integer
xs:boolean
xs:date
xs:time

Простые элемент могут содержать величины по умолчанию, в них также может быть указан фиксированный набор допустимых элементов. Величина, описанная как величина, используемая по умолчанию, будет автоматически использована, если не указано иное значение. Например,

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

Фиксированное значение присваивается элементу автоматически без всяких условий. В примере ниже это значение “red”:

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

Атрибуты в XSD

Атрибуты могут иметь только сложные элементы. Все атрибуты объявляется только в виде простых типов. Синтаксис при определении атрибутов таков:

<xs:attribute name="xxx" type="yyy"/>

Здесь xxx – это имя атрибута, yyy –тип данных, соответствующий атрибуту. Пусть, например, XML файл имеет такой элемент, как ниже

<lastname lang="EN">Smith</lastname>

Соответствующее описание атрибута может выглядеть так:

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

Атрибут по умолчанию можно описать следующим образом:

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

Фиксированный атрибут будет описан так:

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

Атриубт может быть описан, как необязательный:

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

Атрибут может быть описан и как обязательный:

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

Можно установить ограничения на содержимое атрибутов. Так, если, тип описан в виде xs:date, то текст, например, такой как «Привет всем!» использовать в качестве значения этого атрибута нельзя.

Ограничения на элементы и атрибуты

Ограничения ограничивают допустимые типы, используемые в качестве значений элементов и атрибутов.

Ограничения на значения

Следующий пример показывает, как можно использовать ограничения, накладываемые на допустимые значения:

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

Перечисляемый набор значений

Значения могут быть заданы в виде набора допустимых величин, как в примере ниже.

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

В качестве значения элемента car могут использоваться значения Audi, Golf или BMW.
Этот пример можно переписать в другом виде:

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

По смыслу результат оказывается таким же.

Ограничения на наборы значений

Можно ограничить использование в значениях тех или иных наборов данных. Например:

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

Здесь в качестве значения элемент letter может быть использован только один символ, соответствующий маленькой букве из промежутка от a до z.
Вот еще один пример:

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

Здесь в качестве значения элемента initials можно использовать только три заглавные буквы.
Чтобы иметь возможность использовать не только заглавные буквы, но и маленькие, запишем так:

<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>
</xs:simpleType>
</xs:element>

В следующем примере в качестве значения элемента choice можно использовать одну из трех букв: x, y или z.

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

Чтобы значением элемента prodid был набор из пяти десятичных цифр, создадим такое описание:

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

Ниже приведен еще один пример задания ограничения на используемые величины:

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

Здесь в качестве значения элемента letter может быть использовано произвольное количество маленьких букв (от нуля и более).

Пример ниже показывает, что элемент letter начинается с одного или нескольких символов маленьких букв, за которыми (которым) следует заглавная буква:

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

Пол может быть описан, как элемент gender, значением которого может быть либо male, либо female.

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

Пароль, состоящий ровно из 8 символов букв верхнего и нижнего регистра, а также цифр, описан как элемент password:

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

Модно вводить ограничения на количество используемых символов пробелов. В примере ниже все пробелы, используемые в файле XML , останутся без изменений и не будут удалены процессором XML:

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

В следующем примере будут удалены все символы пробелов, соответствующие переводам строк, табуляциям и возвратам каретки, и они будут заменены на символ простого пробела:

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

Существуют другие типы ограничений, в том числе ограничения по длине элемента. Здесь можно использовать ограничения length, maxLength, minLength.
Чтобы пароль был длиной ровно 8 знаков, можно записать так:

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

Чтобы ограничить пароль в пределах от 5 до 8 знаков, запишем следующим образом:

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

Сведем в таблицу рассмотренные типы ограничений (табл.1).

Таблица 1. Ограничения на данные.
whiteSpace Задает способ обработки пробелов (line feeds, tabs, spaces, carriage return)

Ограничение	Описание
enumeration	Задает список допустимых величин
fractionDigits	Задает максимальное количество допустимых десятичных знаков (должно быть не меньше нуля).
length	Задает количество элементов (не меньше нуля).
maxExclusive	Задает верхнее ограничение для чисел (значение должно быть меньше его).
maxInclusive	Задает верхнее ограничение для чисел (значение должно быть не больше его).
maxLength	Задает максимальное количество символов или элементов в списке (не меньше нуля).
minExclusive	Задает нижнее ограничение для чисел (значение должно быть больше его).
minInclusive	Задает нижнее ограничение для чисел (значение должно быть не меньше его).
minLength	Задает минимальное количество символов или элементов в списке (не меньше нуля).
pattern	Задает шаблон – допустимую последовательность символов
totalDigits	Задает допустимое количество цифр (не меньше 0).

Сложные элементы XSD

Сложные элементы XML могут содержать дочерние элементы и/или атрибуты. Существует четыре типа сложных элементов.

Пустые элементы.
Элементы, содержащие дочерние элементы.
Элементы, содержащие только текст.
Элементы, которые содержат как дочерние элементы, так и текст.

Каждый из перечисленных элементов может содержать атрибуты.
Пример пустого элемента:

Пример элемента, содержащего другие элементы:

<employee>
<firstname>John</firstname>
<lastname>Ivanov</lastname>
</employee>

Пример элемента, содержащего только текст:

<food type="dessert">Morozhenoe</food>

Пример элемента, содержащего как текст, так и другие элементы:

<description>
Eto sluchilos lang="norwegian">17.10.02</date>
....
</description>

Описание сложного элемента

Пусть элемент employee выглядит таким образом:

<employee>
<firstname>John</firstname>
<lastname>Smith</lastname>
</employee>

Этот элемент можно описать при помощи XSD несколькими способами.

Способ 1.

Прямое задание элементов:

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

Способ 2.

Указание атрибутов, которые имеют ссылку на заданный тип:

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

При этом несколько элементов могут ссылаться на один и тот же сложный тип, например:

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

Сложный элемент может быть основан на уже существующем сложном элементе, при этом можно добавить новые элементы:

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

Пустой элемент может содержать атрибуты, но в нем не может быть записано содержание, расположенное между открывающим я закрывающим тегами.

Пусть задан пустой элемент product, который в XML файле выглядит так: <product prodid="1345" />

Такой элемент может быть описан в файле XSD следующим образом:

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

В этом примере мы задали тип complexType с указанием сложного контекста complexContent.
Этот элемент, однако, можно описать более компактно следующим образом:
<xs:element name="product">
<xs:complexType>
<xs:attribute name="prodid" type="xs:positiveInteger"/>
</xs:complexType>
</xs:element>

Можно также указать имя для элемента complexType, а в теге элемента с именем product указать тип, который будет ссылаться на заданное имя: <xs:element name="product" type="prodtype"/>
<xs:complexType name="prodtype">
<xs:attribute name="prodid" type="xs:positiveInteger"/>
</xs:complexType>

Элементы в XSD, которые состоят только из дочерних элементов

Элемент XML может быть описан так, что этот элемент может состоять только из дочерних элементов. В примере ниже элемент person может состоять из элементов firstname и lastname.

<person>
<firstname>John</firstname>
<lastname>Ivanov</lastname>
</person>

Этот элемент может быть описан средствам XML Schema следующим образом:

<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:complexType>
</xs:element>

Здесь встречается тег <xs:sequence>, он задает порядок появления элементов в документе.
Порядок будет такой же, как и в описании XSD.
Этот элемент может быть описан иначе:

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

Элементы, содержащие только текст

Сложные элементы, содержащие только тест, могут иметь атрибуты. Например:

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

Можно описать текстовый сложный элемент по-другому:

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

В XML документе текстовый элемент с атрибутом может выглядеть, например, так:

Этот элемент может быть описан с использованием средств XSD следующим образом:

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

Его можно описать также и другим способом:

<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

В языке XML Schema существует возможность описания того, как элементы XML должны быть использованы внутри XML документа. Для этого в XSD используются индикаторы. Мы уже с ними встречались ранее. Перечислим индикаторы, представив их по типам.

Индикаторы порядка вхождений

К индикаторам порядка вхождений относятся следующие индикаторы:

All
Choice
Sequence

Индикаторы количества вхождений

Индикаторы количества вхождений устанавливают минимальное и максимальное число вхождений описываемого элемента:

maxOccurs
minOccurs

Индикаторы групп

Индикаторы имен группы задают имена группы и атрибута группы:

Group name
attributeGroup name

Индикаторы порядка вхождений

Индикаторы порядка вхождений определяет порядок появления элементов внутри сложного элемента.

Индикатор all

Индикатор <xs:all> показывает, что элементы, описанные внутри элемента xs:all, могут появляться в произвольном порядке и количество вхождений каждого элемента произвольно. Пример использования индикатора <xs:all>:

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

Если используется индикатор <all>, то допускается использованием индикатора <minOccurs>, значением которого должно быть либо 0, либо 1, а также индикатора <maxOccurs>, значением которого должно быть 1 (об этих индикаторах см. далее).

Индикатор выбора choice

Индикатор выбора <choice> указывает, что может быть использован один из описанных внутри этого индикатора элементов:

<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

Индикатор последовательности вхождений XML элементов <sequence> задает фиксированный порядок вхождений описываемых элементов:

<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:complexType>
</xs:element>

Индикаторы количества вхождений

Индикаторы количества вхождений показывают, сколько раз должен использовать тот или иной элемент. При этом для индикаторов any, all, choice, sequence, groupname значением по умолчанию для параметров maxOccurs и minOccurs будет 1.

Индикатор maxOccurs

Индикатор <maxOccurs> задает минимальное количество вхождений описываемого элемента:

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

Этот пример показывает, что элемент child_name может быть использован не менее одного раза. Максимальное количество вхождений этого элемента будет 10.

Индикатор minOccurs

Индикатор <minOccurs> задает минимальное количество вхождений описываемого элемента:

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

Здесь минимальное число вхождений элемента child_name – 0, максимальное - 10. Для того, чтобы позволить неограниченное число вхождений элемента задаем такое значение ограничителя:

maxOccurs="unbounded"

В качестве примера рассмотрим файл semya.xml.

Файл semya.xml

<?xml version="1.0"?>
<persons xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:noNamespaceSchemaLocation="semya_1.xsd">
<person>
<full_name>Petr Ivanov</full_name>
<child_name>Sveta</child_name>
</person>
<person>
<full_name>Marina Ivanova</full_name>
<child_name>Vanya</child_name>
<child_name>Tolya</child_name>
<child_name>Andrej</child_name>
<child_name>Galina</child_name>
</person>
<person>
<full_name>Andrej Ivanov</full_name>
</person>
</persons>

Корневым элементом здесь является элемент persons. Внутри этого элемента определяется несколько элементов person. Каждый элемент person может иметь не более пяти дочерних элементов child_name и один элемент full_name.
Ниже приведен файл semya_1.xsd, описывающий документ semya.xml.

Файл semya_1.xsd

<?xml version="1.0"?>
<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

Индикатор группы <xs:group> используется для задания объединенных в группу элементов. Элементы группы определяются следующим образом:

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

Внутри группы необходимо задать индикатор порядка вхождения элементов, т.е. один из индикаторов all, choice, 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>
<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

Группа атрибутов описывается с использованием тега <attributeGroup>, например:

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

Внутри тела элемента, описывающего группу атрибутов, должны быть помещены описания атрибутов:

После того, как группа атрибутов описана, ссылку на нее можно использовать в другой группе или при описании сложного элемента:

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

Элемент any

Элемент <any> используется для того, чтобы сообщить, что в XML документе можно использовать теги, не описанные в XML Schema. Переопределим документ semya.xml, зададим файл semya_2.xsd следующим образом.

Файл semya_2.xsd

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

Сейчас в соответствующем XML документе допускается использование произвольных элементов.
Рассмотрим другой файл XML Schema, пусть это будет файл children.xsd. Затем мы рассмотрим пример XML файла в котором есть ссылки на два файла xsd.

Файл children.xsd

<?xml version="1.0" encoding="ISO-8859-1"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
targetNamespace="http://www.e-olymp.com"
xmlns="http://www.e-olymp.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>

Файл moyasemya.xml содержит ссылки как на файл semya_2.xsd, так и на файл children.xsd.

Файл moyasemya.xsd

<?xml version="1.0"?>
<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.e-olymp.com children.xsd">
<person>
<firstname>Petr</firstname>
<lastname>Ivanov</lastname>
<children>
<childname>Sveta</childname>
</children>
</person>
<person>
<firstname>MArina</firstname>
<lastname>Ivanova</lastname>
</person>
</persons>

Элемент anyAttribute

С помощью элемента <anyAttribute> можно описать такой XML документ, в котором можно использовать атрибуты, не указанные в документе XML Schema. Перепишем файл moyasemya.xsd, новый файл назовем moyasemya1.xsd.

Файл moyasemya1.xsd

С учетом возможности установления произвольных атрибутов в XML файлах переделаем файл children.xsd, новый файл назовем children1.xsd.

Файл children1.xsd

С учетом новых возможностей приведем новый пример, XML код которого сохранен в файле moyasemya1.xml.

Файл moyasemya1.xml

<?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.e-olymp.com children.xsd">
<person gender="female">
<firstname>Hege</firstname>
<lastname>Refsnes</lastname>
<children>
<childname>Cecilie</childname>
</children>
</person>
<person gender="male">
<firstname>Stale</firstname>
<lastname>Refsnes</lastname>
</person>
</persons>

Подстановка элементов

XML Schema позволяет описать XML файл, в котором вместо одного элемента может быть использован другой элемент. Предположим, что мы используем формы в двух вариантах – в русском и польском. Мы можем, например, сделать так, что пользователь может на свой выбор использовать либо русский, либо польский вариант. Для этого мы воспользуемся в файле XML Schema элементом substitutionGroup.

В начале мы определим элемент, а потом определим другой элемент, который может быть использован в качестве заменителя для первого элемента. Например,

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

Здесь элемент name может быть заменен элементом drugojname.
Используем для описания XML документа следующий фрагмент XSD:

<xs:element name="name" type="xs:string"/>
<xs:element name="name1" 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"/>

В соответствии с этим описанием в качестве элемента (соответствующего, например, покупателю), можно использовать либо такой элемент:

<customer>
<name>John Popoff</name>
</customer>

либо такой элемент

<kunde>
<navn>Adolf Schtierlitz</navn>
</kunde>

Блокировка подстановки элементов

Чтобы запретить возможность замены одного элемента другим в том или ином элементе, используется атрибут block. Например,

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

В качестве примера приведем следующее описание:

<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"/>

Такому описанию может соответствовать следующий фрагмент XML документа:

<customer>
<name>John Smirnoff</name>
</customer>

Вместо него нельзя использовать другой элемиент, т.е. элемент, например, такой, как приведен ниже:

<kunde>
<navn>Hitler Kaput</navn>
</kunde>

Примеры XSD документов

В этом разделе мы рассмотрим примеры. Первым примером будет документ XML, сохраненный в файле order.xml.

Файл order.xml

<?xml version="1.0"?>
<order orderid="889923"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:noNamespaceSchemaLocation="order.xsd">
<orderperson>Ivan Petrov</orderperson>
<shipto>
<name>Sveta Sidorov</name>
<address>Ulitsa 23</address>
<city>777777 Gorod</city>
<country>Strana</country>
</shipto>
<item>
<title>Super kniga</title>
<note>Special Edition</note>
<quantity>1</quantity>
<price>10.90</price>
</item>
<item>
<title>Esche odna kniga</title>
<quantity>1</quantity>
<price>9.90</price>
</item>
</order>

Здесь в качестве атрибута было использовано имя orderid". Элемент "order" включает в себя три дочерних элемента "orderperson", "shipto", "item". Элемент "item" появляется два раза и содержитв себе дочерние элементы "quantity" и "price". Строка xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" сообщает XML процессору, что этот документ должен быть проверен на соответствие с заданным описанием XML Schema, а местоположение соответствующего файла задается в виде xsi:noNamespaceSchemaLocation="order.xsd" (файл XSD расположен в той же папке что и исходный файл "order.xml"). Сейчас мы создадим файл order.xsd. Начнем с начала.

«Эскиз» файла order.xsd

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

</xs:schema>

Здесь мы записали корневой элемент и определили пространство имен, соответствующее формату XML Schema. Далее мы опишем элемент "order". Этот элемент имеет атрибут и содержит другие элементы:

<xs:element name="shiporder">
<xs:complexType>
<xs:sequence>
...
...
</xs:sequence>
...
</xs:complexType>
</xs:element>

Затем мы определи элемент "orderperson". Это простой элемент, его тип – строка, укажем этот тип с префиксом для XML Schema, что соответствует заранее определенным в XML Schema типам.

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

Затем мы описываем два сложных элемента "shipto" и "item".

Элемент shipto

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

Элемент item

<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:attribute name="orderid" type="xs:string" use="required"/>

Полностью законченный файл order.xsd приведен ниже.

Файл order.xsd

<?xml version="1.0"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:element name="order">
<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>

Альтернативный метод

Описание XML в виде XML Schema в том виде, что мы привели выше, не очень удобно для чтения. Ниже мы приводим другой вариант оформления того же файла order.xsd.

Файл order.xsd в более наглядном представлении

<?xml version="1.0"?> <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>

Еще один метод

В качестве третьего варианта можно предложить использование уже описанных типов и установления ссылок на них.

Файл order.xsd с описанием типов и заданием ссылок на них

<?xml version="1.0"?>
<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>

Здесь элемент, с помощью которого накладываются ограничения на используемый тип, использует префикс xs, соответствующий пространству имен XML Schema:

<xs:restriction base="xs:string">

Типы строковых данных

Строковые типы используются тогда, когда значения содержат последовательности символов. Среди символов могут встречаться буквенные символы, символы перевода строки, возврата каретки, табуляции. Описание строкового типа данных производится таким образом:

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

Соответствующий элемент XML документа может выглядеть, например, так:

<customer>Ivan Petrov</customer>

Существует несколько разновидностей строковых типов.

Тип NormalizedString

Тип normalizedString является производным от String типом. При использовании этого типа процессор XML удаляет все символы перевода строки, возврата каретки и табуляций из исходного текста. В файле XSD тип normalizedString используется таким образом:

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

Соответствующий элемент в XML файле может выглядеть как обычно:

<customer>Ivan Petrov</customer>

Тип Token

Тип token также основывается на типе String. При работе с этим типом XML процессор удаляет символы перевода строк, возврата каретки, табуляции, ведущие и завершающие пробелы, множественные пробелы. В файле XSD этот тип мождет быть описан следующим образом:

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

Соответствующий элемент в файле XML может выглядеть например, так:

<customer>Sidor Ivanov</customer>

В таблице 2 приведены строковые типы, которые являются типами, производными от типа String.

Таблица 2. Строковые типы

Название	Описание
ENTITIES	Задание фрагмента, в котором определяются сущности
ENTITY	Задание сущности
ID	Строка-идентификатор (атрибут ID)
IDREF	Строка, соответствующая атрибуту IDREF
IDREFS	Ссылки на атрибуты
Language	Строка-идентификатор языка
Name	Строка с именем XML
NCName	Имя NCName
NMTOKEN	Строкa, представляющая значение атрибута NMTOKEN
NMTOKENS	Ссылка на имена NMTOKENS
normalizedString	Строка, в которой нет символов переводов строки, возврата каретки, табуляций.
Qname	Строка Qname
String	Строка
Token	Строка без символов перевода строк, возвратов каретки, табуляций, ведущих и завершающих пробелов, множественных пробелов.

Ограничения на строковые типы

Строковые типы могут иметь наложенные на них ограничения. Могут быть наложены следующие ограничения для строковых типов:

enumeration
length
maxLength
minLength
pattern (не используется с NMTOKENS, IDREFS, ENTITIES)
whiteSpace

Данные в XSD

Для представления данных, которые являются значениями элементов, а также для представления времени, которое также представляет собой специальный тип данных, используются соответствующие типы данных. Типы данных используются для описания различных данных.

Типы данных для описания даты

Данные дат представляются в специальном формате. Общий формат даты выглядит так: "CCYY-MM-DD". Здесь буквы соответствуют цифровым позициям и обозначают следующее:

CC - век
YY - годы
MM - месяц
DD – день месяца

Следует отметить, что все компоненты даты являются обязательными. Дата в XSD файле объявляется следующим образом:

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

Содержащий дату элемент XML файла может выглядеть следующим образом:

Чтобы указать зональное время, можно использовать символ “Z”, который вставляется в виде суффикса после указания даты, например:

Можно указать также как положительный, так и отрицательный временной сдвиг зонального времени относительно стандартного времени, например:

или

Тип Time

Тип time используется для описания формата данных представления времени. Время представляется в следующем виде: "hh:mm:ss". Здесь в позициях, обозначенных символами, указываются следующие величины:

hh – часы
mm - минуты
ss - секунды

Все компоненты данных времени являются обязательными.

Пример объявления данных времени в файле XSD приведен ниже:

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

Соответствующий ему элемент в XML файле может выглядеть, например, следующим образом:

или

Временные зоны могут быть указаны с использованием суффикса "Z" после данных времени:

Временной сдвиг может быть задан с указанием как положительного, так и отрицательного сдвига относительно стандартного времени, например:

или

Тип DateTime

Тип dateTime используется для описания данных даты и времени одновременно. Этот формат представляет данные в следующем виде: "CCYY-MM-DDThh:mm.ss". Здесь буквами представлены следующие значения:

CC - век
YY - год
MM - месяц
DD - день
T – индикатор начала задания времени
hh - часы
mm - минуты
ss - секунды

Все компоненты являются обязательными.

Описание элемента, содержащего дату и время, может выглядеть следующим образом:

<xs:element name="startdate" type="xs:dateTime"/>

Соответствующий этому описанию элемент XML файла может выглядеть следующим образом:

или

С этим форматом можно использовать временные зоны, например:

или

или

Тип Duration

Тип duration используется для задания временного интервала. Формат представления данных таков: "PnYnMnDTnHnMnS". Здесь буквами обозначениы следующие позиции:

P – обозначает тип данных описания интервала (обязателен)
nY – количестов лет
nM - месяцы
nD - дния
T – обозначает начало задания времени в часах, минутах и секундах
nH – количество часов
nM - минуты
nS - секунды

Описание интервала в файле XML Schema может выглядеть так:

<xs:element name="period" type="xs:duration"/>

Соответвующий элемент в XML файле может быть записан следующим образом:

Эта запись соответствует периоду в три года. Можно записать, например, так:

Эта запись соответствует периоду в два года, семь месяцев и семнадцать дней.
Еще один пример:

Это период в один год, два месяца, десять дней и двенадцать часов.
Наконец, можно записать так:

Такая запись соответствует периоду в пятнадцать часов.
Период может быть указан отрицательным, например:

В таблице 3 приведены типы, используемые при работе с временем и датой.

Таблица 3. Типы для работы с датой и временем.

Название	Описание
Date	Значение даты
DateTime	Значение даты и времени
Duration	Временной интерфал
GDay	День (DD)
Gmonth	Месяц (MM)
GmonthDay	Месяц и день (MM-DD)
Gyear	Год (CCYY)
GyearMonth	Год и месяц (CCYY-MM)
Time	Время

При работе с типами данных, описывающими даты и время, можно накладывать ограничения. Ниже приведены допустимые при работе с датами и временем ограничения:

enumeration
maxExclusive
maxInclusive
minExclusive
minInclusive
pattern
whiteSpace

Числовые типы в XSD

Для представления числовых значений используются числовые типы.

Тип decimal

Тип decimal используется для десятичных чисел. Например:

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

Соответствующий элемент XML файла может выглядеть так:

Другие допустимые способы представления этого элемента:

Максимальное количество десятичных цифр ограничено и составляет 18.

Тип integer

Этот тип используется для описания целочисленных данных. Например:

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

Соответствующий этому описанию элемент XML файла может выглядеть так:

Другие допустимые варианты:

Числовые типы данных сведены в табл. 4.

Таблица 4. Числовые типы данных.

Название	Описание
Byte	Целое 8 бит со знаком
Decimal	Десятичное значение
Int	Целое 32 бит со знаком
Integer	Целое
Long	Цело 64 бит со знаком
negativeInteger	Отрицательное целое ( .., -2, -1.)
nonNegativeInteger	Неотрицательное целое (0, 1, 2, ..)
nonPositiveInteger	Неположительное целое (.., -2, -1, 0)
positiveInteger	Положительное целое (1, 2, ..)
Short	Целое 16 бит со знаком
unsignedLong	Целое 64 бит без знака
UnsignedInt	Целое 32 бит без знака
unsignedShort	Целое 16 бит без знака
unsignedByte	Целое 8 бит без знака

На числовые типы данных могут быть наложены следующие ограничения:

enumeration
fractionDigits
maxExclusive
maxInclusive
minExclusive
minInclusive
pattern
totalDigits
whiteSpace

Прочие типы данных в XSD

В XML Schema могут быть использованы и другие типы данных, такие, например, как boolean, base64Binary, hexBinary, float, double, anyURI, QName, NOTATION. Рассмотрим эти типы.

Тип Boolean

Логический тип boolean используется для представления значений true и false. Пример описания логического типа приводится ниже:

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

Соответствующий этому описанию элемент в файле XML может выглядеть, например, так:

В качестве значений можно использовать логические литералы true и false, а также соответствующие им 1 и 0.

Двоичные типы

Двоичные типы могут быть представлены в следующих форматах:

base64Binary (кодировка Base64)
hexBinary (кодировка hexadecimal)

Пример описания двоичных данных в XML Schema:

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

Тип AnyURI

Для описания имен URI используется тип anyURI. Пример задания типа anyURI:

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

Соответствующий этому описанию элемент в файле XML может выглядеть так:

В табл. 5 приведено описание прочих типов, используемых в XML Schema.

Таблица 5. Прочие типы XML Schema.

Имя	Описание
anyURI	Идентификатор URI
base64Binary	Кодированные в формате base64 двоичные данные
boolean	Логический тип
double	Число с двойной точностью
float	Число с плавающей точкой
hexBinary	Кодированный в формате hexBinary тип
NOTATION	Тип NITATION
QName	Тип Qname

При работе с прочими типами могут быть наложены ограничения. Список этих ограничений приводится далее:

enumeration (не используется с Boolean)
length (не используется с Boolean)
maxLength (не используется с Boolean)
minLength (не используется с Boolean)
whiteSpace

В завершение настоящего раздела приводим краткую справку по элементам XML Schema.

Автор: Вадим Будилов (softclub@soft.mail.ru)

Комментарии к статьям

Anoous, 29.03.04 12:42

dfgdfgdfgdfgfdgdfgdfgdfgfdgdfgfdgdfgdfgfdgdfgdfgdfgdfgdfgdfgdfgdfgdfgdfgdfgdfg

Anonymous, 16.08.04 15:49

<?xml version="1.0"?>
<xs:schema xmlns:xs="http:www.w3.org2001XMLSchema">
<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>