公告

翻譯：taowen

本文是XML Europe 2002會議上的一次tutorial的記錄。詳細講述了各種用來定義xml的結構應該是這樣的schema語言的特點以及用處。我將文章譯成了三部分，這是第一部分，講述基于規則的schema如何規范XML。

1. 簡介

What is a XML schema language?

什么是 XML schema 語言？

I will insist more on this point during my comparison of XML schema languages on Wednesday morning, but one thing is sure: a XML schema language is probably not what you're expecting, and its main feature is not (or not always) to describe a class of XML documents but rather to act as a filter or firewall to protect applications from the wide diversity of well formed XML documents.

我將在星期三早上對各種 XML schema 語言進行比較的時候會強調更多事情，但是一件事情是肯定的：一種 XML schema 語言可能不是你所期望的，但是它的主要特性不是（或者不總是）去描述一類 XML 文檔而是作為一個過濾器或者防火墻來把程序從各種各樣合式的 XML 文檔保護起來。

All over this tutorial we will use the following example:

整個教程我將使用這個例子：

 <?xml version="1.0"?>
 <library>
  <book id="_0836217462">
    <isbn>
      0836217462
    </isbn>
    <title>
      Being a Dog Is a Full-Time Job
    </title>
    <author-ref id="Charles-M.-Schulz"/>
    <character-ref id="Peppermint-Patty"/>
    <character-ref id="Snoopy"/>
    <character-ref id="Schroeder"/>
    <character-ref id="Lucy"/>
  </book>
  <book id="_0805033106">
    <isbn>
      0805033106
    </isbn>
    <title>
      Peanuts Every Sunday
    </title>
    <author-ref id="Charles-M.-Schulz"/>
    <character-ref id="Sally-Brown"/>
    <character-ref id="Snoopy"/>
    <character-ref id="Linus"/>
    <character-ref id="Snoopy"/>
  </book>
  <author id="Charles-M.-Schulz">
    <name>
      Charles M. Schulz
    </name>
    <nickName>
      SPARKY
    </nickName>
    <born>
      1992-11-26
    </born>
    <dead>
      2000-02-12
    </dead>
  </author>
  <character id="Peppermint-Patty">
    <name>
      Peppermint Patty
    </name>
    <since>
      1966-08-22
    </since>
    <qualification>
      bold, brash and tomboyish
    </qualification>
  </character>
  <character id="Snoopy">
    <name>
      Snoopy
    </name>
    <since>
      1950-10-04
    </since>
    <qualification>
      extroverted beagle
    </qualification>
  </character>
  <character id="Schroeder">
    <name>
      Schroeder
    </name>
    <since>
      1951-05-30
    </since>
    <qualification>
      brought classical music to the Peanuts strip
    </qualification>
  </character>
  <character id="Lucy">
    <name>
      Lucy
    </name>
    <since>
      1952-03-03
    </since>
    <qualification>
      bossy, crabby and selfish
    </qualification>
  </character>
  <character id="Sally-Brown">
    <name>
      Sally Brown
    </name>
    <since>
      1960-08-22
    </since>
    <qualification>
      always looks for the easy way out
    </qualification>
  </character>
  <character id="Linus">
    <name>
      Linus
    </name>
    <since>
      1952-09-19
    </since>
    <qualification>
      the intellectual of the gang
    </qualification>
  </character>
 </library>

An application managing the library described by this document, or even a XSLT stylesheet designed to display it would probably be very confused if the name or content of the elements are not what they expect and a the main feature of a XML schema language is to provide a formal way to describe what is expected to protect the applications from these risks of errors.

一個管理本文檔描述的庫的程序，或者甚至是一個 XSLT 樣式表被設計出來顯示它。如果元素的名字或者內容不是它所期望的，它可能被完全地困住了。而 XML schema 語言的一個主要作用就是提供一種正規的辦法來描述所期望的是什么并保護程序免于發生錯誤的風險。

2. 基于規則的語言 (XSLT & Schematron)

The most basic way to implement this firewall is to give a set of rules which need to followed by the instance documents.

最基本的實現這種防火墻的辦法是給出一組需要附帶一些例子文檔的規則。

This is the approach followed by rule based XML schema languages which main representative is Schematron. Before presenting Schematron itself, we will have a look on how XSLT may be used as a XML schema language since this is a good exercise to understand the basics of those schema languages.

這就是基于規則的 XML schema 語言所采用的辦法，其中的代表者就是 Schematron。在介紹 Schematron 之前，我們將先看看 XSLT 可以怎么用作 XML schema 語言，因為這對于理解這些 schema 語言的基本知識來說是一個很好的鍛煉。

XSLT 用作基于規則的 XML schema 語言
Schematron

2.1. XSLT 用作基于規則的 XML schema 語言

We can use "classical" programming languages to write a rule based XML schema either general purpose using a XML API or XML specific such as XSLT or XQuery.

我們可以使用 "傳統的" 編程語言來編寫基于規則的 XML schema 也能通用地使用 XML API 或者特殊的 XML 例如 XSLT 或者XQuery。

To illustrate this point, let's take the following very simple snippet of our example:

為了闡明這個觀點，讓我們來看看下面這個我們例子中非常簡單的代碼片斷：

 <?xml version="1.0"?>
 <library>
  <book id="_0836217462"/>
  <book id="_0805033106"/>
 </library>

Why so simple? Because we will see that even if it is true that we can use XSLT as a rule based XML schema language, this is quite verbose and I don't want spend all the time allocated to this tutorial to develop our schema!

為什么如此簡單？因為即使XSLT可以用作基于規則的 XML schema 語言，那也是非常冗長的我不想把所有分配給這個教程的時間用來開發我們的 schema！

To write this schema, we have basically two options which are the same than we have when we configure a firewall: the closed one where all what is not allowed is forbidden and the open one where all what is not forbidden is allowed and we will implement both schemas.

編寫這個 schema，我基本上有兩個選擇來配置防火墻：封閉的，所有不允許的都被禁止；以及開放的，所有不禁止的都被允許。我們將兩種 schema 都實現一下。

開放的 XSLT schema
封閉的 XSLT schema

The first conclusion from this simple example is that XML applications tend to forbid much more than they allow: closed schemas are often easier to write than open schemas.

從這個簡單的例子中得出的第一個推論就是 XML 程序傾向于禁止比它們允許的更多東西：封閉的 schema 比開放的 schema 一般更容易寫一些。

On the other hand, it's easier to define user friendly error messages in a open schema since the context in which something is forbidden is always determined.

另一方面，在開放 schema 中定義用戶友好的錯誤信息更加容易，因為被禁止的東西的上下文總是確定的。

2.1.1. 開放的 XSLT schema

To implement an open schema with XSLT, we will start defining a default template which will accept anything:

為了用 XSLT 實現開放的 schema，我們將從定義個一個缺省的允許所有東西的模板開始：

 <xsl:template match="*|@*|text()">
  <xsl:apply-templates select="*|@*|text()"/>
 </xsl:template>

With this single template, our "schema" would accept any well formed XML document and never raise any error and we need to add templates to define what's forbidden.

有了這個簡單的模板，我們的 "schema" 將接受任何合式的 XML 文檔，不會拋出任何錯誤并且我們需要添加模板來定義什么是被禁止的。

Like with the design of any XSLT transformation, we have the choice to implement the tests as conditions in the "match" attribute of templates or within the templates using if or choose statements. When we are using if or choose statements, we have also the choice of the location where we will will do the test.

像任何一個 XSLT 轉換的設計一樣，我們可以選擇把這個測試實現為在模板的 "match" 屬性之中或者在模板之中使用 if 或者 choose 語句。當我們使用 if 或者 choose 語句的時候，我們還可以決定哪兒進行這樣的測試。

To check that the document element is "library", we can for instance:

為了檢查文檔元素是 "library"，我可以這樣：

在 match 表達式中測試
在模板中測試

Now that we've set up the background, we can generalize it and a pretty much complete "schema" including a test for unicity of the identifiers could be:

現在我們臺子搭起來了，歸納一下，一個更完善的包括測試標識符單一性的 "schema" 可能是這樣的：

完整的 XSLT 實現的開放 schema

Note that we have left a degree of opening and that arbitrary element and text nodes can be added to the book element.

注意，我們留下了一定程度的擴展機會，任意元素和文本都能被添加到 book 元素之中。

2.1.1.1. 在 match 表達式中測試

We can write a template to allow library as document element:

我們可以編寫一個模板來允許 library 作為文檔元素：

 <xsl:template match="/library">
  <xsl:apply-templates select="*|@*|text()"/>
 </xsl:template>

But we also need to forbid other document elements:

但是我們還需要禁止其他的文檔元素：

 <xsl:template match="/*">
  <xsl:message terminate="no">
    The document element should be "library".
  </xsl:message>
  <xsl:apply-templates select="*|@*|text()"/>
 </xsl:template>

Or, alternatively, we can rely on the default template and replace both templates by a slightly more complex match expression:

或者，我們還能依賴缺省模板并且把兩個模板換成一個 match 表達式稍微復雜一些的模板：

 <xsl:template match="/*[not(self::library)]">
  <xsl:message terminate="no">
    The document element should be "library".
  </xsl:message>
  <xsl:apply-templates select="*|@*|text()"/>
 </xsl:template>

2.1.1.2. 在模板中測試

We can also perform the test in a template for the root of the document:

我們還能在模板中執行對文檔的根的測試：

 <xsl:template match="/">
  <xsl:if test="not(library)">
   <xsl:message terminate="no">
    The document element should be "library".
   </xsl:message>
  </xsl:if>
  <xsl:apply-templates select="*|@*|text()"/>
 </xsl:template>

or do the same test in a template for document element:

或者在模板中對模板元素進行相同測試：

 <xsl:template match="/*">
  <xsl:if test="not(self::library)">
   <xsl:message terminate="no">
    The document element should be "library".
   </xsl:message>
  </xsl:if>
  <xsl:apply-templates select="*|@*|text()"/>
 </xsl:template>

2.1.1.3. 完整的 XSLT 實現的開放 schema

 <?xml version="1.0" encoding="utf-8"?>
 <xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" >

 <xsl:template match="*|@*|text()">
  <xsl:apply-templates select="*|@*|text()"/>
 </xsl:template>

 <xsl:template match="/*[not(self::library)]">
  <xsl:message terminate="no">
    <xsl:text>The document element should be "library", not "</xsl:text>
    <xsl:value-of select="name()"/>
    <xsl:text>"!</xsl:text>
  </xsl:message>
  <xsl:apply-templates select="*|@*|text()"/>
 </xsl:template>

 <xsl:template match="/*/*[not(self::book)]">
  <xsl:message terminate="no">
    <xsl:text>The children elements of library should be "book", not "</xsl:text>
    <xsl:value-of select="name()"/>
    <xsl:text>"!</xsl:text>
  </xsl:message>
  <xsl:apply-templates select="*|@*|text()"/>
 </xsl:template>

 <xsl:template match="library/@*">
  <xsl:message terminate="no">
    <xsl:text>The "library" element should have no attribute, </xsl:text>
    <xsl:value-of select="name()"/>
    <xsl:text> shouldn't appear!</xsl:text>
  </xsl:message>
  <xsl:apply-templates select="*|@*|text()"/>
 </xsl:template>

 <xsl:template match="library/text()[normalize-space()]">
  <xsl:message terminate="no">
    <xsl:text>The "library" element should have no text, "</xsl:text>
    <xsl:value-of select="normalize-space()"/>
    <xsl:text>" shouldn't appear!</xsl:text>
  </xsl:message>
  <xsl:apply-templates select="*|@*|text()"/>
 </xsl:template>

 <xsl:template match="book/@*">
  <xsl:message terminate="no">
    <xsl:text>The "book" element should have no other attribute than "id", </xsl:text>
    <xsl:value-of select="name()"/>
    <xsl:text> shouldn't appear!</xsl:text>
  </xsl:message>
  <xsl:apply-templates select="*|@*|text()"/>
 </xsl:template>

 <xsl:template match="book/@id">
  <xsl:if test=". = ../preceding-sibling::book/@id">
   <xsl:message terminate="no">
     <xsl:text>The "book" id should be unique, </xsl:text>
     <xsl:value-of select="."/>
     <xsl:text> is duplicated.</xsl:text>
   </xsl:message>
  </xsl:if>
  <xsl:apply-templates select="*|@*|text()"/>
 </xsl:template>

 </xsl:stylesheet>

2.1.2. 封閉的 XSLT 實現的 schema

A closed schema is the other way round and will define defaults templates which are forbidding everything (except eventually "empty" text nodes):

封閉的 schema 是反其道而行之，定義一個禁止所有東西的缺省模板（除了最終的 "空" 文本）：

 <xsl:template match="*">
  <xsl:message terminate="no">
   <xsl:text>Forbidden element:</xsl:text>
   <xsl:value-of select="name()"/>
  </xsl:message>
  <xsl:apply-templates select="*|@*|text()"/>
 </xsl:template>

 <xsl:template match="@*">
  <xsl:message terminate="no">
   <xsl:text>Forbidden attribute:</xsl:text>
   <xsl:value-of select="name()"/>
  </xsl:message>
 </xsl:template>

 <xsl:template match="text()"/>

 <xsl:template match="text()[normalize-space()]">
  <xsl:message terminate="no">
   <xsl:text>Forbidden text:</xsl:text>
   <xsl:value-of select="."/>
  </xsl:message>
 </xsl:template>

and then define everything which is allowed, ie in fact very few things:

然后定義出所有允許的東西，事實上也就是一點東西：

 <xsl:template match="/library">
  <xsl:apply-templates select="*|@*|text()"/>
 </xsl:template>

 <xsl:template match="library/book">
  <xsl:apply-templates select="*|@*|text()"/>
 </xsl:template>

 <xsl:template match="book/@id[not (.=../preceding-sibling::book/@id)]">
  <xsl:apply-templates select="*|@*|text()"/>
 </xsl:template>

2.2. Schematron

Technically speaking, Schematron is a concise formalization of one of the examples which we have seen and generates a XSLT transformation which is an open schema (everything which has not been forbidden is allowed) with tests inside the templates.

技術上講，Schematron 是對我們看過的例子中的一個精確的形式化，并且產生的是一個 XSLT 轉換，它在模板中進行開放 schema （所有沒有被禁止的東西都被允許）測試。

That being said, XSLT is totally hidden from the Schematron user who needs to know the Schematron syntax and XPath which is used to express the rules.

也就是，XSLT 對 Schematron 的用戶完全的隱藏起來了。但是他們需要知道 Schematron 的語法以及用來表達這些規則的 XPath。

A Schematron schema is composed of a set of patterns each pattern including one or more rules and each rule being composed of asserts and reports, however, to present the syntax used by Schematron, we'll take it "bottom/up" and start with asserts and reports before seeing how they are associated into rules, patterns and schemas.

Schematron schema 由一套 pattern 組成。每個 pattern 包括一個或者多個規則，而且每個規則都由 assert 和 report 組成。然而，為了展示 Schematron 使用的語法，我們將反過來，在看它們如何關聯到規則，pattern 以及 schema 之中之前，從 assert 和 report 入手。

assert(s) 和 report(s)
rule(s)
pattern(s)
schema
合起來

2.2.1. assert(s) 和 report(s)

The "assert" and "report" elements are where the rules are defined in a Schematron schema. Both carry a "test" attribute which is an XPath expression they differ in a couple of ways:

"assert" 和 "report" 元素是在 Schematron schema 中定義規則的地方。都帶一個 XPath 表達式的 "test" 屬性，它們在幾個方面不同：

They are the opposite one of each other: the test must be true to pass in an "assert" element and false to pass in a "report" element.
The original purpose of assert is more for "fatal errors" and report more for things that should just be "reported", but this distinction is not relevant any longer in the latest version (1.5).

他們互相是對方的反面：要通過，在 "assert" 元素中 test 必須是真，而在 "report" 元素中必須是假。
assert 起初的目的更多是用于 "致命的錯誤" 而 report 更多是用于那些僅僅需要 "通報" 的東西，但是這種差別在最新的版本 (1.5) 中不存在了。

There are some goodies which we will not cover in this tutorial, but the basic syntax is:

在本教程中有許多好東西是講不到的，但是基本的語法是這樣的：

  <sch:assert test="library">
    The document element should be 'library'.
  </sch:assert>

Which raises an error with the corresponding message if there is no "library" element under the context node, or:

如果在上下文節點中沒有 "library" 元素，它拋出一個錯誤和對應的信息，或者：

  <sch:report test="@*">
     The library element should not contain attributes.
  </sch:report>

Which raises an error if there is any attribute under the context node.

如果在上下文節點中有任何屬性，它拋出一個錯誤。

In both cases, the context node is set by the "rule" parent element of the report or assert node.

在兩種情況中，上下文節點都是由 report 或者 assert 節點的 "rule" 父元素設置的。

2.2.2. rule(s)

Schematron rule elements are roughly equivalent to XSLT templates and are used to define the context under which a set of assert and report elements will be performed.

Schematron rule 元素大體上和 XSLT 模板相當并且被用來定義 assert 和report 元素將施加于的上下文。

An example of rule (without bells and whistles) performing the tests done in our open schema on the book element could be:

一個在我們的開放 schema 中對 book 元素執行測試的規則（沒有所有的花哨的東西）的例子可能是：

   <sch:rule context="book">
    <sch:report test="@*[name() != 'id']">
     The book element should not include any attribute other than "id".
    </sch:report>
    <sch:assert test="@*[namespace-uri() = '']">
     The book element should not include any attribute other than "id" (namespace).
    </sch:assert>
    <sch:report test="@id = preceding-sibling::book/@id">
     The book id should be unique.
    </sch:report>
   </sch:rule>

Some notes about rules:

一些關于規則的注意事項是：

The context of a rule cannot be set on an attribute.
The order in which the tests (report and assert elements) are performed is not guaranteed and the sequence of tests stops after the first failure.

規則的上下文不能設置為屬性。
測試（report 和 assert 元素）執行的順序是不被保證的，而且一系列測試在第一個錯誤發生的時候終止。.

2.2.3. pattern(s)

Pattern elements are sets of rules which are evaluated independently (technically using different modes in the XSLT stylesheet generated out of the Schematron schema).

Pattern 元素是一批獨立執行的規則（技術上講，在 Schematron schema 之外是使用 XSLT 樣式表中的不同 mode 來保證的）。

An example of pattern roughly equivalent to our open XSLT schema could be:

一個和我們的開放 XSLT schema 相當的例子可能是這樣：

 <sch:pattern>
   <sch:rule context="/">
    <sch:assert test="library">
     The document element should be 'library'.
    </sch:assert>
   </sch:rule>
   <sch:rule context="library">
    <sch:report test="*[not(self::book)]">
     The library element should contain only book elements.
    </sch:report>
    <sch:report test="@*">
     The library element should not contain attributes.
    </sch:report>
    <sch:report test="text()[normalize-space()]">
     The library element should not contain attributes.
    </sch:report>
   </sch:rule>
   <sch:rule context="book">
    <sch:report test="@*[name() != 'id']">
     The book element should not include any attribute other than "id".
    </sch:report>
    <sch:assert test="@*[namespace-uri() = '']">
     The book element should not include any attribute other than "id" (namespace).
    </sch:assert>
    <sch:report test="@id = preceding-sibling::book/@id">
     The book id should be unique.
    </sch:report>
   </sch:rule>
  </sch:pattern>

One of the differences with what we had implemented is that Schematron will stop the evaluation of a pattern after the first error found (following the order of the source tree) and if we wanted to be potentially able to raise several errors, we would have to spread our rules within several different patterns.

與我們已經實現的不同之處的一個是 Schematron 將在第一個錯誤發現的時候停止那個 pattern 的執行（按照源代碼樹的順序）而且如果你想要能拋出好幾個錯誤，我們需要把規則分散到好幾個不同的 pattern 之中去。

2.2.4. schema

Finally, the schema element is the document element of a Schematron schema and basically include a title and one or more patterns. To implement our rules within separated patterns, we could write:

最后，schema 元素是 Schematron schema 的文檔元素而且主要包括一個標題以及一個或者多個 pattern。要把我們的 rule 實現于好幾個 pattern 之中，我們可以這么寫：

 <?xml version="1.0" encoding="utf-8"?>
 <sch:schema xmlns:sch="http://www.ascc.net/xml/schematron">
  <sch:title>Example Schematron Schema</sch:title>
  <sch:pattern>
   <sch:rule context="/">
    <sch:assert test="library">
     The document element should be 'library'.
    </sch:assert>
   </sch:rule>
  </sch:pattern>
  <sch:pattern>
   <sch:rule context="library">
    <sch:report test="*[not(self::book)]">
     The library element should contain only book elements.
    </sch:report>
    <sch:report test="@*">
     The library element should not contain attributes.
    </sch:report>
    <sch:report test="text()[normalize-space()]">
     The library element should not contain attributes.
    </sch:report>
   </sch:rule>
  </sch:pattern>
  <sch:pattern>
   <sch:rule context="book">
    <sch:report test="@*[name() != 'id']">
     The book element should not include any attribute other than "id".
    </sch:report>
    <sch:assert test="@*[namespace-uri() = '']">
     The book element should not include any attribute other than "id" (namespace).
    </sch:assert>
    <sch:report test="@id = preceding-sibling::book/@id">
     The book id should be unique.
    </sch:report>
   </sch:rule>
  </sch:pattern>
 </sch:schema>

2.2.5. 合起來

Solving the same problem with Schematron and XSLT shows the nature of Schematron which is a subset of XSLT tailored to XML validation through open rule based schemas.

用 Schematron 和 XSLT 解決同一個問題揭示了 Schematron 的本質，即它是剪裁用于 XML 驗證的實現基于開放規則 schema 的 XSLT 子集。

Why do I insist that much on the openness of Schematron schemas?

為什么我強調 Schematron schema 的開放性？

Because the default behavior of Schematron is to be open, but it is still possible to write closed (or semi closed schemas) with Schematron even though it isn't a common practice.

因為 Schematron 的缺省行為是開放的，但是也可以用 Schematron 編寫封閉的（或者是半封閉的）schema，雖然這不是一個常見的行為。

The main trick when doing so is to note that the rules within a Schematron pattern are evaluated in lexical order instead of following the rules of priorities as defined by XSLT. The default rules which will forbid content not described in any rule need therefore to be located after all the other rules, such as in:

要那樣做的主要技巧是記住 Schematron pattern 中的規則是以詞法順序執行而不是由 XSLT 定義的優先級來決定的。缺省禁止沒有在任何規則中描述的內容的規則因而需要放在所有其他規則之后，像這樣：

 <?xml version="1.0" encoding="utf-8"?>
 <sch:schema xmlns:sch="http://www.ascc.net/xml/schematron">
  <sch:title>Example Schematron Schema</sch:title>
  <sch:pattern>
   <sch:rule context="/library">
    <sch:report test="@*">
     The library element should not contain attributes.
    </sch:report>
   </sch:rule>
   <sch:rule context="library/book">
    <sch:report test="@*[name() != 'id']">
     The book element should not include any attribute other than "id".
    </sch:report>
    <sch:assert test="@*[namespace-uri() = '']">
     The book element should not include any attribute other than "id" (namespace).
    </sch:assert>
    <sch:report test="@id = preceding-sibling::book/@id">
     The book id should be unique.
    </sch:report>
   </sch:rule>
   <sch:rule context="*">
    <sch:report test="1">
      Element "<sch:name/>" forbidden under "<sch:name path=".."/>".
    </sch:report>
   </sch:rule>
   <sch:rule context="text()[normalize-space()]">
    <sch:report test="1">
      Text forbidden in "<sch:name path=".."/>" element.
    </sch:report>
   </sch:rule>
  </sch:pattern>
 </sch:schema>

Note also the usage of the "name" element and the fact that rules can't be defined for attributes.

還要注意 "name" 元素的用法以及不能給屬性定義規則。

posted on 2004-05-24 18:49 taowen 閱讀(1001) 評論(0) 收藏舉報

刷新頁面返回頂部