XSD 限定 / Facets

నిర్వచన (restriction) ఎక్సీంప్లోర్ లేదా అంశాలకు అంగీకరించబడే విలువలను నిర్వచించడానికి ఉపయోగిస్తారు. XML మూలకాలపై నిర్వచనం అని పిలుస్తారు.

విలువల పరిమితి

ఈ ఉదాహరణలో, "age" పేరుతో ఒక పరిమితమైన మూలకాన్ని నిర్వచించబడింది. 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>

విలువల సమితి పరిమితి

XML మూలకం యొక్క లోపలి విషయాన్ని ఒక అంగీకరించబడే విలువల సమితిగా నిర్వచించడానికి, మేము అనుక్రమణ పరిమితి (enumeration constraint) ఉపయోగిస్తాము:

ఈ ఉదాహరణలో, "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>

పైని ఉదాహరణ ఈ ప్రకారం కూడా వ్రాయబడవచ్చు:

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

ప్రత్యామ్నాయంగా:ఈ పరిస్థితిలో, "carType" రకం ఇతర మూలకాలు ఉపయోగించవచ్చు, ఎందుకంటే ఇది "car" మూలకం యొక్క భాగం కాదు:

విలువల శ్రేణి పరిమితి

XML మూలకం యొక్క లోపలి విషయాన్ని ఒక పరిమితమైన సంఖ్యలు లేదా అక్షరాల శ్రేణిగా నిర్వచించడానికి, మేము నమూనా పరిమితి (pattern constraint) ఉపయోగిస్తాము:

ఈ ఉదాహరణలో, "letter" పేరుతో ఒక పరిమితమైన మూలకాన్ని నిర్వచించబడింది. అంగీకరించబడే విలువలు అక్షరాలు a - z లో ఒకటి మాత్రమే అని చెప్పవచ్చు:

<xs:element name="letter">
<xs:simpleType>
  <xs:restriction base="xs:string">
    <xs:pattern value="[a-z]"/>
  </xs:restriction>
</xs:simpleType>
</xs:element>

తదుపరి ఉదాహరణ కూడా ఒక పరిమితమైన పేరు "initials" కలిగిన మూలకాన్ని నిర్వచించింది. అంగీకరించబడే విలువలు అక్షరాలు A - 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>

తదుపరి ఉదాహరణ కూడా ఒక పరిమితమైన పేరు "initials" కలిగిన మూలకాన్ని నిర్వచించింది. అంగీకరించబడే విలువలు అక్షరాలు a - 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>

ఈ ఉదాహరణలో "choice" పేరుతో ఒక నిర్దేశిత మెటాఅంశం నిర్వచించబడింది. అంగీకరించబడే విలువలు అక్షరాలు x, y లేదా z లో ఒకటి ఉంటాయి:

<xs:element name="choice">
<xs:simpleType>
  <xs:restriction base="xs:string">
    <xs:pattern value="[xyz]"/>
  </xs:restriction>
</xs:simpleType>
</xs:element>

ఈ ఉదాహరణలో "prodid" పేరుతో ఒక నిర్దేశిత మెటాఅంశం నిర్వచించబడింది. అంగీకరించబడే విలువలు ఐదు అరబీ నంబర్లు ఒక పంక్తిలో ఉన్నాయి, ప్రతి నంబర్ 0-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>

ఒక సరిహద్దు విలువలపై ఇతర నిర్దేశాలు:

ఈ ఉదాహరణలో "letter" పేరుతో ఒక నిర్దేశిత మెటాఅంశం నిర్వచించబడింది. అంగీకరించబడే విలువలు "a"-"z" లో ఉన్న శుభ్రతా అక్షరాలు ఒక సంఖ్యలో ఉంటాయి:

<xs:element name="letter">
<xs:simpleType>
  <xs:restriction base="xs:string">
    <xs:pattern value="([a-z])*"/>
  </xs:restriction>
</xs:simpleType>
</xs:element>

ఈ ఉదాహరణలో "letter" పేరుతో ఒక నిర్దేశిత మెటాఅంశం నిర్వచించబడింది. అంగీకరించబడే విలువలు ఒక చిన్న అక్షరం తర్వాత ఒక పెద్ద అక్షరంతో కూడిన ఒక అక్షరం లేదా అక్షరాల జంట ఉంటాయి. ఉదాహరణకు, "sToP" ఈ పెటర్న్ను దొరికించగలదు, కానీ "Stop", "STOP" లేదా "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>

ఈ ఉదాహరణలో "gender" పేరుతో ఒక నిర్దేశిత మెటాఅంశం నిర్వచించబడింది. అంగీకరించబడే విలువలు "male" లేదా "female" ఉంటాయి:

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

ఈ ఉదాహరణలో "password" పేరుతో ఒక నిర్దేశిత మెటాఅంశం నిర్వచించబడింది. అంగీకరించబడే విలువలు అక్షరాలు, విలువలు, అక్షరాలు, లేదా నంబర్లు 0-9 లో ఉన్న 8 అక్షరాల ఒక పంక్తి ఉంటాయి:

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

శుభ్రతా అక్షరాలపై నిర్దేశం:

శుభ్రతా అక్షరాలపై నియంత్రణను నిర్వహించడానికి, మాకు whiteSpace నిర్దేశం వాడాలి:

ఈ ఉదాహరణలో "address" పేరుతో ఒక నిర్దేశిత మెటాఅంశం నిర్వచించబడింది. ఈ whiteSpace నిర్దేశం "preserve" గా ఉంది, ఇది అర్ధంగా XML ప్రాసెసర్ ఏ శుభ్రతా అక్షరాలనూ తొలగించదు:

<xs:element name="address">
<xs:simpleType>
  <xs:restriction base="xs:string">
    <xs:whiteSpace value="preserve"/>
  </xs:restriction>
</xs:simpleType>
</xs:element>

ఈ ఉదాహరణ కూడా "address" పేరుతో ఒక పరిమితి కలిగిన అంశాన్ని నిర్వచించింది. ఈ whiteSpace పరిమితి "replace" గా సెట్ చేయబడింది, ఇది అర్థం చెప్పేది షెక్స్ ప్రాసెసర్ అన్ని కాలుష్యాలను (నోట్స్, క్రోస్, స్పేస్ మరియు టేబుల్స్) తొలగిస్తుంది:

<xs:element name="address">
<xs:simpleType>
  <xs:restriction base="xs:string">
    <xs:whiteSpace value="replace"/>
  </xs:restriction>
</xs:simpleType>
</xs:element>

ఈ ఉదాహరణ కూడా "address" పేరుతో ఒక పరిమితి కలిగిన అంశాన్ని నిర్వచించింది. ఈ whiteSpace పరిమితి "collapse" గా సెట్ చేయబడింది, ఇది అర్థం చెప్పేది షెక్స్ ప్రాసెసర్ అన్ని కాలుష్యాలను (నోట్స్, క్రోస్, స్పేస్ మరియు టేబుల్స్) మార్చి ఒక సింగిల్ స్పేస్ గా మార్చి, ప్రారంభం మరియు ముగింపు స్పేస్ ని తొలగిస్తుంది, మరియు పలుకులు గా పెరిగిన స్పేస్ ని ఒకే స్పేస్ గా మార్చింది:

<xs:element name="address">
<xs:simpleType>
  <xs:restriction base="xs:string">
    <xs:whiteSpace value="collapse"/>
  </xs:restriction>
</xs:simpleType>
</xs:element>

పొడవు పరిమితి

అంశంలో విలువ పొడవును పరిమితం చేయడానికి length, maxLength మరియు minLength పరిమితులను వాడాలి.

ఈ ఉదాహరణ కూడా "password" పేరుతో ఒక పరిమితి కలిగిన అంశాన్ని నిర్వచించింది. దాని విలువ 8 అక్షరాలకు ఖచ్చితంగా ఉండాలి:

<xs:element name="password">
<xs:simpleType>
  <xs:restriction base="xs:string">
    <xs:length value="8"/>
  </xs:restriction>
</xs:simpleType>
</xs:element>

ఈ ఉదాహరణ కూడా "password" పేరుతో ఒక పరిమితి కలిగిన అంశాన్ని నిర్వచించింది. దాని విలువ కనీసం 5 అక్షరాలు, గరిష్టంగా 8 అక్షరాలు ఉండాలి:

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

డేటా రకం పరిమితి

పరిమితి వివరణ
enumeration అంగీకరించే విలువల జాబితాను నిర్వచించండి.
fractionDigits అనుమతించే గుణకం గరిష్ట అంతరాన్ని నిర్వచించండి. ఇది 0 లేదా అంతకంటే ఎక్కువ ఉండాలి.
length అనుమతించే అక్షరాలు లేదా జాబితా అంశాల ప్రత్యేక సంఖ్యని నిర్వచించండి. ఇది 0 లేదా అంతకంటే ఎక్కువ ఉండాలి.
maxExclusive రంగం పైన పరిమితి ని నిర్వచించండి. అనుమతించే విలువలు ఈ విలువను కంటే తక్కువగా ఉండాలి.
maxInclusive 定义数值的上限。所允许的值必须小于或等于此值。
maxLength 定义所允许的字符或者列表项目的最大数目。必须大于或等于0。
minExclusive 定义数值的下限。所允许的值必需大于此值。
minInclusive 定义数值的下限。所允许的值必需大于或等于此值。
minLength 定义所允许的字符或者列表项目的最小数目。必须大于或等于0。
pattern అంగీకరించబడిన అక్షరాలను నిర్వచించండి. నిర్వచించబడిన ప్రకారం అక్షరాల శృంఖలం.
totalDigits అనుమతించబడిన అరబీకు సంఖ్యలను నిర్వచించండి. అందుకు అవసరమైన విలువలు ఒకటి కంటే ఎక్కువ ఉండాలి.
whiteSpace ఖాళీ అక్షరాలను (నోటిఫై, రిటర్న్, స్పేస్ మరియు టేబుల్ ట్యాబ్లేస్) ఎలా పరిగణించాలి నిర్వచించండి.