'

Языки описания информации

Понравилась презентация – покажи это...





Слайд 0

Языки описания информации Лекция 3. Кафедра «ОСУ» Весенний семестр 2010/2011 уч. года XML Schema и XLink


Слайд 1

XSD (XML Schema Definition Language) XML Schema: альтернатива использованию DTD


Слайд 2

Стандарт XML Schema XML Schema это альтернатива языку DTD, основанная на синтаксисе языка XML. XML 1.0 поддерживает DTD для определения структуры документов. Язык XML Schema имеет лучшие возможности поддержки для приложений, структуры документов, атрибутов т типов данных. Будущие версии XML будут основываться на XML Schema для определения типов XML документов. Стандарт XML Schema включает XML Schema Structures specifies the XML Schema definition language.  XML Schema Data types specifies extensible data types for XML.


Слайд 3

Спецификации XML Shema и временной график их принятия


Слайд 4

Язык XML Schema позволяет описывать структуру XML документа. Пример XML Schema: <?xml version="1.0"?> <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"> <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>


Слайд 5

Введение в XML Schema Язык XML Schema предназначен для описания структуры XML документов. Язык XML Schema также называется XML Schema Definition (XSD). Целью создания языка XML Schema является описание правильного синтаксиса конкретного языка разметки (также, как и язык DTD). XML Schema определяет: элементы, которые могут появляться в документах; атрибуты, которые могут использоваться с элементами; как элементы могут вкладываться друг в друга; порядок следования дочерних элементов; может ли элемент быть пустым или может ли он включать текст; типы данных для элементов и атрибутов; значения по умолчанию и фиксированные значения для элементов и атрибутов.


Слайд 6

XML Schema является правопреемником (заменителем) языка DTD. Считается, что скоро XML Schema будет использоваться в большинстве Web приложений в качестве замены для DTDs. Причинами этого является: XML Schema является расширяемым для будущих дополнений; XML Schema более выразительный и более мощный, чем DTD; XML Schema использует семантику метаязыка XML; XML Schema поддерживает типы данных; XML Schema поддерживает пространства име (namespaces).


Слайд 7

Почему нужно использовать XML Schema Язык XML Schemas является более мощным по сравнению с языком DTD. XML Schemas Support Data Types. XML Schemas use XML Syntax. XML Schemas Secure Data Communication. XML Schemas are Extensible. Well-Formed is not Enough.


Слайд 8

XML Schemas поддерживает типы данных One of the greatest strength of XML Schemas is the support for data types. With support for data types: It is easier to describe allowable document content It is easier to validate the correctness of data It is easier to work with data from a database It is easier to define data facets (restrictions on data) It is easier to define data patterns (data formats) It is easier to convert data between different data types


Слайд 9

Рассмотрим пример простого XML-документа (note.xml) <?xml version="1.0"?> <сообщение> <для_кого> Луценко</для_кого> <от_кого>Фролов</от_кого> <заголовок>Напоминание</заголовок> <содержание> Не забудь о собрании лаборатории в субботу! </содержание> </сообщение>


Слайд 10

Описание схемы на языке XML Schema На языке XML Schema язык разметки использованный для составления XML-документа note.xml может быть описан следующим образом (файл note.xsd): <?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=“для_кого" type="xs:string"/> <xs:element name="от_кого" type="xs:string"/> <xs:element name="заголовок" type="xs:string"/> <xs:element name="содержание" type="xs:string"/> </xs:sequence> </xs:complexType> </xs:element> </xs:schema>


Слайд 11

Связывание XML-документ note.xml с описанием его синтаксиса на языке XML Schema можно выполнить следующим образом: <?xml version="1.0"?> < сообщение xmlns="http://www.w3schools.com" xmlns:xsl="http://www.w3.org/2001/XMLSchema-instance" xsl:schemaLocation="http://www.w3schools.com note.xsd"> <для_кого>Луценко</для_кого> <от_кого>Фролов</от_кого> <заголовок>Напоминание</заголовок> <содержание> Не забудь о собрании лаборатории в субботу! </содержание> </сообщение>


Слайд 12

Здесь все используемые элементы, с помощью первого атрибута объявлены в пространстве имен "http://www.w3schools.com". Во втором атрибуте (xmlns:xsl="http://www.w3.org/2001/XMLSchema-instance") создается префикс для пространства имен «XML Schema Instance», которое используется для связывания с экземплярами документов описания схем на языке XSD. Из данного пространства имен можно использовать атрибут schemaLocation, которому задается два значения, разделенные пробелом. первое значение (http://www.w3schools.com) – это используемое пространство имен, второе значение (note.xsd) – местоположение документа с описанием XML схемы для данного пространства имен. Например: xsl:schemaLocation="http://www.w3schools.com note.xsd"


Слайд 13

Синтаксис языка XSD Корневым элементом описаний на языке XML Schema является элемент <schema>: <?xml version="1.0"?> <xs:schema> . . . . . . </xs:schema> Элемент <schema> может включать некоторые атрибуты. Например: <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" targetNamespace="http://www.w3schools.com" xmlns="http://www.w3schools.com" elementFormDefault="qualified">


Слайд 14

Первый атрибут xmlns:xs="http://www.w3.org/2001/XMLSchema" указывает, что в данном документе используется пространство имен "http://www.w3.org/2001/XMLSchema". Второй атрибут targetNamespace= "http://www.w3schools.com" указывает на то, что для описываемых в документе новых элементов (сообщение, для_кого, от_кого, заголовок, содержание) задается пространство имен "http://www.w3schools.com". Третий атрибут xmlns="http://www. w3schools.com" указывает, что пространством имен по умолчанию является "http://www.w3schools.com". Четвертый атрибут elementFormDefault= "qualified" указывает, что для всех элементов данного XML-документа должно быть указано пространство имен. Описания всех элементов и атрибутов конкретного языка могут использовать атрибут type.


Слайд 15

Встроенные типы языка XML Schema В языке XML Schema определен набор из 19 встроенных (предопределенных) типов данных, которые могут использоваться при описании элементов и атрибутов.


Слайд 16

Примеры встроенных типов xs:string – произвольные строки текста; xs:byte, xs:float, xs:long – числовые форматы: xs:byte – любое 8-разрядное число со знаком; xs:long – любое 32-разрядное число со знаком; xs:float – число с плавающей точкой, например, 15,6 или 5.032E-6. xs:time, xs:date, xs:timeinstant, xs:timeduration – шаблоны для обозначения времени, даты и длительности;


Слайд 17

xs:boolean – значение true или false (допускаются также числовые эквиваленты: 0 или 1); xs:binary – шаблон для двоичных чисел, например, 00101110; xs:language – код языка, например, en-US или RUS; xs:uri-reference – шаблон для любого URI, например, http://www.donut.org/cruller.xml#ingredients; xs:ID, xs:IDREF, xs:IDREFS, xs:NMTOKEN, xs:NMTOKENS – типы атрибутов, действующие так же, как соответствующие типы в DTD.


Слайд 18

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


Слайд 19

Описание простых элементов В состав описываемого конкретного языка могут входить простые элементы и составные элементы. Простые элементы могут включать только текстовое содержание и не могут включать другие элементы или атрибуты. Составные элементы могут содержать текст, атрибуты и дочерние элементы. Для описания простого элемента используется следующий синтаксис: <xs:element name="имя" type="тип"/>, где "имя" это имя элемента, а "тип" – тип данных, которые описываемый элемент может иметь.


Слайд 20

Примеры простых XML элементов XML-документ: <lastname>Refsnes</lastname> <age>36</age> <dateborn>1970-03-27</dateborn> Эти элементы могут быть следующим образом описаны с помощью языка XSD: <xs:element name="lastname" type="xs:string"/> <xs:element name="age" type="xs:integer"/> <xs:element name="dateborn" type="xs:date"/>


Слайд 21

Значения по умолчанию и фиксированные значения Простые элементы могут иметь значения по умолчанию или фиксированные значения. Значение по умолчанию автоматически назначается элементу, когда никакого значения ему не задано. Например: <xs:element name="color" type="xs:string" default="red"/> Если для простого элемента задано фиксированное значение, то данному элементу не могут быть заданы другие значения. Например: <xs:element name="color" type="xs:string" fixed="red"/>


Слайд 22

Описание атрибутов Простые элементы не могут иметь атрибуты. Если элемент имеет атрибуты, то он считается составным типом. Однако, сами атрибуты описываются, как простые типы, следующим образом: <xs:attribute name="имя" type="тип"/>, "имя" – это имя атрибуты, "тип" – тип данных, который может быть задан данному атрибуту. Например: <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"/>


Слайд 23

По умолчанию атрибуты считаются не обязательными. Для задания обязательности описываемых атрибутов используется атрибут "use". Например: <xs:attribute name="lang" type="xs:string" use="required"/>


Слайд 24

Ограничения на содержание элементов Если простому элементу или атрибуту задан тип, то он налагает ограничения на их содержание. Например, если элемент типа xs:date будет содержать строку типа "Hello World", то он не будет считаться верным. Кроме использования типов на значения простых элементов и атрибутов можно также накладывать дополнительные ограничения, которые еще называются «гранями» (facets). Ограничения можно задать с помощью элементов xs:restriction, в который вкладываются разные типы ограничений,


Слайд 25

Типы ограничений на элементы


Слайд 26

Типы ограничений на элементы (2)


Слайд 27

Пример ограничения Для элемента age (возраст) возможный интервал значений от 0 до 120 можно задать следующим образом: <xs:element name="age"> <xs:simpleType> <xs:restriction base="xs:integer"> <xs:minInclusive value="0"/> <xs:maxInclusive value="120"/> </xs:restriction> </xs:simpleType> </xs:element>


Слайд 28

Пример ограничения (2) C помощью элемента xs:enumeration можно ограничить содержание элемента списком возможных значений. Например, с помощью элемента xs:enumeration можно установит условие, что элементу car могут задаваться только значения из списка (Audi, Golf, BMW): <xs:element name="car"> <xs:simpleType> <xs:restriction base="xs:string"> <xs:enumeration value="Audi"/> <xs:enumeration value="Golf"/> <xs:enumeration value="BMW"/> </xs:restriction> </xs:simpleType> </xs:element>


Слайд 29

Пример с типами автомобилей можно описать и по-другому: вначале создать новый тип carType, затем использовать его для описания элемента car: <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="car" type="carType"/> Новый тип carType может использоваться и для описания и других элементов, т.к. не является частью элемента car.


Слайд 30

Ограничения содержания текстового элемента Для ограничения содержания элемента, имеющего тип xs:string, можно использовать шаблоны, которые задаются с помощью элемента xs:pattern и атрибута value. Шаблоны используют язык регулярных выражений и задают наборы правил формирования последовательности допустимых символов. Они могут задаваться в виде перечня разрешенных строк разделенных знаком "|". Например: "male | female".


Слайд 31

В каждой строке могут быть заданы конкретные символы или не определенные символы, описываемые в квадратных скобках […], в которых перечисляются возможные их значения, например, [xyz] – символ может получать значение x или y или z. Вместо перечисления значений символа можно задавать интервалы возможных значений: a-z (только маленькие буквы); A-Z (только большие буквы); 0-9 (только цифры). Интервалы можно комбинировать, например, a-zA-Z – возможна маленькая или большая буква.


Слайд 32

Кроме задания символов в квадратных скобках можно использовать следующие указатели: \d – одна цифра; \s – пробельный символ; \w – буква или цифра. С помощью круглых скобок возможные символы можно объединять в группы, после которой можно указать сколько раз данная группа может повториться. Для этого после закрывающейся скобки группы можно указать символы: * – ноль или более; + – 1 или более; {n} – точно n раз.


Слайд 33

Пример 1 <xs:pattern value="([a-z][A-Z])+"/> разрешенными значениями являются одна или несколько пар символов, каждая пара состоит из маленькой и большой буквы верно: "sToP"; неверно: "Stop" или "STOP".


Слайд 34

Пример 2 <xs:pattern value="[a-zA-Z0-9]{8}"/> должно задаваться точно 8 символов, каждый из которых может быть маленькой (a-z) или большой буквой (A-Z), или цифрой от 0 до 9 (0-9).


Слайд 35

Пример 3 <xs:pattern value="[A-Z]-\d{3}"/> может задаваться любой символ алфавита ([A-Z]), за которым следует дефис (-) и три цифры (\d{3}).


Слайд 36

Описание составных элементов Составные элементы могут содержать текст, другие элементы и/или атрибуты. Имеются 4 вида составных элементов: пустые элементы пустые элементы, которые не могут иметь содержание, но могут иметь атрибуты; элементы, содержащие другие элементы; элементы, содержащие только текст; элементы, которые содержат другие элементы и текст (смешанное содержание). Каждый из этих видов элементов также может содержать и атрибуты.


Слайд 37

Примеры составных элементов Пример пустого составного элемента "product": <product pid="1345" /> Пример составного элемента "employee", содержащего только дочерние элементы : <employee> <firstname>John</firstname> <lastname>Smith</lastname> </employee>


Слайд 38

Описание пустых элементов Пустые элементы не могут иметь содержания, но могут иметь атрибуты. Их нужно описывать, как составные элементы, но не включать в них никакие дочерние элементы, а определять только их атрибуты. Например: элемент, использующий атрибут pid, которому могут задаваться только целые положительные значения (например, <product pid="1345" />), может описываться на языке XML Schema следующими способами: <xs:element name="product"> <xs:complexType> <xs:attribute name="prodid" type="xs:positiveInteger"/> </xs:complexType> </xs:element>


Слайд 39

Создание нового составного типа и указание его в описании элемента product: <xs:element name="product" type="prodtype"/> <xs:complexType name="prodtype"> <xs:attribute name="prodid" type="xs:positiveInteger"/> </xs:complexType> Непосредственное описание элемента без содержания и с одним атрибутом с помощью элементов xs:complexType и xs:restriction: <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>


Слайд 40

Описание составных элементов, содержащих только дочерние элементы Составные элементы, содержащие только дочерние элементы, как например элемент person: <person> <firstname>John</firstname> <lastname>Smith</lastname> </person> могут определяться на языке XSD следующим образом: <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 указывает, что дочерние элементы (firstname и lastname) должны в XML-документе появляться в заданном порядке.


Слайд 41

Также можно задать создать новый тип составного элемента persontype и использовать его при описании элемента person: <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>


Слайд 42

Описание элементов, имеющих простое содержание При описании элемента, включающего только простое содержимое (текст и атрибуты), нужно использовать элемент simpleContent. В элементе simpleContent можно описать расширение (xs:extension) или ограничение (xs:restriction): <xs:element name="somename"> <xs:complexType> <xs:simpleContent> <xs:extension base="basetype"> . . . </xs:extension> </xs:simpleContent> </xs:complexType> </xs:element>


Слайд 43

Описание элемента simpleContent с использованием ограничение (xs:restriction): <xs:element name="somename"> <xs:complexType> <xs:simpleContent> <xs:restriction base="basetype"> . . . </xs:restriction> </xs:simpleContent> </xs:complexType> </xs:element>


Слайд 44

Пример описания простого элемента Например, нужно описать элемент "shoesize" (размер обуви), которые записываются следующим образом: <shoesize country="france">35</shoesize> Данный элемент может быть описан, как составной элемент, содержащий только целые значения и использующий атрибут с именем 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> Также можно вначале создать новый составной тип shoetype, а затем использовать его при описании элемента shoesize.


Слайд 45

Описание составных типов со смешанным содержанием Составные типы со смешанным содержанием могут включать атрибуты, дочерние элементы и текст. Например, рассмотрим элемент letter, который может содержать, как текст, так и другие элементы: <letter> Уважаемый господин <name>Луценко Александр</name>. Ваш заказ <orderid>1032</orderid> Был отправлен <shipdate>2012-03-13</shipdate>. </letter>


Слайд 46

Данный элемент "letter" можно описать следующим образом: <xs:element name="letter"> <xs:complexType mixed="true"> <xs:sequence> <xs:element name="name" type="xs:string"/> <xs:element name="orderid" type="xs:positiveInteger"/> <xs:element name="shipdate" type="xs:date"/> </xs:sequence> </xs:complexType> </xs:element> Отметим, чтобы разрешить записывать символьные данные между дочерними элементами, требуется задать атрибуту mixed значение true.


Слайд 47

Индикаторы Для задания правил использования в XML-документе дочерних элементов применяются индикаторы. Имеется три вида индикаторов: Индикаторы порядка – используются для определения порядка элементов (all, choice, sequence). Индикаторы кратности – используется для определения того, сколько раз могут записываться элементы: (maxOccurs, minOccurs). Индикаторы группирования – используются для задания взаимосвязанных наборов элементов (Group, attributeGroup).


Слайд 48

Индикатор <all> Индикатор <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.


Слайд 49

Индикатор <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>


Слайд 50

Индикатор <sequence> Индикатор <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>


Слайд 51

Индикаторы <maxOccurs> и <minOccurs> Индикатор <maxOccurs> указывает на максимальное количество, а индикатор <minOccurs> указывает на минимальное количество дочерних элементов. Например, для задания ограничения детей от 0 до 10 можно записать <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>


Слайд 52

По умолчанию для всех элементов задаются индикаторы maxOccurs=1 и minOccurs=1. Для того, что не было ограничения на максимальное количество дочернего элемента нужно задать: maxOccurs="unbounded".


Слайд 53

С помощью индикаторов группирования элементов можно описывать группы элементов, задавать им имена и использовать их в других описаниях. При создании группы элементов нужно указать индикатор порядка элементов внутри данной группы (all, choice или sequence). Например: описание группы элементов с именем persongroup, которые должны появляться в заданном порядке: <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>


Слайд 54

После определения группы с именем persongroup, на нее можно ссылаться в других описаниях с помощью атрибута ref. Например, при описании составного элемента: <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>


Слайд 55

С помощью индикаторов группирования атрибутов можно описывать группы атрибутов, задавать им имена и использовать их в других описаниях. Например: описание группы атрибутов с именем 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> После создания данной группы атрибутов на нее можно ссылаться в других описаниях. Например: <xs:element name="person"> <xs:complexType> <xs:attributeGroup ref="personattrgroup"/> </xs:complexType> </xs:element>


Слайд 56

Элемент <any> Элемент <any> позволяет включать в XML-документ элементы, которые не указаны в описании схемы конкретного языка разметки. Пример, показанный ниже, является фрагментом из схемы конкретного языка разметки, хранящегося в файле family.xsd. В нем содержится описание элемента person. С помощью элемента <any> выполняется расширение содержания типа элементов person. В этом случае в элементе person после элемента lastname могут записываться любые не описанные в схеме элементы: <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>


Слайд 57

Теперь в элементе person включать, например, элемент children, хотя в самой схеме возможность использования данного элемента не была описана. Рассмотрим файл, называемый "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>


Слайд 58

Ниже показан XML-документ (называемый "Myfamily.xml"), использующий элементы из двух разных схем "family.xsd" и "children.xsd": <?xml version="1.0" encoding="ISO-8859-1"?> <persons xmlns="http://www.microsoft.com" xmlns:xsl="http://www.w3.org/2001/XMLSchema-instance" xsl: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>


Слайд 59

Данный XML-документ является действительным (valid), так как схема "family.xsd" позволяет расширять элемент "person" необязательным элементом после элемента "lastname". Элементы <any> и <anyAttribute> используются для того, чтобы сделать конкретный язык разметки расширяемым! Они позволяют документу содержать дополнительные элементы, которые не объявлены в основной XML схеме.


Слайд 60


Слайд 61

Спасибо за внимание!


Слайд 62


Слайд 63


Слайд 64


Слайд 65

XML Schemas использует XML-синтаксис Another great strength about XML Schema is that they are written in XML. Some benefits of that XML Schemas are written in XML: You don't have to learn a new language You can use your XML editor to edit your Schema files You can use your XML parser to parse your Schema files You can manipulate your Schema with the XML DOM You can transform your Schema with XSLT


Слайд 66

XML Schemas Secure Data Communication When sending data from a sender to a receiver, it is essential that both parts have the same "expectations" about the content. With XML Schemas, the sender can describe the data in a way that the receiver will understand. A date like: "03-11-2004" will, in some countries, be interpreted as 3.November and in other countries as 11.March. However, an XML element with a data type like this: <date type="date">2004-03-11</date> ensures a mutual understanding of the content, because the XML data type "date" requires the format "YYYY-MM-DD".


Слайд 67

XML Schemas являются расширяемым XML Schemas are extensible, because they are written in XML. With an extensible Schema definition you can: Reuse your Schema in other Schemas Create your own data types derived from the standard types Reference multiple schemas in the same document


Слайд 68

Well-Formed is not Enough A well-formed XML document is a document that conforms to the XML syntax rules, like: it must begin with the XML declaration it must have one unique root element start-tags must have matching end-tags elements are case sensitive all elements must be closed all elements must be properly nested all attribute values must be quoted entities must be used for special characters Even if documents are well-formed they can still contain errors, and those errors can have serious consequences. Think of the following situation: you order 5 gross of laser printers, instead of 5 laser printers (???). With XML Schemas, most of these errors can be caught by your validating software.


Слайд 69

XML документы могут ссылаться на DTD или XML Schema Look at this simple XML document called "note.xml": <?xml version="1.0"?> <note>   <to>Tove</to>   <from>Jani</from>   <heading>Reminder</heading>   <body>Don't forget me this weekend!</body> </note> DTD файл. The following example is a DTD file called "note.dtd" that defines the elements of the XML document above ("note.xml"): <!ELEMENT note (to, from, heading, body)> <!ELEMENT to (#PCDATA)> <!ELEMENT from (#PCDATA)> <!ELEMENT heading (#PCDATA)> <!ELEMENT body (#PCDATA)> The first line defines the note element to have four child elements: "to, from, heading, body". Line 2-5 defines the to, from, heading, body elements to be of type "#PCDATA".


Слайд 70

Описание на языке XML Schema The following example is an XML Schema file called "note.xsd" that defines the elements of the XML document above ("note.xml"): <?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. The other elements (to, from, heading, body) are simple types because they do not contain other elements. You will learn more about simple and complex types in the following chapters.


Слайд 71

Ссылки на схему Ссылка на DTD. This XML document has a reference to a DTD: <?xml version="1.0"?> <!DOCTYPE note SYSTEM "http://www.w3schools.com/dtd/note.dtd"> <note>   <to>Tove</to>   <from>Jani</from>   <heading>Reminder</heading>   <body>Don't forget me this weekend!</body> </note> Ссылка на XML Schema. This XML document has a reference to an XML Schema: <?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"> <to>Tove</to>   <from>Jani</from>   <heading>Reminder</heading>   <body>Don't forget me this weekend!</body> </note>


Слайд 72

Элемент XSD - <schema> The <schema> element is the root element of every XML Schema. <?xml version="1.0"?> <xs:schema> ... ... </xs:schema> The <schema> element may contain some attributes. A schema declaration often looks something like this: <?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>


Слайд 73

The following fragment: xmlns:xs=http://www.w3.org/2001/XMLSchema indicates that the elements and data types used in the schema come from the "http://www.w3.org/2001/XMLSchema" namespace. It also specifies that the elements and data types that come from the "http://www.w3.org/2001/XMLSchema" namespace should be prefixed with xs: This fragment: targetNamespace="http://www.w3schools.com"indicates that the elements defined by this schema (note, to, from, heading, body.) come from the "http://www.w3schools.com" namespace. This fragment: xmlns="http://www.w3schools.com"indicates that the default namespace is "http://www.w3schools.com". This fragment: elementFormDefault="qualified"indicates that any elements used by the XML instance document which were declared in this schema must be namespace qualified.


Слайд 74

Ссылка на схему в XML документе This XML document has a reference to an XML Schema: <?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“> <to>Tove</to> <from>Jani</from> <heading>Reminder</heading> <body>Don't forget me this weekend!</body> </note> The following fragment: xmlns="http://www.w3schools.com"specifies the default namespace declaration. This declaration tells the schema-validator that all the elements used in this XML document are declared in the "http://www.w3schools.com" namespace. Once you have the XML Schema Instance namespace available: xmlns:xsi=http://www.w3.org/2001/XMLSchema-instance you can use the schemaLocation attribute. This attribute has two values. The first value is the namespace to use. The second value is the location of the XML schema to use for that namespace: xsi:schemaLocation="http://www.w3schools.com note.xsd"


Слайд 75

Простые (simple) XSD элементы Простыми XML элементами называются элементы, которые могут содержать только текст. Они не могут включать другие элементы или атрибуты. Текст может представлять собой данные разных типов: типов включенных в определение XML Schema (boolean, string, date, etc.), пользовательский тип, который он описывает сам. You can also add restrictions (facets) to a data type in order to limit its content, or you can require the data to match a specific pattern. The syntax for defining a simple element is: <xs:element name="xxx" type="yyy"/>, где xxx - name of the element and yyy - data type of the element. XML Schema has a lot of built-in data types. The most common types are: xs:string xs:decimal xs:integer xs:boolean xs:date xs:time


Слайд 76

Пример простых элементов Here are some XML elements: <lastname>Refsnes</lastname> <age>36</age> <dateborn>1970-03-27</dateborn> And here are the corresponding simple element definitions: <xs:element name="lastname" type="xs:string"/> <xs:element name="age" type="xs:integer"/> <xs:element name="dateborn" type="xs:date"/>


Слайд 77

Значение по умолчанию и фиксированное значение для простых типов Simple elements may have a default value OR a fixed value specified. A default value is automatically assigned to the element when no other value is specified. In the following example the default value is "red": <xs:element name="color" type="xs:string” default="red"/> A fixed value is also automatically assigned to the element, and you cannot specify another value. In the following example the fixed value is "red": <xs:element name="color" type="xs:string" fixed="red"/>


Слайд 78

Атрибуты XSD All attributes are declared as simple types. Simple elements cannot have attributes. If an element has attributes, it is considered to be of a complex type. But the attribute itself is always declared as a simple type. The syntax for defining an attribute is: <xs:attribute name="xxx" type="yyy"/>, где xxx is the name of the attribute yyy specifies the data type of the attribute. XML Schema has a lot of built-in data types. The most common types are: xs:string xs:decimal xs:integer xs:boolean xs:date xs:time Пример XML element with an attribute: <lastname lang="EN">Smith</lastname> And here is the corresponding attribute definition: <xs:attribute name="lang" type="xs:string"/>


Слайд 79

Default and Fixed Values for Attributes Attributes may have a default value OR a fixed value specified. A default value is automatically assigned to the attribute when no other value is specified. Например, default value is "EN": <xs:attribute name="lang" type="xs:string" default="EN"/> A fixed value is also automatically assigned to the attribute, and you cannot specify another value. Например, fixed value is "EN": <xs:attribute name="lang" type="xs:string" fixed="EN"/> Optional and Required Attributes Attributes are optional by default. To specify that the attribute is required, use the "use" attribute: <xs:attribute name="lang" type="xs:string" use="required"/> Restrictions on Content. When an XML element or attribute has a data type defined, it puts restrictions on the element's or attribute's content. If an XML element is of type "xs:date" and contains a string like "Hello World", the element will not validate. With XML Schemas, you can also add your own restrictions to your XML elements and attributes. Такие ограничения называются гранями (facets). 


Слайд 80

XSD ограничения/грани Restrictions are used to define acceptable values for XML elements or attributes. Restrictions on XML elements are called facets. Restrictions on Values The following example defines an element called "age" with a restriction. The value of age cannot be lower than 0 or greater than 120: <xs:element name="age">   <xs:simpleType>     <xs:restriction base="xs:integer">       <xs:minInclusive value="0"/>       <xs:maxInclusive value="120"/>     </xs:restriction>   </xs:simpleType> </xs:element>


Слайд 81

Restrictions on a Set of Values To limit the content of an XML element to a set of acceptable values, we would use the enumeration constraint. The example below defines an element called "car" with a restriction. The only acceptable values are: Audi, Golf, BMW: <xs:element name="car">   <xs:simpleType>     <xs:restriction base="xs:string">       <xs:enumeration value="Audi"/>       <xs:enumeration value="Golf"/>       <xs:enumeration value="BMW"/>     </xs:restriction>   </xs:simpleType> </xs:element> The example above could also have been written like this: <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> Note: In this case the type "carType" can be used by other elements because it is not a part of the "car" element.


Слайд 82

Restrictions on a Series of Values To limit the content of an XML element to define a series of numbers or letters that can be used, we would use the pattern constraint. The example below defines an element called "letter" with a restriction. The only acceptable value is ONE of the LOWERCASE letters from a to z: <xs:element name="letter">   <xs:simpleType>     <xs:restriction base="xs:string">       <xs:pattern value="[a-z]"/>     </xs:restriction>   </xs:simpleType> </xs:element> The next example defines an element called "initials" with a restriction. The only acceptable value is THREE of the UPPERCASE letters from a to 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>


Слайд 83

Restrictions on a Series of Values (2) The next example also defines an element called "initials" with a restriction. The only acceptable value is THREE of the LOWERCASE OR UPPERCASE letters from a to z: <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> The next example defines an element called "choice" with a restriction. The only acceptable value is ONE of the following letters: x, y, OR z: <xs:element name="choice">   <xs:simpleType>     <xs:restriction base="xs:string">       <xs:pattern value="[xyz]"/>     </xs:restriction>   </xs:simpleType> </xs:element>


Слайд 84

Other Restrictions on a Series of Values The example below defines an element called "letter" with a restriction. The acceptable value is zero or more occurrences of lowercase letters from a to z: <xs:element name="letter">   <xs:simpleType>     <xs:restriction base="xs:string">       <xs:pattern value="([a-z])*"/>     </xs:restriction>   </xs:simpleType> </xs:element> The next example also defines an element called "letter" with a restriction. The acceptable value is one or more pairs of letters, each pair consisting of a lower case letter followed by an upper case letter. For example, "sToP" will be validated by this pattern, but not "Stop" or "STOP" or "stop": <xs:element name="letter">   <xs:simpleType>     <xs:restriction base="xs:string">       <xs:pattern value="([a-z][A-Z])+"/>     </xs:restriction>   </xs:simpleType> </xs:element>


Слайд 85

The next example defines an element called "gender" with a restriction. The only acceptable value is male OR female: <xs:element name="gender">   <xs:simpleType>     <xs:restriction base="xs:string">       <xs:pattern value="male|female"/>     </xs:restriction>   </xs:simpleType> </xs:element> The next example defines an element called "password" with a restriction. There must be exactly eight characters in a row and those characters must be lowercase or uppercase letters from a to z, or a number from 0 to 9: <xs:element name="password">   <xs:simpleType>     <xs:restriction base="xs:string">       <xs:pattern value="[a-zA-Z0-9]{8}"/>     </xs:restriction>   </xs:simpleType> </xs:element>


Слайд 86

The next example defines an element called "prodid" with a restriction. The only acceptable value is FIVE digits in a sequence, and each digit must be in a range from 0 to 9: <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>


Слайд 87

Restrictions on Whitespace Characters To specify how whitespace characters should be handled, we would use the whiteSpace constraint. This example defines an element called "address" with a restriction. The whiteSpace constraint is set to "preserve", which means that the XML processor WILL NOT remove any white space characters: <xs:element name="address">   <xs:simpleType>     <xs:restriction base="xs:string">       <xs:whiteSpace value="preserve"/>     </xs:restriction>   </xs:simpleType> </xs:element> This example also defines an element called "address" with a restriction. The whiteSpace constraint is set to "replace", which means that the XML processor WILL REPLACE all white space characters (line feeds, tabs, spaces, and carriage returns) with spaces: <xs:element name="address">   <xs:simpleType>     <xs:restriction base="xs:string">       <xs:whiteSpace value="replace"/>     </xs:restriction>   </xs:simpleType> </xs:element>


Слайд 88

This example also defines an element called "address" with a restriction. The whiteSpace constraint is set to "collapse", which means 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, and multiple spaces are reduced to a single space): <xs:element name="address">   <xs:simpleType>     <xs:restriction base="xs:string">       <xs:whiteSpace value="collapse"/>     </xs:restriction>   </xs:simpleType> </xs:element>


Слайд 89

Restrictions on Length To limit the length of a value in an element, we would use the length, maxLength, and minLength constraints. This example defines an element called "password" with a restriction. The value must be exactly eight characters: <xs:element name="password">   <xs:simpleType>     <xs:restriction base="xs:string">       <xs:length value="8"/>     </xs:restriction>   </xs:simpleType> </xs:element> This example defines another element called "password" with a restriction. The value must be minimum five characters and maximum eight characters: <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>


Слайд 90

Restrictions for Datatypes


Слайд 91

XSD Complex Elements A complex element is an XML element that contains other elements and/or attributes. There are four kinds of complex elements: empty elements elements that contain only other elements elements that contain only text elements that contain both other elements and text Note: Each of these elements may contain attributes as well! Examples of Complex Elements A complex XML element, "product", which is empty: <product pid="1345"/> A complex XML element, "employee", which contains only other elements: <employee>   <firstname>John</firstname>   <lastname>Smith</lastname> </employee> A complex XML element, "food", which contains only text: <food type="dessert">Ice cream</food> A complex XML element, "description", which contains both elements and text: <description> It happened on <date lang="norwegian">03.03.99</date> .... </description>


Слайд 92

Описание сложных элементов Look at this complex XML element, "employee", which contains only other elements: <employee>   <firstname>John</firstname>   <lastname>Smith</lastname> </employee> We can define a complex element in an XML Schema two different ways: 1. The "employee" element can be declared directly by naming the element, like this: <xs:element name="employee">   <xs:complexType>     <xs:sequence>       <xs:element name="firstname" type="xs:string"/>       <xs:element name="lastname" type="xs:string"/>     </xs:sequence>   </xs:complexType> </xs:element> If you use the method described above, only the "employee" element can use the specified complex type. Note that the child elements, "firstname" and "lastname", are surrounded by the <sequence> indicator. This means that the child elements must appear in the same order as they are declared. You will learn more about indicators in the XSD Indicators chapter. 2. The "employee" element can have a type attribute that refers to the name of the complex type to use: <xs:element name="employee" type="personinfo"/> <xs:complexType name="personinfo“>   <xs:sequence>     <xs:element name="firstname" type="xs:string"/>    <xs:element name="lastname" type="xs:string"/>   </xs:sequence> </xs:complexType>


Слайд 93

If you use the method described above, several elements can refer to the same complex type, like this: <xs:element name="employee" type="personinfo"/> <xs:element name="student" type="personinfo"/> <xs:element name="member" type="personinfo"/> <xs: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 complex element on an existing complex element and add some 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> <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>


Слайд 94

Пустые элементы An empty complex element cannot have contents, only attributes. Complex Empty Elements An empty XML element: <product prodid="1345" /> The "product" element above has no content at all. To define a type with no content, we must define a type that allows elements in its content, but we do not actually declare any elements, like this: <xs:element name="product">   <xs:complexType>     <xs:complexContent>       <xs:restriction base="xs:integer">         <xs:attribute name="prodid" type="xs:positiveInteger"/>       </xs:restriction>     </xs:complexContent>   </xs:complexType> </xs:element> In the example above, we define a complex type with a complex content. The complexContent element signals that we intend to restrict or extend the content model of a complex type, and the restriction of integer declares one attribute but does not introduce any element content.


Слайд 95

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>


Слайд 96

Составные элементы, содержащие только подэлементы ("elements-only") An "elements-only" complex type contains an element that contains only other elements. An XML element, "person", that contains only other elements: <person>   <firstname>John</firstname>   <lastname>Smith</lastname> </person> В схеме элемент "person" может быть описан следующим образом: <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> Notice the <xs:sequence> tag. It means that the elements defined ("firstname" and "lastname") must appear in that order inside a "person" element.


Слайд 97

Другой способ описания 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="persontype">   <xs:sequence>     <xs:element name="firstname" type="xs:string"/>     <xs:element name="lastname" type="xs:string"/>   </xs:sequence> </xs:complexType>


Слайд 98

XSD Text-Only Elements A complex text-only element can contain text and attributes. Complex Text-Only Elements. 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 within the simpleContent element, like this: <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> Tip: Use the extension/restriction element to expand or to limit the base simple type for the element.


Слайд 99

Here is an example of 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 value, and the "shoesize" element also contains an attribute named "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 complexType 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>


Слайд 100

Элементы со смешанным содержанием A mixed complex type element can contain attributes, elements, and text. Complex Types with Mixed Content An XML element, "letter", that contains both text and other elements: <letter>   Dear Mr.<name>John Smith</name>.   Your order <orderid>1032</orderid>   will be shipped on <shipdate>2001-07-13</shipdate>. </letter>The following schema declares the "letter" element: <xs:element name="letter">   <xs:complexType mixed="true">     <xs:sequence>       <xs:element name="name" type="xs:string"/>       <xs:element name="orderid" type="xs:positiveInteger"/>       <xs:element name="shipdate" type="xs:date"/>     </xs:sequence>   </xs:complexType> </xs:element> Note: To enable character data to appear between the child-elements of "letter", the mixed attribute must be set to "true". The <xs:sequence> tag means that the elements defined (name, orderid and shipdate) must appear in that order inside a "letter" element.


Слайд 101

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>


Слайд 102

Индикаторы XSD We can control HOW elements are to be used in documents with indicators. Indicators There are seven indicators: Order indicators: All Choice Sequence Occurrence indicators: maxOccurs minOccurs Group indicators: Group name attributeGroup name


Слайд 103

Order Indicators Order indicators are used to define the order of the elements. All Indicator The <all> indicator specifies that the child elements can appear in any order, and that each child element must occur only once: <xs:element name="person">   <xs:complexType>     <xs:all>       <xs:element name="firstname" type="xs:string"/>       <xs:element name="lastname" type="xs:string"/>     </xs:all>   </xs:complexType> </xs:element> Note: When using the <all> indicator you can set the <minOccurs> indicator to 0 or 1 and the <maxOccurs> indicator can only be set to 1 (the <minOccurs> and <maxOccurs> are described later).


Слайд 104

Choice Indicator 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 Indicator 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:element name="lastname" type="xs:string"/>     </xs:sequence>   </xs:complexType> </xs:element>


Слайд 105

Occurrence Indicators Occurrence indicators are used to define how often an element can occur. Note: For all "Order" and "Group" indicators (any, all, choice, sequence, group name, and group reference) the default value for maxOccurs and minOccurs is 1. maxOccurs Indicator The <maxOccurs> indicator specifies the maximum number of times an element can occur: <xs: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 example above indicates that the "child_name" element can occur a minimum of one time (the default value for minOccurs is 1) and a maximum of ten times in the "person" element. minOccurs Indicator The <minOccurs> indicator specifies the minimum number of times an element can occur: <xs: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 example above indicates that the "child_name" element can occur a minimum of zero times and a maximum of ten times in the "person" element. Tip: To allow an element to appear an unlimited number of times, use the maxOccurs="unbounded" statement:


Слайд 106

Пример XML-документа 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>


Слайд 107

Пример описания схемы family.xsd The XML file above contains a root element named "persons". Inside this root element we have defined three "person" elements. Each "person" element must contain a "full_name" element and it can contain up to five "child_name" elements. <?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>


Слайд 108

Индикаторы группы Group indicators are used to define related sets of elements. Element Groups Element groups are defined with the group declaration, like this: <xs:group name="groupname"> ... </xs:group> You must define an all, choice, or sequence element inside the group declaration. The following example defines a group named "persongroup", that defines a group of elements that must occur in an exact sequence: <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>


Слайд 109

After you have defined a group, you can reference it in another 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>


Слайд 110

Attribute Groups Attribute groups are defined with the attributeGroup declaration, like this: <xs:attributeGroup name="groupname"> ... </xs:attributeGroup>The following example defines an attribute group named "personattrgroup": <xs:attributeGroup name="personattrgroup">   <xs:attribute name="firstname" type="xs:string"/>   <xs:attribute name="lastname" type="xs:string"/>   <xs:attribute name="birthday" type="xs:date"/> </xs:attributeGroup>After you have defined an attribute group, you can reference it in another definition, like this: <xs: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>


Слайд 111

XSD The <any> Element The <any> element enables us to extend the XML document with elements not specified by the schema! The following example is a fragment from an XML schema called "family.xsd". It shows a declaration for the "person" element. By using the <any> element we can extend (after <lastname>) the content of "person" with any element: <xs: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. Look at this 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>


Слайд 112

The XML file below (called "Myfamily.xml"), uses components from two different schemas; "family.xsd" and "children.xsd": <?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 declared in the main XML schema.


Слайд 113

XSD The <anyAttribute> Element The <anyAttribute> element enables us to extend the XML document with attributes not specified by the schema! The following example is a fragment from an XML schema called "family.xsd". It shows a declaration for the "person" element. By using the <anyAttribute> element we can add any number of attributes to the "person" element: <xs: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> Now we want to extend the "person" element with a "gender" attribute. In this case we can do so, even if the author of the schema above never declared any "gender" attribute. Look at this schema file, called "attribute.xsd": <?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>


Слайд 114

XSD Element Substitution With XML Schemas, one element can substitute another element. Let's say that we have users from two different countries: England and Norway. We would like the ability to let the user choose whether he or she would like to use the Norwegian element names or the English element names in the XML document. To solve this problem, we could define a substitutionGroup in the XML schema. First, we declare a head element and then we declare the other elements which state that they are substitutable for the head element. <xs:element name="name" type="xs:string"/> <xs:element name="navn" substitutionGroup="name"/>In the example above, the "name" element is the head element and the "navn" element is substitutable for "name". Look at this fragment of an XML schema: <xs: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"/>


Слайд 115

A valid XML document (according to the schema above) could look like this: <customer>   <name>John Smith</name> </customer>or like this: <kunde>   <navn>John Smith</navn> </kunde>


Слайд 116

Blocking Element Substitution To prevent other elements from substituting with a specified element, use the block attribute: <xs:element name="name" type="xs:string" block="substitution"/>Look at this fragment of an XML schema: <xs:element name="name" type="xs:string" block="substitution"/> <xs: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"/>A valid XML document (according to the schema above) looks like this: <customer>   <name>John Smith</name> </customer>BUT THIS IS NO LONGER VALID: <kunde>   <navn>John Smith</navn> </kunde>


Слайд 117

Using substitutionGroup The type of the substitutable elements must be the same as, or derived from, the type of the head element. If the type of the substitutable element is the same as the type of the head element you will not have to specify the type of the substitutable element. Note that all elements in the substitutionGroup (the head element and the substitutable elements) must be declared as global elements, otherwise it will not work! What are Global Elements? Global elements are elements that are immediate children of the "schema" element! Local elements are elements nested within other elements.


Слайд 118

XML document Let's have a look at this XML document called "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 above consists of a root element, "shiporder", that contains a required attribute called "orderid". The "shiporder" element contains three different child elements: "orderperson", "shipto" and "item". The "item" element appears twice, and it contains a "title", an optional "note" element, a "quantity", and a "price" element. The line above: xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" tells the XML parser that this document should be validated against a schema. The line: xsi:noNamespaceSchemaLocation="shiporder.xsd" specifies WHERE the schema resides (here it is in the same folder as "shiporder.xml").


Слайд 119

Create an XML Schema Now we want to create a schema for the XML document above. We start by opening a new file that we will call "shiporder.xsd". To create the schema we could simply follow the structure in the XML document and define each element as we find it. We will start with the standard XML declaration followed by the xs:schema element that defines a schema: <?xml version="1.0" encoding="ISO-8859-1" ?> <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"> ... </xs:schema> In the schema above we use the standard namespace (xs), and the URI associated with this namespace is the Schema language definition, which has the standard value of http://www.w3.org/2001/XMLSchema.


Слайд 120

Create an XML Schema Next, we have to define the "shiporder" element. This element has an attribute and it contains other elements, therefore we consider it as a complex type. The child elements of the "shiporder" element is surrounded by a xs:sequence element that defines an ordered sequence of sub elements: <xs:element name="shiporder">   <xs:complexType>     <xs:sequence>       ...     </xs:sequence>   </xs:complexType> </xs:element>


Слайд 121

Then we have to define the "orderperson" element as a simple type (because it does not contain any attributes or other elements). The type (xs:string) is prefixed with the namespace prefix associated with XML Schema that indicates a predefined schema data type: <xs:element name="orderperson" type="xs:string"/> Next, we have to define two elements that are of the complex type: "shipto" and "item".


Слайд 122

We start by defining the "shipto" element: <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 minOccurs attributes. maxOccurs specifies the maximum number of occurrences for an element and minOccurs specifies the minimum number of occurrences for an element. The default value for both maxOccurs and minOccurs is 1!


Слайд 123

Now we can define the "item" element. This element can appear multiple times inside a "shiporder" element. This is specified by setting the maxOccurs attribute of the "item" element to "unbounded" which means that there can be as many occurrences of the "item" element as the author wishes. Notice that the "note" element is optional.


Слайд 124

We have specified this by setting the minOccurs attribute to zero: <xs:element name="item" maxOccurs="unbounded">   <xs:complexType>     <xs:sequence>       <xs:element name="title" type="xs:string"/>       <xs:element name="note" type="xs:string" minOccurs="0"/>       <xs:element name="quantity" type="xs:positiveInteger"/>       <xs:element name="price" type="xs:decimal"/>     </xs:sequence>   </xs:complexType> </xs:element> We can now declare the attribute of the "shiporder" element. Since this is a required attribute we specify use="required". Note: The attribute declarations must always come last: <xs:attribute name="orderid" type="xs:string" use="required"/>


Слайд 125

Полное описание схемы (shiporder.xsd) <?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>


Слайд 126

Разделение схемы <?xml version="1.0" encoding="ISO-8859-1" ?> <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"> <!-- definition of simple elements --> <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"/> <!-- definition of attributes --> <xs:attribute name="orderid" type="xs:string"/> <!-- definition of complex elements --> <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> The previous design method is very simple, but can be difficult to read and maintain when documents are complex. The next design method is based on defining all elements and attributes first, and then referring to them using the ref attribute. Here is the new design of the schema file ("shiporder.xsd"):


Слайд 127

Использование именованных типов (Named Types) <?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> The third design method defines classes or types, that enables us to reuse element definitions. This is done by naming the simpleTypes and complexTypes elements, and then point to them through the type attribute of the element. Here is the third design of the schema file ("shiporder.xsd"): <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>


Слайд 128

The restriction element indicates that the datatype is derived from a W3C XML Schema namespace datatype. So, the following fragment means that the value of the element or attribute must be a string value: <xs:restriction base="xs:string">The restriction element is more often used to apply restrictions to elements. Look at the following lines from the schema above: <xs:simpleType name="orderidtype">   <xs:restriction base="xs:string">     <xs:pattern value="[0-9]{6}"/>   </xs:restriction> </xs:simpleType>This indicates that the value of the element or attribute must be a string, it must be exactly six characters in a row, and those characters must be a number from 0 to 9.


Слайд 129

Типы данных XML Schema


Слайд 130

XSD String Data Types String data types are used for values that contains character strings. The string data type can contain characters, line feeds, carriage returns, and tab characters. The following is an example of a string declaration in a schema: <xs:element name="customer" type="xs:string"/> An element in your document might look like this: <customer>John Smith</customer> Or it might look like this: <customer>       John Smith     </customer> Note: The XML processor will not modify the value if you use the string data type.


Слайд 131

NormalizedString Data Type The normalizedString data type is derived from the String data type. The normalizedString data type also contains characters, but the XML processor will remove line feeds, carriage returns, and tab characters. The following is an example of a normalizedString declaration in a schema: <xs:element name="customer" type="xs:normalizedString"/> An element in your document might look like this: <customer>John Smith</customer> Or it might look like this: <customer>     John Smith     </customer> Note: In the example above the XML processor will replace the tabs with spaces.


Слайд 132

Token Data Type The token data type is also derived from the String data type. The token data type also contains characters, but the XML processor will remove line feeds, carriage returns, tabs, leading and trailing spaces, and multiple spaces. The following is an example of a token declaration in a schema: <xs:element name="customer" type="xs:token"/> An element in your document might look like this: <customer>John Smith</customer> Or it might look like this: <customer>     John Smith     </customer> Note: In the example above the XML processor will remove the tabs.


Слайд 133

String Data Types Note that all of the data types below derive from the String data type (except for string itself)!


Слайд 134

Restrictions on String Data Types Restrictions that can be used with String data types: enumeration length maxLength minLength pattern (NMTOKENS, IDREFS, and ENTITIES cannot use this constraint) whiteSpace


Слайд 135

XSD Date and Time Data Types Date and time data types are used for values that contain date and time. The date data type is used to specify a date. The date is specified in the following form "YYYY-MM-DD" where: YYYY indicates the year MM indicates the month DD indicates the day Note: All components are required! The following is an example of a date declaration in a schema: <xs:element name="start" type="xs:date"/> An element in your document might look like this: <start>2002-09-24</start>Time Zones To specify a time zone, you can either enter a date in UTC time by adding a "Z" behind the date - like this: <start>2002-09-24Z</start> or you can specify an offset from the UTC time by adding a positive or negative time behind the date - like this: <start>2002-09-24-06:00</start> Or <start>2002-09-24+06:00</start>


Слайд 136

Time Data Type The time data type is used to specify a time. The time is specified in the following form "hh:mm:ss" where: hh indicates the hour mm indicates the minute ss indicates the second Note: All components are required! The following is an example of a time declaration in a schema: <xs:element name="start" type="xs:time"/> An element in your document might look like this: <start>09:00:00</start> Or it might look like this: <start>09:30:10.5</start>


Слайд 137

Time Zones To specify a time zone, you can either enter a time in UTC time by adding a "Z" behind the time - like this: <start>09:30:10Z</start> or you can specify an offset from the UTC time by adding a positive or negative time behind the time - like this: <start>09:30:10-06:00</start> or <start>09:30:10+06:00</start>


Слайд 138

DateTime Data Type The dateTime data type is used to specify a date and a time. The dateTime is specified in the following form "YYYY-MM-DDThh:mm:ss" where: YYYY indicates the year MM indicates the month DD indicates the day T indicates the start of the required time section hh indicates the hour mm indicates the minute ss indicates the second Note: All components are required! The following is an example of a dateTime declaration in a schema: <xs:element name="startdate" type="xs:dateTime"/> An element in your document might look like this: <startdate>2002-05-30T09:00:00</startdate> Or it might look like this: <startdate>2002-05-30T09:30:10.5</startdate>


Слайд 139

Time Zones To specify a time zone, you can either enter a dateTime in UTC time by adding a "Z" behind the time - like this: <startdate>2002-05-30T09:30:10Z</startdate> or you can specify an offset from the UTC time by adding a positive or negative time behind the time - like this: <startdate>2002-05-30T09:30:10-06:00</startdate> or <startdate>2002-05-30T09:30:10+06:00</startdate>


Слайд 140

Duration Data Type The duration data type is used to specify a time interval. The time interval is specified in the following form "PnYnMnDTnHnMnS" where: P indicates the period (required) nY indicates the number of years nM indicates the number of months nD indicates the number of days T indicates the start of a time section (required if you are going to specify hours, minutes, or seconds) nH indicates the number of hours nM indicates the number of minutes nS indicates the number of seconds The following is an example of a duration declaration in a schema: <xs:element name="period" type="xs:duration"/> An element in your document might look like this (period of five years): <period>P5Y</period> Or it might look like this (period of five years, two months, and 10 days): <period>P5Y2M10D</period> Or it might look like this (period of five years, two months, 10 days, and 15 hours): <period>P5Y2M10DT15H</period> Or it might look like this (period of 15 hours): <period>PT15H</period>


Слайд 141

Negative Duration To specify a negative duration, enter a minus sign before the P: <period>-P10D</period>The example above indicates a period of minus 10 days.


Слайд 142

Date and Time Data Types …


Слайд 143

Restrictions on Date Data Types Restrictions that can be used with Date data types: enumeration maxExclusive maxInclusive minExclusive minInclusive pattern whiteSpace


Слайд 144

XSD Numeric Data Types - Decimal Data Type Decimal data types are used for numeric values. The decimal data type is used to specify a numeric value. The following is an example of a decimal declaration in a schema: <xs:element name="prize" type="xs:decimal"/> An element in your document might look like this: <prize>999.50</prize> Or it might look like this: <prize>+999.5450</prize> Or it might look like this: <prize>-999.5230</prize> Or it might look like this: <prize>0</prize> Or it might look like this: <prize>14</prize> Note: The maximum number of decimal digits you can specify is 18.


Слайд 145

Integer Data Type The integer data type is used to specify a numeric value without a fractional component. The following is an example of an integer declaration in a schema: <xs:element name="prize" type="xs:integer"/> An element in your document might look like this: <prize>999</prize> Or it might look like this: <prize>+999</prize> Or it might look like this: <prize>-999</prize> Или it might look like this: <prize>0</prize>


Слайд 146

Numeric Data Types Note that all of the data types below derive from the Decimal data type (except for decimal itself)!


Слайд 147

Restrictions on Numeric Data Types Restrictions that can be used with Numeric data types: enumeration fractionDigits maxExclusive maxInclusive minExclusive minInclusive pattern totalDigits whiteSpace


Слайд 148

XSD Miscellaneous Data Types Other miscellaneous data types are boolean, base64Binary, hexBinary, float, double, anyURI, QName, and NOTATION. Boolean Data Type The boolean data type is used to specify a true or false value. The following is an example of a boolean declaration in a schema: <xs:attribute name="disabled" type="xs:boolean"/> An element in your document might look like this: <prize disabled="true">999</prize> Note: Legal values for boolean are true, false, 1 (which indicates true), and 0 (which indicates false). Binary Data Types Binary data types are used to express binary-formatted data. We have two binary data types: base64Binary (Base64-encoded binary data) hexBinary (hexadecimal-encoded binary data) The following is an example of a hexBinary declaration in a schema: <xs:element name="blobsrc" type="xs:hexBinary"/>


Слайд 149

AnyURI Data Type The anyURI data type is used to specify a URI. The following is an example of an anyURI declaration in a schema: <xs:attribute name="src" type="xs:anyURI"/> An element in your document might look like this: <pic src="http://www.w3schools.com/images/smiley.gif" /> Note: If a URI has spaces, replace them with %20.


Слайд 150

Miscellaneous Data Types …


Слайд 151

Restrictions on Miscellaneous Data Types Restrictions that can be used with the other data types: enumeration (a Boolean data type cannot use this constraint) length (a Boolean data type cannot use this constraint) maxLength (a Boolean data type cannot use this constraint) minLength (a Boolean data type cannot use this constraint) pattern whiteSpace


Слайд 152

XSD Elements


Слайд 153

XSD Elements (2)


Слайд 154

XSD Elements (3)


Слайд 155

XSD ограничения/грани для типов данных


Слайд 156

Синтаксис DTD устарел и недостаточно гибок, из-за чего для некоторых задач DTD недостаточно выразительны. В документах применяется один синтаксис, а в DTD – другой. Модели содержимого и объявления списков атрибутов тяжело читать и понимать, невозможно задать шаблонов данных в элементах и атрибутах. В связи с этим в 2001 году был разработан стандарт XML Schema (XSchema). Вторая версия XSchema был опубликован в 2004 (http://www.w3.org/TR/xmlschema11-1/).


Слайд 157

В отличие от синтаксиса DTD, синтаксис XML Schema является корректным (well-formed) XML, что позволяет использовать при ее редактировании излюбленные инструменты XML. Она также предоставляет значительно больший контроль над типами данных и шаблонами, образуя более привлекательный язык для соблюдения строгих требований ввода данных. Пример описания схемы бланк для переписи населения. Данная схема должна способствовать поддержке организации данных путем контроля типов данных в случае, если что-то будет введено в неверное поле. Вот как может выглядеть в XML экземпляр документа.


Слайд 158

Пример XML документа переписи <census date="1999-04-29"> <censustaker>738</censustaker> <address> <number>510</number> <street>Yellowbrick Road</street> <city>Munchkinville</city> <province>Negbo</province> </address> <occupants> <occupant status="adult"> <firstname>Floyd</firstname> <surname>Fleegle</surname> <age>61</age> </occupant> <occupant> <firstname>Phylis</firstname> <surname>Fleegle</surname> <age>52</age> </occupant> <occupant> <firstname>Filbert</firstname> <surname>Fleegle</surname> <age>22</age> </occupant> </occupants> </census>


Слайд 159

Описание схемы документа переписи <xsd:schema xmlns:xsd="http://www.w3.org/1999/XMLSchema"> <xsd:annotation> <xsd:documentation> Census form for the Republic of Oz Department of Paperwork, Emerald City </xsd:documentation> </xsd:annotation> <xsd:element name="census" type="CensusType"/> <xsd:complexType name="CensusType"> <xsd:element name="censustaker" type="xsd:decimal" minoccurs="0"/> <xsd:element name="address" type="Address"/> <xsd:element name="occupants" type="Occupants"/> <xsd:attribute name="date" type="xsd:date"/> </xsd:complexType> <xsd:complexType name="Address"> <xsd:element name="number" type="xsd:decimal"/> <xsd:element name="street" type="xsd:string"/> <xsd:element name="city" type="xsd:string"/> <xsd:element name="province" type="xsd:string"/> <xsd:attribute name="postalcode" type="PCode"/> </xsd:complexType>


Слайд 160

<xsd:simpleType name="PCode" base="xsd:string"> <xsd:pattern value="[A-Z]-\d{3}"/> </xsd:simpleType> <xsd:complexType name="Occupants"> <xsd:element name="occupant" minOccurs="1" maxOccurs="50"> <xsd:complexType> <xsd:element name="firstname" type="xsd:string"/> <xsd:element name="surname" type="xsd:string"/> <xsd:element name="age"> <xsd:simpleType base="xsd:positive-integer"> <xsd:maxExclusive value="200"/> </xsd:simpleType> </xsd:element> </xsd:complexType> </xsd:element> </xsd:complexType> </xsd:schema>


Слайд 161

Объявление элементов и атрибутов В первой строке документ идентифицируется как схема и связывается с пространством имен XML Schema. Для удобства в дальнейшем обсуждении мы будем отбрасывать префикс пространства имен xsd:. Следующая структура, <annotation>, служит местом для документирования назначения схемы и других деталей. Следующим в нашем примере идет первое объявление типа элемента. Атрибут name присваивает родовой идентификатор, а атрибут type устанавливает тип элемента. Есть два типа элементов: простые и сложные. Объявление простого (simple) элемента не содержит атрибутов или элементов в содержимом. Поскольку данный конкретный элемент является корневым, он должен иметь иной тип – сложный. В данном случае сложному типу в действительности дается имя, CensusType, которое нам позднее пригодится для его описания. Хотя имена не являются обязательными, все же лучше использовать их для вашего же собственного блага.


Слайд 162

Сложные и простые типы элементов В следующей части схемы CensusType определяется как элемент <complexType>. В нем содержатся объявления еще трех элементов и объявление атрибута. Здесь не только объявляются три элемента: <censustaker> (счетчик), <address> (адрес) и <occupants> (жильцы), но и определяется модель содержимого для CensusType. Поэтому элемент <census> должен содержать все три элемента в указанном порядке и может иметь необязательный атрибут date. Это значительно отличается от стиля DTD, в котором модель содержимого состоит из строки внутри объявления элемента, а атрибуты объявляются отдельно в объявлении списка атрибутов. Ограничения модели содержимого Если последовательность отдельных элементов не предоставляет достаточной информации, в XML Schema есть другие возможности. Атрибуты minOccurs и maxOccurs устанавливают (минимальное и максимальное) число появлений чеголибо в документе. minOccurs="0" отменяет значение по умолчанию 1 и делает элемент необязательным. maxOccurs="*" снимает верхнюю границу, и элемент может появляться любое число раз.


Слайд 163

Ограничение модели содержимого Элементы составных типов могут иметь разные модели содержимого. Модели содержимого элементов, которые могут включать дочерние узлы, могут быть одного из трех видов: <xs:sequence>, <xs:choice> или <xs:all>. При определении нового составного типа путем наложения ограничения на другой тип необходимо гарантировать, что модели содержимого обоих типов удовлетворяют ряду условий. Эти условия необходимы для гарантии того, что любое корректное содержимое производного типа является корректным по отношению и к базовому типу.


Слайд 164

Типы данных В каждом объявлении элемента и атрибута есть атрибут type, как мы видели в объявлении первого элемента. Некоторые типы являются предопределенными в XML Schema, например, string и decimal. Тип string представляет обычные символьные данные, как тип CDATA в языке DTD. Тип decimal представляет собой число. Ниже мы объявляем элемент <age> как имеющий тип positive-integer и ограничиваем сверху его величину значением 200. В DTD это сделать нельзя, в нем нет способа наложить на символьные данные шаблон ограничений, а в XML Schema таких способов несколько.


Слайд 165

Предопределенные типы данных В следующем списке перечислены еще некоторые предопределенные типы: byte, float, long - Числовые форматы. Формат byte является любым 8-разрядным числом со знаком, а long - любым 32-разрядным числом со знаком. Тип float представляет число с плавающей точкой, например, 5.032E-6. Другие числовые величины представляют скорее абстракции, а не числа, например, INF (бесконечность), –INF (отрицательная бесконечность) и NaN (not a number – не число, категория, определенная IEEE для операций с плавающей точкой). time, date, timeinstant, timeduration - Шаблоны для обозначения времени, даты и длительности. boolean - Значение true или false. Допускаются также числовые эквиваленты: 0 или 1. binary - Шаблон для двоичных чисел, например, 00101110. language - Код языка, скажем, en-US. uri-reference - Шаблон для любого URI, например, http://|www.donut.org/cruller.xml#ingredients. ID, IDREF, IDREFS, NMTOKEN, NMTOKENS - Типы атрибутов, действующие так же, как соответствующие типы в DTD.


Слайд 166

Грани Грани (facets) представляют собой свойства, используемые для задания типов данных, устанавливая пределы и ограничения на величину данных. Например, элементу <age>, тип данных которого positive-integer, было разрешено максимальное значение 200, называемое гранью max-inclusive. В XSchema есть еще 13 граней, в том числе precision, scale, encoding, pattern, enumeration, max-length (точность, масштаб, кодировка, шаблон, перечисление, максимальная длина) и другие.


Слайд 167

Шаблоны Объявление сложного типа Address знакомит нас с другим типом ограничения по шаблону. Он имеет атрибут postalcode с типом PCode, который определен посредством объявления <pattern>. Если среди предопределенных типов нет нужного шаблона, с помощью этого элемента можно создать свой собственный. В рассматриваемой схеме PCode определен строкой шаблона [A-Z]-\d{3}, которую нужно читать следующим образом: «любой символ алфавита, за которым следует дефис и три цифры».


Слайд 168

XML документ <BOOKS> <BOOK YEAR="1999 2003"> <AUTHOR>Abiteboul</AUTHOR> <AUTHOR>Buneman</AUTHOR> <AUTHOR>Suciu</AUTHOR> <TITLE>Data on the Web</TITLE> <REVIEW>A <EM>fine</EM> book.</REVIEW> </BOOK> <BOOK YEAR="2002"> <AUTHOR>Buneman</AUTHOR> <TITLE>XML in Scotland</TITLE> <REVIEW><EM>The <EM>best</EM> ever!</EM></REVIEW> </BOOK> </BOOKS>


Слайд 169

DTD (Document Type Definition) <!ELEMENT BOOKS (BOOK*)> <!ELEMENT BOOK (AUTHOR+, TITLE, REVIEW?)> <!ATTLIST BOOK YEAR CDATA #OPTIONAL> <!ELEMENT AUTHOR (#PCDATA)> <!ELEMENT TITLE (#PCDATA)> <!ENTITY % INLINE "( #PCDATA | EM | BOLD )*"> <!ELEMENT REVIEW %INLINE;> <!ELEMENT EM %INLINE;> <!ELEMENT BOLD %INLINE;>


Слайд 170

XML Schema <xsd:schema targetns="http://www.example.com/books" xmlns="http://www.example.com/books" xmlns:xsd="http://www.w3.org/2001/XMLSchema" attributeFormDefault="qualified" elementFormDefault="qualified"> <xsd:element name="BOOKS"> <xsd:complexType> <xsd:sequence> <xsd:element ref="BOOK" minOccurs="0" maxOccurs="unbounded"/> </xsd:sequence> </xsd:complexType> </xsd:element> <xsd:element name="BOOK"> <xsd:complexType> <xsd:sequence> <xsd:element name="AUTHOR" type="xsd:string" minOccurs="1« maxOccurs="unbounded"/> <xsd:element name="TITLE" type="xsd:string"/> <xsd:element name="REVIEW" type="INLINE" minOccurs="0" maxOccurs="1"/> <xsd:sequence> <xsd:attribute name="YEAR" type="NONEMPTY-INTEGER-LIST" use="optional"/> </xsd:complexType> </xsd:element>


Слайд 171

<xsd:complexType name="INLINE" mixed="true"> <xsd:choice minOccurs="0" maxOccurs="unbounded"> <xsd:element name="EM" type="INLINE"/> <xsd:element name="BOLD" type="INLINE"/> </xsd:choice> </xsd:complexType> <xsd:simpleType name="INTEGER-LIST"> <xsd:list itemType="xsd:integer"/> </xsd:simpleType> <xsd:simpleType name="NONEMPTY-INTEGER-LIST"> <xsd:restriction base="INTEGER-LIST"> <xsd:minLength value="1"/> </xsd:restriction> </xsd:simpleType> </xsd:schema>


×

HTML:





Ссылка: