Въведение в XML Schema

Въведение

Какво е XML?

XML (eXtensible Markup Language) е език, който комбинира, както текст, така и допълнителна информация за самия текст (markup language). Разбира се, има много подобни езици, които вършат тази работа. Един от най-разпространените е HTML (HyperText Markup Lanugage). Предимството на XML е, че той дава възможност на програмистите да създават свои собствени формати за съхраняване и споделяне на информация. Въпреки сходството си с HTML и SGML, това, което го прави различен, е неговата гъвкавост. С помощта на XML всякакъв вид информация може да се пренася между различни информационни системи, особено Интернет, където е най-често използван.

Какво е XML Schema?

XML Schema представлява XML документ, където се описва структурата и дизайна на друг XML документ, който съдържа дадена информация. Както всички XML схема езици, XML Schema се използва да изрази схема: инструкция, на която XML документ съответствува, за да бъде считан за действителен според тази схема. Обаче, за разлика от болшинството от другите схема езици, XML Schema също така е проектиран с намерението за утвърждаване на достоверност и действителност. Така различни приложения, които си обменят информация посредством XML, могат да проверят дали документите, които си предават помежду си, отговарят на дадени изисквания, необходими за правилното им интерпретиране. За това е необходимо предварително да се създаде такъв XML Schema документ (който е известен под името XML Schema Definition - XSD), спрямо който да се проверява съдържанието на информацията.

История

Това е първия одобрен схематичен език, използващ XML, в архива с препоръки на W3C World Wide Web Consortium. Препоръката на W3C e от май 2001 година. По отношение на препращанията, XML Schema е повлияна от DTD и другите ранни усилия за създаване на XML схема както например, DDML, SOX, XML-Data, и XDR. Оказва се че има избрани парчета от всички тези предложения, но също така е компромис между тях. Някои от тези езици, като XDR и SOX продължават да бъдат използвани и поддържани впоследствие публикуването на XML Schema. Много Microsoft продукти поддържаха XDR до пускането на MSXML 4.0 през октомври 2001(който заменя XDR с XML Schema). Commerce One Inc. поддържа неговия SOX Schema език до обявяване на банкрут в края на 2004. През декември на 2006-та, Novell Inc. купи патентите на компанията, включително онези свързана с SOX. От компанията завеждат много патентно-свързани съдебни процеси срещу компании използващи неправомерно SOX Schema.

XML Schema

Резюме

В тази статия ще ви запозная със същността на XML Schema като заедно с информацията за синтаксиса на този документ ще ви показвам и подходящ пример, онагледяващ как изглеждат нещата на практика. За примерите ще се спра на една училищна информационна система – информация за училището, учители, ученици, оценки и т.н.

Начало

Ето как изглежда един XSD документ най-общо.

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

Както всеки XML документ, и XML Schema съдържа в началото версията и кодировката на информацията. Най-разпространената кодировка е UTF-8. Цялата информация в документа трябва да е поместена между таговете <xs:schema></xs:schema>. Префиксътxs обозначава пространството от имена на XML Schema - http://www.w3.org/2001/XMLSchema

Елементи

Нека да разгледаме следния XML документ, който описва информация за училището.

<schoolName>ПМГ "Екзарх Антим I"</schoolName>
<builtDate>1970-10-17</builtDate>
<address>гр. Видин</address>

А ето как ще изглежда и частта от XSD документа, в която е описана структурата на по-горния документ.

<xs:element name="schoolName" type="xs:string" />
<xs:element name="builtDate" type="xs:date" />
<xs:element name="address" type="xs:string" />

Тагът <xs:element /> обозначава елемент от описания XML документ. Атрибутът name показва името на елемента, а атрибутът type показва негови тип – цяло число, низ, дата и т.н. Елементите се делят на два вида – прости и сложни.

Прости елементи

Простите елементи могат да съдържат само и единствено текст. Пример за прости елементи са тези, с които се срещнахте малко по-горе. За един прост елемент можете да укажете, както неговот име и тип, така и стойност по подразбиране или фиксирана стойност.

<xs:element name="schoolType" type="xs:string" default="high" />
<xs:element name="schoolType" type="xs:string" fixed="high" />

С атрибута default указвате стойност по подразбиране на елемента. Фактически, ако при попълването на информацията, този елемент е оставен празен, той автоматично ще получи стойността, указана този атрибут. Другият атрибут fixed пък указва фиксирана стойност на елемента. Ако се опитате да въведете други стойности, в крайна сметка ще се изведе тази, указана в него.

Сложни елементи

Сложните елементи, за разлика от простите, могат да съдържат в себе си, както текст, така и други елементи и атрибути. Освен това, те могат да бъдат празни. Ето някои примери за сложни елементи в един XML документ:

<school id="123" />

<student>
<name>Любо</name>
<age>15</age>
</student>

<teacher subject="math">Петър Иванов</teacher>

Повече за сложните елементи, ще научите малко по-долу в раздела Съставни типове.

Атрибути

Атрибутите в XML документа имат за цел да дават допълнителна информация за елементите. Един атрибут може да съдържа само и единствено текст. Няма сложни атрибути. Искаме да укажем номера на даден ученик в класа. Ето какво ще трябва да направим:

<xs:attribute name="studentNo" type="xs:integer" />

С тагът <xs:attribute /> указваме, че ще следва информация за атрибут, а чрез атрибутите name и type указваме съответно името на атрибута и неговия тип. Ето как в нашия XML документ можем да използваме създадения атрибут:

<student studentNo="5">Иван Петров</student>

Както и при елементите можем да укажем стойност по подразбиране и фиксирана стойност, така и тук можем да направим същото.

<xs:attribute name="studentNo" type="xs:integer" default="1" />
<xs:attribute name="studentNo" type="xs:integer" fixed="9" /> <xs:attribute name="studentNo" type="xs:integer" use="required" />
<xs:attribute name="studentNo" type="xs:integer" use="optional" />
<xs:attribute name="studentNo" type="xs:integer" use="prohibited" />

Освен това, атрибутите могат да са задължителни, незадължителни или забранени. По подразбиране всички атрибути са задължителни.

Типове данни

Основни типове

Някои от основните типове данни са:

  • xs:string - низ
  • xs:ineteger - описва цяло число (положително или отрицателно)
  • xs:date - допустими стойности са дати от Грегорианския календар, които са във формат YYYY-MM-DD (година-месец-ден) (пример: 1988-10-02)
  • xs:time - времето във формат HH:mm:ss (час-минути-секунди) (пример: 12:04:56, възможно е и да бъдат включени стотните - 12:04:56.6)
  • xs:float - множеството от стойности са 32-битови дробни числа, както и положителната и отрицателната нула (0; -0), безкрайност (+INF; -INF), не-е-число (NaN)
  • xs:boolean - вярно (true) или невярно (false)

Създаване на прости типове

Когато започнем да въвеждаме информация за учениците и учителите, ще ни се наложи да конкретизираме някои от данните. Например, ЕГНто на ученика. Както знаем, едно ЕГН се състои от 10 цифри. За това поле по принцип бихме могли да използваме типа xs:ineteger, но то не ни дава никаква гаранция, че цифрите са точно 10 ... За тази цел в XSD документа можете да създавате свои типове – прости и сложни. В този раздел ще ви демонстрирам как могат да се създават прости типове.

Ето как изглежда един новосъздаден прост тип:

<xs:simpleType name="egn">
...
</xs:simpleType>

Тагът <xs:simpleType /> указва, че следва декларация на прост тип, а атрибутът name указва неговото име. След като вече сме създали наш собствен тип, можем да го използваме при създаването на елементи:

<xs:element name="studentEgn" type="egn" />

Обединение

Понякога ни се налага да въведем информация или от един тип или от друг. За тази цел имаме възможността да зъдадеме нов тип, който обединява няколко други типа.

<xs:simpleType name="stringOrInt">
<xs:union memberTypes="xs:string xs:integer" />
</xs:simpleType>

С помощта на тага <xs:union /> можем да обединим няколко други типа в един. В атрибута memberTypes се изреждат типовете данни, разделени с интервал. Така елементите от новосъздадения тип (stringOrInt) ще бъдат валидни само, ако съдържат в себе си низ или число.

Списък

Искаме да въведеме оценките на даден ученик. За целта можем да създадем тип, който представлява списък от елементи от даден прост тип, разделени с интервал.

<xs:simpleType name="marks">
<xs:list itemType="xs:integer" />
</xs:simpleType>

Тагът <xs:list /> указва самия списък, а неговия атрибут itemType указва от какъв тип ще бъдат елементите в този списък. Ето и един валиден елемент от тип marks.

<studentMarks>2 4 6 6 5</studentMarks>

Ограничения

Понякога ни се налага да ограничим даден тип по някакъв начин. Например искаме да въведем годините на даден ученик. Ще използваме тип xs:integer, но той няма да е достатъчен, защото нямаме гаранция, че няма да бъде въведена отрицателна стойност, например. За тази цел, можем да използваме няколко ограничения.

<xs:simpleType name="age">
<xs:restriction base="xs:integer">
<xs:minInclusive value="13" />
<xs:maxInclusive value="19" />
</xs:restriction>
</xs:simpleType>

Чрез тага <xs:restriction /> указваме, че ще следва ограничение. Неговият атрибут base указва основният тип, върху който ще наложим ограниченията. С помощта на елементите <xs:minInclusive /> и <xs:maxInclusive /> указваме, че минималата стойност на полето age е 13, а максималната – 19 (включително).

Освен тези две ограничения, има още няколко по-основни. За числа, освен <xs:minInclusive /> и <xs:maxInclusive /> можем да използваме и <xs:minExclusive />, <xs:maxExclusive /> и <xs:totalDigits />. За типа xs:decimal можем да използваме и <xs:fractionDigits />, което указва броя на цифрите след десетичната запетая. Ограниченията за xs:string> елементи и производните на тях са <xs:length />, <xs:minLength /> и <xs:maxLength /> - дължина, минимална дължина и максимална дължина.

Можем също да ограничим даден тип до това, да може да се избере една от няколко възможни стойности, като използваме <xs:enumeration />.

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

Друга възможност за създаване на ограничения ни предлага тагът <xs:pattern />. Този таг наистина дава една голяма възможност да се филтрират данните, тъй като използва така наречените регулярни изрази. Ще ви демонстрирам една част от тях.

1. <xs:pattern value="[123]" />
2. <xs:pattern value="[1-7]" />
3. <xs:pattern value="[a-zA-Z]" />
4. <xs:pattern value="([a-z0-9])*" />
5. <xs:pattern value="([a-z0-9])+" />
6. <xs:pattern value="[0-9]{10}" />
7. <xs:pattern value="male|female" />
  1. позволена стойност е 1, 2 или 3
  2. позволени стойности са цифрите от 1 до 7
  3. позволени са малки или главни букви
  4. позволени са всякакви последователности от малки букви и цифри, както и полето може да е празно
  5. позволени са всякакви комбинации от малко букви и цифри, но полето не може да бъде празно
  6. позволени са цифрите от 0 до 9 като дължината на полето трябва да е от 10 символа
  7. позволена е едната от двете възможности male или female

Разширения

Освен да ограничавате различните основни типове, можете и да ги разширявате. Разширенията се използват при Съставните типове.

Съставни типове

Съставните типове, както споменахме малко по-горе, съдържат в себе си текст, елементи и атрибути. Не е задължително да съдържат едно временно тези три неща. Съставните типове могат да бъдат и празни. Ето как изглежда един съставен тип:

<xs:complexType name="student">
...
</xs:complexType>

Тагът <xs:complexType /> указва, че следва декларация на съставен тип, а атрибутът name - съответно неговот име.

Празен елемент

Ето как би изглеждала декларацията на един празен елемент, който има само един атрибут.

<xs:complexType name="student">
<xs:attribute name="no" type="xs:integer" use="required" />
</xs:complexType>

А ето и самият елемент в XML документа.

<student no="12" />

Елементи само с текст

<xs:complexType name="student1">
<xs:simpleContent>
<xs:extension base="xs:string">
<xs:attribute name="class" />
</xs:extension>
</xs:simpleContent>
</xs:complexType>

<xs:complexType name="student2">
<xs:simpleContent>
<xs:restriction base="student1">
<xs:attribute name="class" use="prohibited" />
</xs:restriction>
</xs:simpleContent>
</xs:complexType>

И в двата блока дефинираме сложен тип, който съдържа само текст. Това указваме с тага <xs:simpleContent />. В този елемент можем да два начина да определим типа на съдържанието – чрез ограничение (xs:restriction) или чрез разширение (xs:extension). Атрибутът base указва типа, който ще ограничаваме или разширяваме. Типът student1 разширява основния тип xs:string с атрибута class. Ето примерен елемент, който отговаря на тази декларация.

<student1 class="12a">Петър</student1>

Във втората декларация, ограничаваме типа student1 като забраняваме атрибута class и по този начин, student2 става идентичен на типа xs:string

Елементи, съдържащи само елементи

Нека разгледаме следната ситуация. Искаме да въведеме информация за даден ученик – име, фамилия, години, егн и т.н.

<student>
<name>Иван</name>
<family>Димитров</family>
<age>17</age>
<egn>8910021812</egn>
</student>

За този случай ще трябва да декларираме сложния елемент student, който съдържа в себе си елементите name, family, age, egn. Ето как би изглеждала една такава декларация.

<xs:complexType name="student">
<xs:sequence>
<xs:element name="name" type="xs:string" />
<xs:element name="family" type="xs:string" />
<xs:element name="age" type="age" />
<xs:element name="egn" type="egn" />
</xs:sequence>
</xs:complexType>

Забелязвате употребата на нов таг - <xs:sequence>. Той е част от така наречените индикатори за подредба. Той указва, че елементите могат да се появяват точно в определения ред. Други възможности са: <xs:all> - елементите могат да се появяват в произволен ред, но най-много по един път; <xs:choice> - позволен е определен брой от съответните елементи. По подразбиране този брой е 1. Броя на елементите се указва, чрез атрибутите <minOccurs и maxOccurs. Ето и един пример за това.

<xs:complexType name="student">
<xs:choice>
<xs:element name="phone" type="xs:string" minOccurs="1" maxOccurs="unbounded" />
</xs:choice>
</xs:complexType>

В случая сме указали, че ученикът може да има минимум един телефонен номер. Това указваме с помощта на атрибута minOccurs. Освен това сме определили максималния брой на телефонните номера на ученика като неограничен с помощта на атрибута maxOccurs като сме му задали стойност unbounded. Двата атрибута, minOccurs и maxOccurs, могат да приемат стойности по-големи или равни на нула, както и unbounded. Ако се използват в <xs:all> могат да приемат само стойности 0 или 1.

Можем да създаваме и отделни групи, с които да работим в състваните типове. Това позволява да се правят по-сложни ограничения за реда и броя на елементите - например, когато искаме няколко елемента да присъстват всички или нито един. Групирането става с помощта на тага <xs:group> като му се указва дадено име.

<xs:group name="address">
<xs:sequence>
<xs:element name="city" type="xs:string" />
<xs:element name="zip" type="xs:integer" />
<xs:element name="country" type="xs:string" />
</xs:sequence>
</xs:group>

Така дефинирахме група address. Сега да видим как да я използваме при съставянето на сложен тип.

<xs:complexType name="student">
<xs:sequence>
<xs:element name="name" type="xs:string" />
<xs:group ref="address" />
</xs:sequence>
</xs:complexType>

Така елемент от тип student ще съдържа елемента name и елементите от групата address.

Можем да дефинираме и група от атрибути като използваме тага <xs:attributeGroup>

<xs:attributeGroup name="studentInfo">
<xs:sequence>
<xs:attribute name="number" />
<xs:attribute name="class" />
</xs:sequence>
</xs:attributeGroup>

След това по аналогичен начин включваме групата към съставния тип:

<xs:complexType name="student">
<xs:attributeGroup ref="studentInfo" />
</xs:complexType>

Атрибутите и групите с атрибути се слагат винаги след всички елементи в съставния тип.

Смесени елементи

Смесените елементи съдържат в себе си, както текст, така и други елементи. За целта ще добавим към описанието на съставния тип нов атрибут, който указва, че около елементите в него може да има текст - mixed.

<xs:complexType name="studentInfo" mixed="true">
<xs:all>
<xs:element name="age" type="age" />
</xs:all>
</xs:complexType>

Ето как би изглеждал XML документа при тази дефиниция.

<studentInfo>
Казвам се Иван Петров и съм на <age>14</age> години.
</studentInfo>
Файлове, към тази статия:
articles/class_style.xsd
articles/class.xml

Коментари

Към тази статия все още няма коментари. Бъдете първи и напишете вашия коментар.

go back to see all articles