एक XSD इन्स्टेंस

本节会为您演示如何编写一个 XML Schema。您还将学习到编写 schema 的不同方法。

XML 文档

让我们看看这个名为 "shiporder.xml" 的 XML 文档：



 George Bush
 
  John Adams
  
Oxford Street

  London
  UK
 
 
  Empire Burlesque
  Special Edition
  1
  10.90
 
 
  Hide your heart
  1
  9.90

上面的XML文档包括根元素 "shiporder"，其中包含必须名为 "orderid" 的属性。"shiporder" 元素包含三个不同的子元素："orderperson"、"shipto" 以及 "item"。"item" 元素出现了两次，它含有一个 "title"、一个可选 "note" 元素、一个 "quantity" 以及一个 "price" 元素。

ऊपरी इस वाक्य xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" को हमें बताता है कि XML परिण्टर को किस schema के अनुसार दस्तावेज़ की प्रवर्तना करने के लिए क्या करना है। इस वाक्य: xsi:noNamespaceSchemaLocation="shiporder.xsd" के माध्यम से schema का स्थान (यहाँ यह "shiporder.xml" से एक ही फ़ोल्डर में है) निर्धारित किया गया है。

एक XML Schema बनाएं

अब, हमें उपरोक्त XML डॉक्यूमेंट के लिए एक schema बनाना है:

हम एक नया फ़ाइल खोल कर इसे "shiporder.xsd" के नाम से नामित कर सकते हैं, और schema बनाने के लिए निर्धारित XML डॉक्यूमेंट की संरचना का अनुसरण करने की जरूरत है, और हमें खोजे गए हर एलीमेंट को परिभाषित करना है। पहले, हम एक मानक XML घोषणा को परिभाषित करना शुरू करते हैं:

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

उपरोक्त schema में, हमारे पास मानक नामस्पेक्ट (xs) का इस्तेमाल किया गया है, जिसका URI Schema के भाषा परिभाषा (Schema language definition) से संबंधित है, जिसका मान http://www.w3.org/2001/XMLSchema है:

अगले, हमें "shiporder" एलीमेंट को परिभाषित करना है। यह एलीमेंट एक अटिविटी रखता है जिसमें अन्य एलीमेंट हैं, इसलिए हम इसे कंपोजिट टाइप मानते हैं। "shiporder" एलीमेंट के सब-एलीमेंट xs:sequence एलीमेंट द्वारा घेरा हुआ है, जो सब-एलीमेंट की क्रमिक अनुक्रम को परिभाषित करता है:

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

तब, हम "orderperson" एलीमेंट को सरल टाइप (इसलिए क्योंकि यह कोई अटिविटी या अन्य एलीमेंट नहीं शामिल करता) के रूप में परिभाषित करना है। टाइप (xs:string) का पूर्व-संकेतन नामस्पेक्ट के पूर्व-संकेतन से निर्दिष्ट होता है, जो अनुसूचित schema डेटाटाइप के XML schema से संबंधित है:

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

अगले, मुझे दो एलीमेंट को कंपोजिट टाइप के रूप में परिभाषित करना है: "shipto" और "item"। हम "shipto" एलीमेंट को परिभाषित करना शुरू करते हैं:

<xs:element name="shipto">
 <xs:complexType>
  <xs:sequence>
   <xs:element name="name" type="xs:string"/>
   <xs:element name="address" type="xs:string"/>
   <xs:element name="city" type="xs:string"/>
   <xs:element name="country" type="xs:string"/>
  </xs:sequence>
 </xs:complexType>
</xs:element>

schema के माध्यम से, हम maxOccurs और minOccurs अटिविटी को इस्तेमाल करके किसी एलीमेंट के दिखने की संख्या को परिभाषित कर सकते हैं। maxOccurs एक एलीमेंट के दिखने की अधिकतम संख्या को परिभाषित करता है, जबकि minOccurs एक एलीमेंट के दिखने की न्यूनतम संख्या को परिभाषित करता है। maxOccurs और minOccurs का डिफ़ॉल्ट मान 1 है!

अब, हम "item" एलीमेंट को परिभाषित कर सकते हैं। यह एलीमेंट "shiporder" एलीमेंट के अंदर कई बार दिखा सकता है। इसे "item" एलीमेंट के maxOccurs अटिविटी के मान को "unbounded" में सेट करके हासिल किया जाता है, इस तरह "item" एलीमेंट कई बार दिख सकता है जितना निर्माता चाहता है। ध्यान दें कि, "note" एलीमेंट एक वैकल्पिक एलीमेंट है। हमने इस एलीमेंट के minOccurs अटिविटी को 0 सेट किया है:

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

अब, हम "shiporder" अभिकल्पनतत्व के गुण को घोषित कर सकते हैं। यह एक अनिवार्य गुण है, इसलिए हम उपयोग करते हैं -> use="required"。

टिप्पणी:इस गुण के घोषणा को अंत में रखना चाहिए:

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

यह इस नाम "shiporder.xsd" के schema फ़ाइल के दस्तावेज़ सूची है:

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

Schema विभाजित करना

पहले का डिजाइन तरीका बहुत आसान है, लेकिन जब दस्तावेज़ ज्यादा कठिन होता है, तो यह पढ़ने और रख-रखाव करने में मुश्किल होता है。

अगले डिजाइन तरीका पहले से आगे ले जाता है कि सभी अभिकल्पनतत्वों और गुणों के परिभाषण को देखा जाए, फिर ref गुण का उपयोग करके उनका संदर्भ लिया जाए।

यह नए तरीके से डिजाइन किया गया schema फ़ाइल है:

<?xml version="1.0" encoding="ISO-8859-1" ?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
यहाँ सरल अभिकल्पनतत्व के परिभाषण है ->
<xs:element name="orderperson" type="xs:string"/>
<xs:element name="name" type="xs:string"/>
<xs:element name="address" type="xs:string"/>
<xs:element name="city" type="xs:string"/>
<xs:element name="country" type="xs:string"/>
<xs:element name="title" type="xs:string"/>
<xs:element name="note" type="xs:string"/>
<xs:element name="quantity" type="xs:positiveInteger"/>
<xs:element name="price" type="xs:decimal"/>
इस अभिकल्पनतत्व के परिभाषण ->
<xs:attribute name="orderid" type="xs:string"/>
यहाँ संकल्पना एक अभिकल्पनतत्व है ->
<xs:element name="shipto">
 <xs:complexType>
  <xs:sequence>
   <xs:element ref="name"/>
   <xs:element ref="address"/>
   <xs:element ref="city"/>
   <xs:element ref="country"/>
  </xs:sequence>
 </xs:complexType>
</xs:element>
<xs:element name="item">
 <xs:complexType>
  <xs:sequence>
   <xs:element ref="title"/>
   <xs:element ref="note" minOccurs="0"/>
   <xs:element ref="quantity"/>
   <xs:element ref="price"/>
  </xs:sequence>
 </xs:complexType>
</xs:element>
<xs:element name="shiporder">
 <xs:complexType>
  <xs:sequence>
   <xs:element ref="orderperson"/>
   <xs:element ref="shipto"/>
   <xs:element ref="item" maxOccurs="unbounded"/>
  </xs:sequence>
  <xs:attribute ref="orderid" use="required"/>
 </xs:complexType>
</xs:element>
</xs:schema>

नामित टाइप (Named Types) का उपयोग करें

तीसरी डिजाइन विधि वर्ग या टाइप को परिभाषित करती है, इससे हमें एलीमेंट के परिभाषण को दोहराने की क्षमता मिलती है. विशेष तरीका यह है: पहले सरल एलीमेंट और कॉम्पोज़ीट एलीमेंट को नाम करें, फिर एलीमेंट के type अट्रिब्यूट के द्वारा इनको संदर्भित करें.

यह तीसरी विधि के द्वारा डिजाइन किया गया schema फ़ाइल ("shiporder.xsd") है:

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

restriction एलीमेंट डाटा टाइप को W3C XML Schema नामस्पेस के डाटा टाइप से प्राप्त करता है। इसलिए, नीचे का तथ्य एलीमेंट या एट्रिब्यूट के मान को चरित्र टाइप के मान होना चाहिए:

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

restriction एलीमेंट अक्सर एलीमेंट पर सीमांकन लगाने के लिए उपयोग किया जाता है। नीचे दिए गए schema के इस तथ्य को देखें:

<xs:simpleType name="orderidtype">
 <xs:restriction base="xs:string">
  <xs:pattern value="[0-9]{6}"/>
 </xs:restriction>
</xs:simpleType>

इस कोड इंडिकेट करता है कि एलीमेंट या गुण का मूल्य चारी अक्षर होना चाहिए, और ये अक्षर केवल 0-9 के न्यूमेरिक अक्षर होने चाहिए。