Abstract

XML Schema allows greater flexibility in defining constraints on intra-document references than the ID/IDREF construct of DTDs. XML Schema's Identity Constraints are scoped, typed, and can be used for elements or attributes. The second aspect of XML Schema discussed today is the derivation of complex types. Complex types can be derived by restriction or extension. Complex type restriction defines the restricted type to be a more restricted version of the base type. Complex type extension make it possible to extend the base type by either adding attributes or contents (only by appending new content to the content model).

Named and Anonymous Types

• Types can be named or anonymous
  • named types can be reused (for elements, attributes, or type derivation)
  • anonymous types can only be used where they are defined
• DTD types are always anonymous (they cannot be reused)

<!ELEMENT person (name, address) >
<!ATTLIST person id ID #REQUIRED >

• DTDs have everything hardcoded
  • complex types are always locally defined
  • elements are always globally defined
  • attributes are always locally defined

Local vs. Global Elements

• Elements can be defined in a type or in the schema
  • local elements can only be used where they are defined
  • global elements can be reused, they can serve as building blocks
• Elements and complex types depend on each other
  • an element is defined by a type, often this will be a complex type
  • a complex type is defined by its contents, which are elements and/or attributes

 <xs:complexType name="mixedType" mixed="true">
  <xs:choice maxOccurs="unbounded" minOccurs="0">
   <xs:element ref="b"/>
   <xs:element name="i" type="xs:string"/>
   <xs:element name="u" type="xs:string"/>
  </xs:choice>
  <xs:attribute ref="class"/>
 </xs:complexType>
 <xs:element name="b" type="xs:string"/>

Reusable Elements

<?xml version="1.0" encoding="UTF-8"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
 <xs:element name="billingAddress" type="addressType"/>
 <xs:element name="shippingAddress" type="addressType"/>
 <xs:complexType name="addressType">
  <xs:sequence>
   <xs:element name="name" type="xs:string"/>
   <xs:element name="street" type="xs:string"/>
   <xs:element name="city" type="xs:string"/>
   <xs:element name="state" type="xs:string" minOccurs="0"/>
   <xs:element name="zip" type="xs:decimal"/>
  </xs:sequence>
  <xs:attribute name="country" type="xs:NMTOKEN"/>
 </xs:complexType>
</xs:schema>

Attribute Definitions

• DTDs treat attributes as something entirely different from element content
  • they are defined in an ATTLIST, not in the ELEMENT definition

    <!ELEMENT person (name, address) >
    <!ATTLIST person id ID #REQUIRED >

  • they have a special range of Attribute Types as opposed to elements

    <!ATTLIST person id ID #REQUIRED >

• XML Schema overcomes these restrictions only partially
  • Simple Types are used to define attribute (or element) contents
  • attributes are still described as something entirely different from an element's content model
• Attributes could be better integrated into the model
  • RELAX NG treats attributes as part of an element's content model
  • this makes it trivial to have choices of element content and attributes

Reusing Attributes

• DTDs treat attributes as something local to an element
  • attributes are defined in an element's ATTLIST
  • reusing attributes for more than on element requires Parameter Entities
• XML Schema better supports reuse of schema components
  • types can be defined locally (anonymous) or globally (named)
  • elements and attributes can be defined globally or locally
• Globally defined attributes can be reused
  • the attribute definition does not tie it to any occurrence
  • the attribute can then be referenced from an complex type definition

Reusing Attributes (Example)

<?xml version="1.0" encoding="UTF-8"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
 <xs:element name="p" type="mixedType"/>
 <xs:complexType name="mixedType" mixed="true">
  <xs:choice maxOccurs="unbounded" minOccurs="0">
   <xs:element ref="b"/>
   <xs:element name="i" type="xs:string"/>
   <xs:element name="u" type="xs:string"/>
  </xs:choice>
  <xs:attribute ref="class"/>
 </xs:complexType>
 <xs:element name="b" type="xs:string"/>
 <xs:attribute name="class">
  <xs:simpleType>
   <xs:restriction base="xs:string">
    <xs:enumeration value="comment"/>
    <xs:enumeration value="warning"/>
   </xs:restriction>
  </xs:simpleType>
 </xs:attribute>
</xs:schema>

Definitions

• Many XML Schemas define a vocabulary for a namespace
  • DTDs do not have any support for namespaces
  • XML Schema heavily builds on XML Namespaces
• XML Schema provides support for declaring a vocabulary's namespace

  <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" targetNamespace="http://www.example.com/">

• Schema-validation can check for proper namespace usage
  • the targetNamespace has to be used in the instance
  • if the namespace does not match, validation cannot succeed

Instances

• The schema defines the targetNamespace of the vocabulary
  • all globally defined elements, attributes, and types are in that namespace
  • the instances must declare and use the namespace to be schema-valid

<html xmlns="http://www.w3.org/1999/xhtml">
 <head>
  <title>Multicolumn Layout in HTML</title>
  <style type="text/css">

• A prefixed name is not the same as a qualified name
  • if there is a default namespace, unprefixed elements are still qualified
• Nasty details about XML Namespaces and attributes
  • the default namespace does not apply to attributes
  • attributes must therefore always be prefixed if they need to be qualified

Name Qualification

• Global elements and attributes have to be used as qualified names
  • this means that they must be referred to by their namespace-qualified name
  • if a default namespace is used, elements are qualified without carrying a prefix
  • since the default namespace does not apply to attributes, they always must be explicitly prefixed
• Local elements and attributes may be used qualified or unqualified
  • this control only applies to locally define elements or attributes
  • the default defined by XML Schema is not a good choice
  • because of how XML Namespaces work, a non-default choice is recommended
• XML Schema allows control over how local names have to be used

<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" targetNamespace="http://www.example.com/" elementFormDefault="qualified" attributeFormDefault="unqualified">

Element = Type + Constraints

• DTDs and XML Schema are mainly about specifying grammars
  • types describe the allowed values using grammars
  • grammar-oriented schemas have some nice properties
• DTD's ID/IDREF allow additional constraints
  • apart from the grammar definition, cross-references in the tree are supported
  • validation checks the integrity of the cross-references, not only the tree
• DTD's ID/IDREF are a very simple mechanism
  • they are always global
  • they also define the type of the attribute (XML names)

Improvements over ID/IDREF

• XML Schema's Identity Constraints improve DTD's ID/IDREF
• Identity constraints are scoped and apply only to a selected set of nodes
  • the constraint applies only to a selected set of nodes (using XPath)
• Identity constraints are evaluated using typed values
  • IDs must be XML names (no numbers allowed)
  • 2 ≟ +00002 should be evaluated based on the type (string or decimal?)
  • XML Schema separates the constraint from the type of the selected nodes
• Identity constraints may select elements or attributes
  • XPaths are used to select the constrained values, they can select elements or attributes
• Multiple fields
  • it is possible to select for than one field for a constraint (phone & area code must be unique)

Types of Identity Constraints

• Uniqueness constraints
  • if there is a field, it must have a unique value among the selected nodes
• Key constraints
  • there must be a field, and it must have a unique value among the selected nodes
• Key reference constraints
  • the field must refer to an existing value in the referred key
  • if the key reference also is constrained by a key, only one reference may use the referred key

Identity Constraint Definitions

• Identity constraints are part of an element definition
• There are three important factors to an identity constraint
  1. location of the identity constraint's definition
  2. the nodes to which the constraint should be applied
  3. the fields which are used to evaluate the constraint
• If the constraint is a key reference constraint, there is a fourth factor
  4. the key constraint that is used for checking the references

Identity Constraint Evaluation

Advanced Identity Constraints

Type Derivation

• XML Schema supports the modeling approach of specialization
  • simple types can be restricted to create more specialized simple types
  • each value of a restricted type is also a valid value of the more general type
• Complex types are combinations of content and attributes
• Specialization of complex types can be done in two ways
  • Complex Type Restriction: more restricted ways of using the content and/or attributes
  • Complex Type Extension: additional content and/or attributes may be used
• Both kinds of complex type derivation can be regarded as specialization
  • Complex Type Restriction: for US persons the country must always be set to US
  • Complex Type Extension: people having an employee number are employees

Removing Choices

• Complex types usually allow variability
  • minOccurs and maxOccurs allow variability in occurrences
  • choice groups allow to choose between a number of alternatives
  • attributes may be flagged as use="optional"
  • simple types allow the individual values to use certain sets of values
• Complex type restriction allows restrictions of all these variations
  • minOccurs and maxOccurs can be made more restrictive
  • alternatives can be removed from choice groups
  • optional attributes can flagged as use="required" or use="prohibited"
  • the simple types of values can be set to more restricted simple types
• The technical way of defining restrictions is cumbersome
  • when the base type changes, the restricted type has to be fixed by hand

Complex Type Restriction (Example)

<?xml version="1.0" encoding="UTF-8"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
 <xs:complexType name="addressType">
  <xs:sequence>
   <xs:element name="name" type="xs:string"/>
   <xs:element name="street" type="xs:string"/>
   <xs:element name="city" type="xs:string" minOccurs="0"/>
   <xs:choice>
    <xs:element name="state" type="xs:string"/>
    <xs:element name="canton" type="xs:string"/>
   </xs:choice>
   <xs:element name="zip" type="xs:decimal"/>
  </xs:sequence>
  <xs:attribute name="country" type="xs:NMTOKEN"/>
  <xs:attribute name="territory" type="xs:string" use="optional"/>
 </xs:complexType>
 <xs:complexType name="USaddressType">
  <xs:complexContent>
   <xs:restriction base="addressType">
    <xs:sequence>
     <xs:element name="name" type="xs:string"/>
     <xs:element name="street" type="xs:string"/>
     <xs:element name="city" type="xs:string"/>
     <xs:choice>
      <xs:element name="state" type="xs:string"/>
     </xs:choice>
     <xs:element name="zip" type="zipType"/>
    </xs:sequence>
    <xs:attribute name="country" type="xs:NMTOKEN"/>
    <xs:attribute name="territory" type="xs:string" use="prohibited"/>
   </xs:restriction>
  </xs:complexContent>
 </xs:complexType>
 <xs:simpleType name="zipType">
  <xs:restriction base="xs:decimal">
   <xs:totalDigits value="5"/>
  </xs:restriction>
 </xs:simpleType>
</xs:schema>

Processing Restricted Complex Types

• Values of restricted types are values of the base types
  • type restriction is defined so that restricted type values are always base type values
  • code processing a type can be reused to process restricted types
• If there is a well-designed type hierarchy, programming becomes easier
  • simple code can be written to handle the basic types
  • if required, more advanced code can be written for the restricted types
  • in many cases, restriction is more for validation than for processing
• XML Schemas may even use abstract types
  • no element will ever use the addressType
  • concrete elements will only use restricted types
  • there can be code handling the addressType which handles all addresses

Adding Content

• Complex types are element content and attributes
  • extensions can add content, but only at the end of the base content
  • extensions can add attributes (order is not significant for attributes)
• Adding content to existing content may not change the existing content
  • if the content is element only, it has to remain element only
  • if the content is mixed, is has to remain mixed
  • if the content is empty, it may become element only or mixed
  • the reason for these rules is that mixed is a global property of a type
• Adding attributes simply adds these to the list of existing attributes
  • the added attributes may be optional or required

Complex Type Extension (Example)

<?xml version="1.0" encoding="UTF-8"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
 <xs:complexType name="addressType">
  <xs:sequence>
   <xs:element name="name" type="xs:string"/>
   <xs:element name="street" type="xs:string"/>
   <xs:element name="city" type="xs:string" minOccurs="0"/>
   <xs:choice>
    <xs:element name="state" type="xs:string"/>
    <xs:element name="canton" type="xs:string"/>
   </xs:choice>
   <xs:element name="zip" type="xs:decimal"/>
  </xs:sequence>
  <xs:attribute name="country" type="xs:NMTOKEN"/>
  <xs:attribute name="territory" type="xs:string" use="optional"/>
 </xs:complexType>
 <xs:complexType name="businessAddressType">
  <xs:complexContent>
   <xs:extension base="addressType">
    <xs:sequence>
     <xs:element name="company" type="xs:string"/>
     <xs:element name="position" type="xs:string" minOccurs="0"/>
    </xs:sequence>
    <xs:attribute name="relationship" type="xs:NMTOKEN"/>
   </xs:extension>
  </xs:complexContent>
 </xs:complexType>
</xs:schema>

Processing Extended Complex Types

• Values of restricted types are not values of the base types
  • type extension adds content add/or attributes to a type
  • if content is added, it is always added at the end of the base type's content
• If there is a well-designed type hierarchy, programming becomes easier
  • simple code can be written to handle the basic types
  • if that should handle extended types, it must be written to handle extensions
  • handling extensions can be as simple as skipping them
• XML Schemas may even use abstract types
  • no element will ever use the addressType
  • concrete elements will only use restricted types
  • code handling extended types can build on code handling the base type

Schema Components

XML Schema Features

• XML Schema allows defining a grammar for XML documents
• Types make it easier to turn a model into a grammar
• Identity constraints enable non-grammar constraints to be expressed
• Some of the things we have not seen:
  • named groups, modularizing schemas, wildcards, substitution groups, ...