Проверка по xml-схеме (xsd) с помощью xmlschemasetxml schema (xsd) validation with xmlschemaset

Определение элементов

Определением элемента заключается в определении его имени и модели контента. В XML-схеме модель контента элемента определяется его типом. Следовательно, элементы в XML-документе могут иметь только значения, которые подходят типам, определенным в его схеме.


Простые типы

Спецификация XML-схемы определяет несколько простых типов для значений, как показано в Таблице 2 -предопределенные простые типы значений.

Тип элемента может быть простым или комплексным (сложным). Элемент простого типа не может содержать другие элементы или атрибуты. Комплексный тип может создавать эффект встраивания элементов в другие элементы или может ассоциировать атрибуты с элементом. До этого момента мы использовали только примеры с простыми типами, определенными пользователем (см. ). В спецификацию XML-схемы также включены предопределенные простые типы (см. вставку ). Предопределенный простой тип ограничивает значения по их базовому типу. К примеру, значением предопределенного простого типа является подмножество значений базового типа .

Простые, не вложенные элементы имеют простой тип

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

Листинг 7: Некоторые простые типы элементов
<element name='age' type='integer'/>
<element name='price' type='decimal'/>

Элементы с атрибутами должны иметь комплексный тип

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

Листинг 8: Элемент комплексного типа
<element name='price'>
  <complexType base='decimal' derivedBy='extension'>
    <attribute name='currency' type='string'/>
  </complexType>
</element>
<!-- In XML instance document, we can write: <price currency='US'>45.50</price> -->

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

В XML-документе в элемент могут быть вложены другие элементы. Это требование выражается напрямую в DTD. XML-схема вместо этого определяет элемент и его тип, который может включать объявления других элементов и атрибутов. Пример приведен в .

XML-схема
<element name='Book' type='BookType'/>
<complexType name='BookType'>
    <element name='Title' type='string'/>
    <element name='Author' type='string'/>
</complexType>

Несмотря на то, что XML-код в соответствует обоим фрагментам DTD и XML-схемы, между ними существует большая разница. В DTD все элементы являются глобальными, тогда как XML-схема в таблице позволяет определить и локально, для появления их только в рамках элемента . Для точного повторения эффекта объявлений DTD в XML-схеме, элементы и должны иметь глобальную область действия, как это показано в . Атрибут элемента позволяет ссылаться на предыдущие объявленные элементы.

Листинг 9: Комплексный тип, состоящий из глобальных простых типов
<element name='Title' type='string'/>
<element name='Author' type='string'/>
<element name='Book' type='BookType'/>
<complexType name='BookType'>
   <element ref='Title'/>
   <element ref='Author'/>
</complexType>

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

Обратите внимание, что фрагмент XML-документа из подходит для всех трех фрагментов схемы из , и

Листинг 10: Скрытие BookType как локального типа
<element name='Title' type='string'/>
<element name='Author' type='string'/>
<element name='Book'>
   <complexType>
      <element ref='Title'/>
      <element ref='Author'/>
   </complexType>
</element>

Использование именованных типов

Способ третий дизайн определяет классы или типы, что позволяет повторно использовать определения элементов. Это делается путем именования элементов simpleTypes и complexTypes, а затем указать на них через type атрибута элемента.

Вот уже третий дизайн файла схемы («shiporder.xsd») :

<?xml version=»1.0″ encoding=»UTF-8″ ?> <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=»{6}»/>   </xs:restriction> </xs:simpleType> <xs:complexType name=»shiptotype»>   <xs:sequence>     <xs:element name=»name» type=»stringtype»/>     <xs:element name=»address» type=»stringtype»/>     <xs:element name=»city» type=»stringtype»/>     <xs:element name=»country» type=»stringtype»/>   </xs:sequence> </xs:complexType> <xs:complexType name=»itemtype»>   <xs:sequence>     <xs:element name=»title» type=»stringtype»/>     <xs:element name=»note» type=»stringtype» minOccurs=»0″/>     <xs:element name=»quantity» type=»inttype»/>     <xs:element name=»price» type=»dectype»/>   </xs:sequence> </xs:complexType> <xs:complexType name=»shipordertype»>   <xs:sequence>     <xs:element name=»orderperson» type=»stringtype»/>     <xs:element name=»shipto» type=»shiptotype»/>     <xs:element name=»item» maxOccurs=»unbounded» type=»itemtype»/>   </xs:sequence>   <xs:attribute name=»orderid» type=»orderidtype» use=»required»/> </xs:complexType> <xs:element name=»shiporder» type=»shipordertype»/> </xs:schema>

Элемент ограничение указывает на то, что тип данных был получен из пространства имен типа данных XML-схемы W3C. Таким образом, следующий фрагмент означает, что значение элемента или атрибута должно быть значение строки:

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

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

<xs:simpleType name=»orderidtype»>   <xs:restriction base=»xs:string»>     <xs:pattern value=»{6}»/>   </xs:restriction> </xs:simpleType>


Это указывает на то, что значение элемента или атрибута должно быть строкой, оно должно быть ровно шесть символов в строке, и эти символы должны быть числом от 0 до 9.

❮ Предыдущая Следующая Глава ❯

Syntax

You need to declare a schema in your XML document as follows −

Example

The following example shows how to use schema −

<?xml version = "1.0" encoding = "UTF-8"?>
<xs:schema xmlns:xs = "http://www.w3.org/2001/XMLSchema">
   <xs:element name = "contact">
      <xs:complexType>
         <xs:sequence>
            <xs:element name = "name" type = "xs:string" />
            <xs:element name = "company" type = "xs:string" />
            <xs:element name = "phone" type = "xs:int" />
         </xs:sequence>
      </xs:complexType>
   </xs:element>
</xs:schema>

The basic idea behind XML Schemas is that they describe the legitimate format that an XML document can take.

How to Define a Complex Element

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>

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>

Create a schema instance¶

Import the library and then create an instance of a schema using the path of the file containing the schema as argument:

>>> import xmlschema
>>> schema = xmlschema.XMLSchema('tests/test_cases/examples/vehicles/vehicles.xsd')

The argument can be also a file-like object or a string containing the schema definition:

>>> schema_file = open('tests/test_cases/examples/collection/collection.xsd')
>>> schema = xmlschema.XMLSchema(schema_file)
>>> schema = xmlschema.XMLSchema("""
... <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
... <xs:element name="block" type="xs:string"/>
... </xs:schema>
... """)

Strings and file-like objects might not work when the schema includes other local subschemas, because the package cannot knows anything about the schema’s source location:

>>> schema_xsd = open('tests/test_cases/examples/vehicles/vehicles.xsd').read()
>>> schema = xmlschema.XMLSchema(schema_xsd)
Traceback (most recent call last):
...
...
xmlschema.validators.exceptions.XMLSchemaParseError: unknown element '{http://example.com/vehicles}cars':

Schema:

  <xs:element xmlns:xs="http://www.w3.org/2001/XMLSchema" ref="vh:cars" />

Path: /xs:schema/xs:element/xs:complexType/xs:sequence/xs:element

In these cases you can provide an appropriate base_url optional argument to define the reference directory path for other includes and imports:

Поиск информации в XML файлах (XPath)¶

XPath ( англ. XML Path Language) — язык запросов к элементам XML-документа. XPath расширяет возможности работы с XML.

XML имеет древовидную структуру. В документе всегда имеется корневой элемент (инструкция к дереву отношения не имеет). У элемента дерева всегда существуют потомки и предки, кроме корневого элемента, у которого предков нет, а также тупиковых элементов (листьев дерева), у которых нет потомков. Каждый элемент дерева находится на определенном уровне вложенности (далее — «уровень»). У элементов на одном уровне бывают предыдущие и следующие элементы.

Это очень похоже на организацию каталогов в файловой системе, и строки XPath, фактически, — пути к «файлам» — элементам. Рассмотрим пример списка книг:

<?xml version="1.0" encoding="windows-1251"?>
<bookstore>
   <book category="COOKING">
     <title lang="it">Everyday Italian</title>
     <author>Giada De Laurentiis</author>
     <year>2005</year>
     <price>30.00</price>
   </book>
   <book category="CHILDREN">
     <title lang="en">Harry Potter</title>
     <author>J K. Rowling</author>
     <year>2005</year>
     <price>29.99</price>
   </book>
   <book category="WEB">
     <title lang="en">Learning XML</title>
     <author>Erik T. Ray</author>
     <year>2003</year>
     <price>39.95</price>
   </book>
</bookstore>

XPath запрос вернет следующий результат:

<price>30.00</price>
<price>29.99</price>
<price>39.95</price>

Сокращенная форма этого запроса выглядит так: .

С помощью XPath запросов можно искать информацию по атрибутам. Например, можно найти информацию о книге на итальянском языке: вернет .

Чтобы получить больше информации, необходимо модифицировать запрос вернет:

<book category="COOKING">
     <title lang="it">Everyday Italian</title>
     <author>Giada De Laurentiis</author>
     <year>2005</year>
     <price>30.00</price>
   </book>

В приведенной ниже таблице представлены некоторые выражения XPath и результат их работы:

An XML Schema

The following example is an XML Schema file called «note.xsd» that defines the elements of the XML document above («note.xml»):

<?xml version=»1.0″?> <xs:schema xmlns:xs=»http://www.w3.org/2001/XMLSchema» targetNamespace=»https://www.w3schools.com» xmlns=»https://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.

Что такое XML-схемы?

XML-схема описывает структуру документа XML.

Язык XML — схемы также упоминается как XML Schema Definition (XSD) .

XSD Пример

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

Цель XML-схемы является определение правовых строительных блоков документа XML:

  • элементы и атрибуты, которые могут появиться в документе
  • количество (and order of) дочерних элементов
  • типы данных для элементов и атрибутов
  • по умолчанию и фиксированные значения для элементов и атрибутов

Definition Types

You can define XML schema elements in the following ways −

Simple Type

Simple type element is used only in the context of the text. Some of the predefined simple types are: xs:integer, xs:boolean, xs:string, xs:date. For example −

<xs:element name = "phone_number" type = "xs:int" />

Complex Type

A complex type is a container for other element definitions. This allows you to specify which child elements an element can contain and to provide some structure within your XML documents. For example −

<xs:element name = "Address">
   <xs:complexType>
      <xs:sequence>
         <xs:element name = "name" type = "xs:string" />
         <xs:element name = "company" type = "xs:string" />
         <xs:element name = "phone" type = "xs:int" /> 
      </xs:sequence> 
   </xs:complexType>
</xs:element> 

In the above example, Address element consists of child elements. This is a container for other <xs:element> definitions, that allows to build a simple hierarchy of elements in the XML document.

Global Types

With the global type, you can define a single type in your document, which can be used by all other references. For example, suppose you want to generalize the person and company for different addresses of the company. In such case, you can define a general type as follows −

<xs:element name = "AddressType">
   <xs:complexType>
      <xs:sequence>
         <xs:element name = "name" type = "xs:string" />
         <xs:element name = "company" type = "xs:string" />
      </xs:sequence> 
   </xs:complexType>
</xs:element> 

Now let us use this type in our example as follows −

<xs:element name = "Address1">
   <xs:complexType>
      <xs:sequence>
         <xs:element name = "address" type = "AddressType" />
         <xs:element name = "phone1" type = "xs:int" /> 
      </xs:sequence> 
   </xs:complexType>
</xs:element> 

<xs:element name = "Address2">
   <xs:complexType>
      <xs:sequence>
         <xs:element name = "address" type = "AddressType" />
         <xs:element name = "phone2" type = "xs:int" /> 
      </xs:sequence> 
   </xs:complexType>
</xs:element> 

Instead of having to define the name and the company twice (once for Address1 and once for Address2), we now have a single definition. This makes maintenance simpler, i.e., if you decide to add «Postcode» elements to the address, you need to add them at just one place.

The Element


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=»https://www.w3schools.com» xmlns=»https://www.w3schools.com» elementFormDefault=»qualified»>… …</xs:schema>

The following fragment:

xmlns:xs=»http://www.w3.org/2001/XMLSchema»

indicates that the elements and data types used in the schema come from the «http://www.w3.org/2001/XMLSchema» namespace. It also specifies that the elements and data types that come from the «http://www.w3.org/2001/XMLSchema» namespace should be prefixed with xs:

This fragment:

targetNamespace=»https://www.w3schools.com»

indicates that the elements defined by this schema (note, to, from, heading, body.) come from the «https://www.w3schools.com» namespace.

This fragment:

xmlns=»https://www.w3schools.com»

indicates that the default namespace is «https://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.

Status of this Document

This section describes the status of this document at the time of its publication. Other documents may supersede this document. A list of current W3C publications and the latest revision of this technical report can be found in the W3C technical reports index at http://www.w3.org/TR/.

This document is a Recommendation of the W3C. It has been reviewed by W3C Members and other interested parties and has been endorsed by the Director as a W3C Recommendation. It is a stable document and may be used as reference material or cited as a normative reference from another document. W3C’s role in making the Recommendation is to draw attention to the specification and to promote its widespread deployment. This enhances the functionality and interoperability of the Web.

This document has been produced by the XML Protocol Working Group (WG) as part of the W3C Web Services Activity. The English version of this specification is the only normative version. However, for translations of this document, see http://www.w3.org/2003/03/Translations/byTechnology?technology=xop10.

Please report errors in this document to xmlp-comments@w3.org (archive). The errata list for this edition is available at http://www.w3.org/2005/01/xop10-errata

This document is based upon the XML-binary Optimized Packaging Proposed Recommendation of 16 November 2004. Feedback received during that review resulted in no changes. Evidence of interoperation between at least two implementations of this specification are documented in the Implementation Summary. Changes between these two versions are described in a diff document.

This document has been produced under the 24 January 2002 CPP as amended by the W3C Patent Policy Transition Procedure. An individual who has actual knowledge of a patent which the individual believes contains Essential Claim(s) with respect to this specification should disclose the information in accordance with section 6 of the . Patent disclosures relevant to this specification may be found on the Working Group’s patent disclosure page.


С этим читают