Outline

• XML Schemas
• XSLT
• Quiz
• XPath

Introduction

• Last week, we introduced XML as a semi-structured data model -- a data model that represents data using trees or directly acyclic graphs whose structure may vary between documents rather than using relations whose rows use the same structures.
• We gave a brief history of how XML arose as an attempt to make it easy to specify new tag based languages for the web beyond HTML.
• We said there were several different ways a new XML language could be specified and on Wednesday gave one of these, using a DTD.
• Today, we begin by looking at a second way to specify new XML languages, using XML Schemas.

XML Schemas

• DTDs are defined in a language which is different from XML.
• We also cannot finely control what kinds of character data can appear within tags.
• The XML schema language was created to address both these issues.

More on Schemas

• The namespace for XML Schema is

  http://www.w3.org/2001/XMLSchema
  

• xsd is a common namespace to use when dealing with XML schema tags.
• A XML schema is used to define a target namespace of the language we are defining.
• A defining schema can be used to allow or restrict other schemas from being used with the target namespace.
• At its simplest, a schema document consists of a bunch of tags such as <element> <simpleType>, <complexType>, <sequence>, <all>,<restriction>, and enclosed with a <schema> tag.

Overview of data types

• There are two categories of data types in XML Schemas:
  • simple types -- which are restricted to strings and cannot have attributes or nested elements
  • complex types -- which can have attributes and can include other data types as elements.
• There are 44 different types in XML schemas, 19 of which are primitive and the remainder are derived.
• Example primitive types include: string, Boolean, time and anyURI.
• Example predefined derived types include: byte, long, decimal, unsignedInt, positiveInteger, and NMTOKEN.
• User defined types are defined by specifying restrictions on an existing type (called a base type). For example, for integer there are eight so-called "facets" on which restrictions to base types can be made: totalDigits, maxInclusive, maxExclusive, minInclusive, minExclusive, pattern, enumeration, and whitespace.
• Types can be named or anonymous. Anonymous types cannot be used outside of the element in which it was declared
• Elements in DTDs are all global. For schemas one can have local elements. These are elements which defined within the scope of some child of the schema tag. child elements themselves are global.

Simple Types

• In an instance of the plane schema we could then have:

  <engine>an example of the content of an engine</engine>
  

• You can also give default values or force fixed values with slight variations of this declaration:

  <xsd:element name="engine" type="xsd:string" default="V-6" />
  <xsd:element name="plane" type="xsd:string" fixed="single wing" />
  

• A simple user-derived type can be defined using the <restriction> tag:

  <xsd:simpleType name="firstName">
  	<xsd:restriction base="xsd:string">
           <xsd:maxLength value="10" />
       </xsd:restriction>
  </xsd:simpleType>
  

Complex Types

• There are several kinds of complex types that can be used with XML schemas.
• We will only look at the complex types which are restricted to having subelement-only -- not both subelements and text. The complexContent tag can be used to handle other kinds of content.
• To define what subelement occur for an element we can use either sequence or all. sequence -- forces an order on the subelement, all doesn't.

  <xsd:complexType name="car">
  	<xsd:sequence>
            <xsd:element name="make"  type="xsd:string" />
            <xsd:element name="year" type="xsd:decimal" />
       </xsd:sequence>
  <!-- you can use minOccurs, maxOccurs to specify number of occurrences ;
  you can have more than one sequence, all tag here-->
  </xsd:complexType>
  

References

• You can define element to be used as a subelement outside of another element and use a reference to refer to it:

  <xsd:element name="year">
  <xsd:simpleType >
       <xsd:restriction base="xsd:decimal">
           <xsd:minInclusive value="1903" />
           <xsd:maxInclusive value="2020" />
       </xsd:restriction>
  </xsd:simpleType>
        </xsd:element>
  <xsd:complexType name="car">
  	<xsd:sequence>
               <xsd:element name="make"  type="xsd:string" />
                <xsd:element ref="year" />
           </xsd:sequence>
  </xsd:complexType>
  <xsd:element name="sport_car" type="car">
   <xsd:attribute name="color" type="xsd:string" />
  </xsd:element>
  

Indicating the Schema Used By an XML document

• Here is an example of how to say an XML patient document makes use tags defined in a patient schema:

  <?xml version="1.0" ?>
  <patient xmlns="http://somewhere.com"
                   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
                   schemaLocation="http://somewhere.com  patient.xsd" >
  
  <!-- other tags for this particular patient record -->
  
  </patient> 
  

XSLT

• Sometimes it is useful to transform one XML markup language into some other XML language.
• For instance, suppose you want to display a pure RSS feed nicely and you want the links to work in IE. Since IE does not support the XLink language this is hard unless you do a stylesheet tranformation.
• The basic idea of XSLT (eXtensible stylesheet transformations), is that we can associate a stylesheet transformation with an XML document and apply this transformation using a processor (for instance, a browser), to get some other XML language.

XSLT Example -- Initial XML Document

<?xml version="1.0" encoding="utf-8" ?>
<?xml-stylesheet type="text/xsl" href="xslplane.xsl" ?>
<plane>
    <year>1970</year>
</plane>

XSLT Example -- The Transformation

<?xml version="1.0" encoding="utf-8" ?>
<xsl:stylesheet version="1.0"
    xmlns:xsl= "http://www.w3.org/1999/XSL/Transform"
   xmlns = "http://www.w3.org/1999/xhtml"
>
<xsl:template match="plane">
<html><head>
<title>result of applying a stylesheet to plane</title>
</head><body><h1>Plane Description</h1>
     <xsl:apply-templates />
     </body></html>
 </xsl:template>
<xsl:template match="year">
    <p style="color:red">
    <xsl:value-of select="." />
    </p>
</xsl:template>
</xsl:stylesheet>

Quiz

Which of the following is true?

1. A semi-structured data model uses relations as it data structures, and uses relational algebra to specify its operations and constraints.
2. An external DTD in XML could be specified with a line like:

   <!DOCTYPE name_of_xml_language SYSTEM "name_of_dtd_with_language_def.dtd" >
   

3. An <!ATTLIST tag can be used to specify at most one attribute of at most one tag element of an XML language.

XPath

• XPath is a language used to refer to parts of an XML document.
• The values of the match attributes we saw for XSLT can make use of XPath expressions.
• In what follow I will try to give a flavor of XPath without completely spelling out its syntax.

XPath Expressions

• Generally, an XPath expression starts from a context node then navigates down the document tree to the collection of nodes that are desired.
• For example,

  doc("winecellar.xml")/winecellar/wine

  matches all wine nodes (and their contents) in the winecellar.xml file which start from the whole document, then immediately go through a winecellar sub-tag then have a wine tag.
• We can use the expression // to skip multiple levels in the tree. So winecellar//wine would match any wine element that was a descendant of a winecellar element.
• We can use wild-cards like /*/ to match a single tag name without specifying what it is.
• If we are interested in the 2nd wine element children of a particular winecellar, we could use the syntax:

  doc("winecellar.xml")/winecellar/wine[2]
  

• We can place requirements on the values of attributes of a element by using [...] notation. For example:

  doc("winecellar.xml")/winecellar/wine[price > 20]/name
  

  returns the names of all wine nodes with price attribute greater than 20.
• Finally, if you want the value of an attribute to be returned rather than the contents of a node, you can use @. For example, //img/@src to get all the url's from img tags in an HTML document.