XTL: An XML Transformation Language and XSLT generator for XTL

Projection while preserving structure

The first is an example to project several tags of XML data while preserving structure. The input XML data is showed below as bib.xml (XML_QL examples).

<?xml version="1.0" ?> 
<bib> 
  <book year="1995"> 
     <!-- A good introductory text --> 
     <title>An Introduction to Database Systems</title> 
     <author><lastname>Date</lastname></author> 
     <publisher><name>Addison-Wesley</name></publisher> 
  </book> 
  <book year="1998"> 
     <title>Foundations for Object/Relational Databases</title> 
     <author><lastname>Date</lastname></author> 
     <author><lastname>Darwen</lastname></author> 
     <publisher><name>Addison-Wesley</name></publisher> 
  </book> 
  <book year="1999"> 
     <title>Data on the Web: from Relations to Semistructured Data & XML</title> 
     <author><firstname>Serge</firstname><lastname>Abiteboul</lastname></author> 
     <author><firstname>Peter</firstname><lastname>Buneman</lastname></author> 
     <author><firstname>Dan</firstname><lastname>Suciu</lastname></author> 
     <publisher><name>Morgan-Kaufman</name></publisher> 
  </book> 
  <article year="1999" type="inproceedings" month="June"> 
     <author><firstname>Mary</firstname><lastname>Fernandez</lastname></author> 
     <author><firstname>Alin</firstname><lastname>Deutsch</lastname></author> 
     <author><firstname>Dan</firstname><lastname>Suciu</lastname></author> 
     <title>Storing Semi-structured Data Using STORED</title> 
     <booktitle>ACM SIGMOD</booktitle> 
  </article> 
  <article year="1995" type="inproceedings" month="Jan"> 
     <author><firstname>Norman</firstname><lastname>Ramsey</lastname></author> 
     <author><firstname>Mary</firstname><lastname>Fernandez</lastname></author> 
     <title>The New Jersey Machine-Code Toolkit</title> 
     <booktitle>USENIX</booktitle> 
  </article> 
</bib>

Let's suppose a query (or transformation) to make bibliography that contains only books and eliminates all articles. The next XTL expresses this query.

<!ELEMENT bib AS {bib} (book*)> 
<!ELEMENT book (title, author+)> 
<!ATTLIST book year CDATA #REQUIRED> 
<!ELEMENT title  (#PCDATA)> 
<!ELEMENT author (firstname?, lastname)> 
<!ELEMENT firstname  (#PCDATA)> 
<!ELEMENT lastname (#PCDATA)>

This XTL expression specifies required elements/attributes, bib, book and all its sub-structures in DTD. Therefore, it produces a bibliography that includes only books. To make an implement of the XTL processor easy, XTL follows a rule that any element that can be a root tag must declared with XPath expression (AS {XPath expression}) in its element type declaration. The XPath expression specifies which part of input XML data is mapped to a tag in the output structure. In this example, the bib tag in the input data is mapped to the bib tag in the output structure. When an XPath expression is omitted for an element in content model or an attribute in attribute list declaration, XTL follows a rule that the specified output XML tag is used as default XPath expression. For example, <!ELEMENT bib AS {bib} (book*)> has the same meaning with <!ELEMENT bib AS {bib} (book* AS {book})>.

However, it is a burden for users to specify all sub-structures of book because they don't transform it at all. XTL query using ANY in DTD solves this issue.

ANY

This example with ANY produces the same query result with a result of the previous XTL expression.

<!ELEMENT bib AS {bib} (book*)> 
<!ELEMENT book ANY> 
<!ATTLIST book year CDATA #REQUIRED>

ANY plays the same role of specifying the all sub-structures (title, author, firstname, and lastname) of book in this XTL expression. Basically, ANY matches all sub-structures recursively if there is no other element type declaration that matches the sub-structures.

ANY is powerful to change a small part of an input XML data. Next example transforms author name by concatenating firstname and lastname and makes new author_name element while keeping the same with other part of input XML.

<!ELEMENT bib AS {bib} ANY> 
<!ELEMENT author AS {author} (author_name)> 
<!ELEMENT author_name (#PCDATA AS {concat(firstname, ' ', lastname)}>

In addition, this example contains a different use of AS clause. If AS clause is specified for #PCDATA or attribute data, it maps a value to an output node. If AS clause is specified for element, it maps an input node to an output node.

Selection

This example is to extract tags satisfying several conditions on elements or attributes. For example, let us make a bibliography that contains only books which is published after 1995 and whose title contains XML. The next XTL expresses this query.

<!ELEMENT bib AS {bib} (book*)> 
<!ELEMENT book (title AS {title[contains(.,'XML')]}, author+)> 
<!ATTLIST  book year AS {@year[.>1995]} CDATA #REQUIRED> 
<!ELEMENT title (#PCDATA)> 
<!ELEMENT author ANY>

XPath expression @year[.>1995] indicates that book's year should be larger than 1995, and the expression title[contains(.,'XML')] indicates that all book's title should contain a string XML. Therefore, this XTL expression extracts such book whose year is larger than 1995 and whose title contains XML.

Rename

Suppose an transformation example to capitalize all tag names.

<!ELEMENT Bib     AS {bib}  (book | article)*> 
<!ELEMENT Book    AS {book} (title, author+, publisher)> 
<!ATTLIST  Book 
             Year AS {year}    CDATA #REQUIRED> 
<!ELEMENT Article AS {article} 
                           (author+, title, booktitle?, 
                            (shortversion | longversion)?)> 
<!ATTLIST  Article 
             Type   AS {type}  CDATA #REQUIRED 
             Year   AS {year}  CDATA #REQUIRED 
             Month  AS {month} CDATA #IMPLIED> 
<!ELEMENT Publisher AS {publisher} (name, address?)> 
<!ELEMENT Name      AS {name}      (#PCDATA)> 
<!ELEMENT Title     AS {title}     (#PCDATA)> 
<!ELEMENT Author    AS {author}    (firstname?, lastname)> 
<!ELEMENT Firstname AS {firstname} (#PCDATA)> 
<!ELEMENT Lastname  AS {lastname}  (#PCDATA)> 
<!ELEMENT Booktitle AS {booktitle} (#PCDATA)>

The first line in this XTL expression indicates that bib tag should be transformed to Bib tag for example.

Changing structure

Next is a changing structure example is to build a list of authors.

<!ELEMENT bib AS {bib} (author* AS {//author} GROUP BY {.})> 
<!ELEMENT author ANY>

This example specifies a collection of author element as child elements of bib element and that is extracted using XPath expression //author. Moreover, the GROUP BY clause eliminates duplicated author elements. The exclusion key that is specified with GROUP BY is {.} and indicates author element itself. This elimination is based on deep equality of author structure.

Let us look at more complicated example that outputs a list of author that contains a list of book title for each author. This example transforms the input structure between title and author upside down.

<!ELEMENT bib AS {bib} (author* AS {//author} GROUP BY {.})> 
<!ELEMENT author (firstname?, lastname, title* AS {//title[../author=$author]}> 
<!ELEMENT title (#PCDATA)> 
<!ATTLIST  title year AS {../@year} CDATA #REQUIRED> 
<!ELEMENT firstname (#PCDATA)> 
<!ELEMENT lastname  (#PCDATA)>

As the same with the previous example, this XTL specifies a collection of author as child elements of bib tag. In addition, it also specifies a collection of title tag as child elements of author tag to make a title list for each author. The XPath expression //title[../author=$author] collects title elements from input XML data whose parent tag has a author element and that is the same with the current author (specified by $author).

Sort

Sort is an operation to reorder a collection of element in ascending or descending order using specified key tag value. Let us look at a simple example that collects an author list and sort it by its name in alphabetical order.

<!ELEMENT bib AS {bib} (author* IN {//author} GROUP BY {.} ORDER BY {.})> 
<!ELEMENT author ANY>

In addition to collect an author list that is the same operation with the first example of changing structure, this example adds an ORDER BY clause to sort the author list. When users omit an ascending or descending clause, ascending is chosen as a default action. The next example describes a descending order example.

<!ELEMENT bib AS {bib} 
      (author* IN {//author} GROUP BY {.} ORDER BY {.} DESC)> 
<!ELEMENT author ANY>

Let us look at an example that has two sort operations in different part. The next example sorts both the author list and its title list.

<!ELEMENT bib AS {bib} 
           (author* IN {//author} GROUP BY {.} ORDER BY {lastname})> 
<!ELEMENT author AS {.} (firstname?, lastname, title* ORDER BY {.})> 
<!ELEMENT title  AS {//title [../author=$author]} (#PCDATA)> 
<!ATTLIST  title year AS {../@year} CDATA #REQUIRED> 
<!ELEMENT firstname (#PCDATA)> 
<!ELEMENT lastname  (#PCDATA)>

The first ORDER BY clause indicates that the author list should be sorted using lastname as key value. The second ORDER BY clause indicates the title list for each author should be sorted using title itself (expressed by .) as key value.

Join

Join operation is a core operation in relational model because relation is a unit and all information is divided into a collection of relations. On the other hand, join operation in XTL is just to combine several XML data into one XML data. Let us look into a join operation example to combine two XML data. One of input XML data is book catalog (BookCatalogue.xml) that does not contain book price data and the other is bookstore list (BookCosts.xml) including book price for each bookstore.

<?xml version="1.0"?> 
<BookCatalogue> 
  <Book> 
    <Title>My Life and Times</Title> 
    <Author>Paul McCartney</Author> 
    <Date>July, 1998</Date> 
    <ISBN>94303-12021-43892</ISBN> 
    <Publisher>McMillin Publishing</Publisher> 
  </Book> 
  <Book> 
    <Title>Illusions The Adventures of a Reluctant Messiah</Title> 
    <Author>Richard Bach</Author> 
    <Date>1977</Date> 
    <ISBN>0-440-34319-4</ISBN> 
    <Publisher>Dell Publishing Co.</Publisher> 
  </Book> 
  <Book> 
    <Title>The First and Last Freedom</Title> 
    <Author>J. Krishnamurti</Author> 
    <Date>1954</Date> 
    <ISBN>0-06-064831-7</ISBN> 
    <Publisher>Harper & Row</Publisher> 
  </Book> 
</BookCatalogue>

<?xml version="1.0"?> 
<BookCosts> 
  <Book> 
    <Title>My Life and Times</Title> 
    <Cost store="Walden Books">$12.95</Cost> 
    <Cost store="Barnes & Noble">$10.95</Cost> 
  </Book> 
  <Book> 
    <Title>Illusions The Adventures of a Reluctant Messiah</Title> 
    <Cost store="Walden Books">$5.95</Cost> 
    <Cost store="Barnes & Noble">$6.95</Cost> 
  </Book> 
  <Book> 
    <Title>The First and Last Freedom</Title> 
    <Cost store="Walden Books">$9.95</Cost> 
    <Cost store="Barnes & Noble">$8.95</Cost> 
  </Book> 
</BookCosts>

The below XTL expression produces an XML data that combines the above two XML data.

<!ELEMENT Bib AS {BookCatalogue} (Book*)> 
<!ELEMENT Book   (Title, Author+, Date, ISBN, Publisher, Cost*)> 
<!ELEMENT Title  (#PCDATA)> 
<!ELEMENT Author (#PCDATA)> 
<!ELEMENT Date   (#PCDATA)> 
<!ELEMENT ISBN   (#PCDATA)> 
<!ELEMENT Publisher (#PCDATA)> 
<!ELEMENT Cost AS {document('BookCosts.xml')/BookCosts/Book[Title=$Title]/Cost} (#PCDATA)> 
<!ATTLIST  Cost store CDATA #REQUIRED>

The important part of this example is that an XPath expression for Cost tag specified in second last row. The docment function, which is defined in XSLT specification, is applied to extract some part of other XML data (BookCosts.xml) and combines it to the base BookCatalogue.xml. The XPath expression, BookCosts/Book/Cost, following after the document function specifies an extraction target tag that should be mapped to Cost tag. The [../Title=$Title] specifies a selection condition for Book tag meaning that a Title tag under the Book tag should be the same with $Title. $Title is a sibling tag of current Cost tag and is defined at third line of this XTL example.

Output structure is specified with DTD

The DTD in XTL specifies an output structure of transformation. Therefore, it is easy for users to understand and specify the transformation result.

Embedded XPath clause into DTD

XPath clause is embedded into DTD syntax for each element or attribute. This clause indicates a mapping rule from input XML to output XML and there are two types of mapping rule: 1) node map and 2) value map.

1. node map: This maps an input node (element or attribute) to an output node. In addition, this defines a current context of XPath for child nodes. Basically, XPath is relative expression to either its parent tag's XPath or its outer parenthesis's XPath. For example, <!ELEMENT result AS {bib} (bo* AS {book})> means that the result element is mapped from bib and set a current context of XPath to bib. So the next XPath book corresponds to bib/book. The other example <!ELEMENT result AS {bib} (bo AS {.})* AS {book})> has the same meaning with the previous XTL in different expression. The output element bo's XPath corresponds to bib/book/. in this case.
2. value map: This maps a value to an output text node (expressed using PCDATA for element or any attribute). For example, <!ELEMENT count (#PCDATA AS {count(author)})> means that the count element value is set with a result of count(author).

It is possible to omit the XPath clause for element or attribute. Default rule of this is that the same tag with output XML tag is used as XPath expression for node map and text() is used as XPath expression for value map. For example, <!ELEMENT bib AS {bib} (book*)> has the same meaning with <!ELEMENT bib AS {bib} (book* AS {book})> and <!ELEMENT book (#PCDATA)> has the same meaning with <!ELEMENT book (#PCDATA AS {text()})>.

DTD Extension

To increase a flexibility of specifying output structure, DTD syntax is extended as follows.

1. Mixed content model extension enables to handle #PCDATA and element in same way. Therefore, XTL can express like, <!ELEMENT paper (#PCDATA, title)> and <!ELEMENT paper (title | #PCDATA)>.
2. ORDER BY clause sorts a collection of specific element using specified key node. For example, <!ELEMENT bib AS {bib} (author* IN {//author} ORDER BY {.})> means that a collection of author should be sorted using deep equality of itself.
3. GROUP BY eliminates duplicated elements using specified key node. For example, <!ELEMENT bib AS {bib} (author* IN {//author} GROUP BY {.})> means that a collection of author should not contain a same author using deep equality of itself.
4. Tag variable enables to map any input tag to keep the same tag name. For example, <!ELEMENT bib AS {bib} ($a AS {paper|article})> means that $a is a tag variable and the input tag name (paper or article) is mapped to the result tag name.

Cardinality Constraint

In DTD, it is possible to specify an element cardinality (*, +, ?, none) in a content model. DTD in XTL specifies an output structure of transformation. XTL defines that the cardinality of element is a constraint for its mapping rule. For example, <!ELEMENT bib AS {bib} (book* AS {book})> indicates that XPath book should return a collection of book that count is more than zero. <!ELEMENT bib AS {bib} (book+ AS {book})> indicates that XPath book should return a collection of book that count is more than one.

XTL also has to define a meaning of ANY and EMPTY in XTL. ANY means that the element can have any content model (structure) without any constraint. EMPTY means that the element should be empty element. For example, <!ELEMENT author AS {author} ANY> indicates that output author can be any content model and all sub-elements of input author is mapped to the transformation result. On the other hand <!ELEMENT author AS {author} EMPTY> indicates that the input author should be empty element.

Variable binding

A variable is automatically set for each element and attribute. Any embedded XPath can refer those variables as long as the referee node assigned to variable is reachable from a referrer via many-to-one or one-to-one association in DTD graph. For example, <!ELEMENT b AS {bib} (a * {$bib/author})> indicates that $b refers input bib element. If XTL has a recursive element definition, then a closest parent is referenced from its children.

Translation from XTL to XSLT

This section briefly describes how the XTL processor translates XTL expression to XSLT expression. The details will come in following section.

First of all, let us remind the XSLT expression. XSLT expression is composed of several template declarations. XSLT processor inputs an XML and checks whether there are some templates that match an input element, attribute, or text. If some template matches, then it is applied and executed. If there are no matching templates, then default action is applied and output the input text.

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

Details of translation

I have described how the XTL processor generates each template declaration without inside details of the template declaration. Let us look into its inside using an example. The example XTL is:

<!ELEMENT bib AS {bib} (author* AS {//author} GROUP BY {.})> 
<!ELEMENT author (firstname?, lastname, 
                  title* AS {//title[../author=$author]} ORDER BY {.})> 
<!ELEMENT title (#PCDATA)> 
<!ATTLIST  title year AS {../@year} CDATA #REQUIRED> 
<!ELEMENT firstname ANY> 
<!ELEMENT lastname  EMPTY>

and the generated XSLT result is:

<?xml version="1.0" encoding="euc-jp"?>
<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0">
<xsl:output method="xml" indent="yes" encoding="euc-jp" omit-xml-declaration="no"/>
<xsl:strip-space elements="*"/>
 
<!-- This is for bib element -->
<xsl:template match="bib">
  <xsl:variable name="bib" select="."/>
  <xsl:element name="bib">
    <xsl:apply-templates select="(//author)" mode="author_.">
      <xsl:with-param name="nodes" select="//author"/>
      <xsl:with-param name="bib" select="$bib"/>
    </xsl:apply-templates>
  </xsl:element>
</xsl:template>
 
<!-- This is for bib element UNDER ANY -->
<xsl:template match="bib" mode="any">
  <xsl:variable name="bib" select="."/>
  <xsl:element name="bib">
    <xsl:apply-templates select="(//author)" mode="author_.">
      <xsl:with-param name="nodes" select="//author"/>
      <xsl:with-param name="bib" select="$bib"/>
    </xsl:apply-templates>
  </xsl:element>
</xsl:template>
 
<!-- This is for author element -->
<xsl:template match="*|@*|text()" mode="author">
  <xsl:variable name="author" select="."/>
  <xsl:param name="bib"/>
  <xsl:if test="count(lastname)>=1">
    <xsl:if test="lastname=''">
      <xsl:element name="author">
        <xsl:apply-templates select="(firstname)[1]" mode="firstname">
          <xsl:with-param name="author" select="$author"/>
          <xsl:with-param name="bib" select="$bib"/>
        </xsl:apply-templates>
        <xsl:apply-templates select="(lastname)[1]" mode="lastname">
          <xsl:with-param name="author" select="$author"/>
          <xsl:with-param name="bib" select="$bib"/>
        </xsl:apply-templates>
        <xsl:apply-templates select="(//title[../author=$author])" mode="title">
          <xsl:with-param name="author" select="$author"/>
          <xsl:with-param name="bib" select="$bib"/>
          <xsl:sort select="." order="ascending"/>
        </xsl:apply-templates>
      </xsl:element>
    </xsl:if>
  </xsl:if>
</xsl:template>
 
<!-- This is for firstname element -->
<xsl:template match="*|@*|text()" mode="firstname">
  <xsl:variable name="firstname" select="."/>
  <xsl:param name="author"/>
  <xsl:param name="bib"/>
  <xsl:element name="firstname">
    <xsl:apply-templates select="child::node()" mode="any"/>
  </xsl:element>
</xsl:template>
 
<!-- This is for lastname element -->
<xsl:template match="*|@*|text()" mode="lastname">
  <xsl:variable name="lastname" select="."/>
  <xsl:param name="author"/>
  <xsl:param name="bib"/>
  <xsl:if test=".=''">
    <xsl:element name="lastname">
    </xsl:element>
  </xsl:if>
</xsl:template>
 
<!-- This is for title element -->
<xsl:template match="*|@*|text()" mode="title">
  <xsl:variable name="title" select="."/>
  <xsl:param name="author"/>
  <xsl:param name="bib"/>
  <xsl:if test="count(../@year)>=1">
    <xsl:element name="title">
      <xsl:variable name="year" select="../@year"/>
      <xsl:if test="count($year)>=1">
        <xsl:attribute name="year">
          <xsl:value-of select="$year"/>
        </xsl:attribute>
      </xsl:if>
      <xsl:value-of select="."/>
    </xsl:element>
  </xsl:if>
</xsl:template>
 
<!-- This is for GROUP author element BY . -->
<xsl:template match="*|@*|text()" mode="author_.">
  <xsl:param name="nodes"/>
  <xsl:param name="bib"/>
  <xsl:variable name="pos" select="position()"/>
  <xsl:if test="count($nodes[$pos>position() and .=current()/.])=0">
    <xsl:apply-templates select="." mode="author">
      <xsl:with-param name="bib" select="$bib"/>
    </xsl:apply-templates>
  </xsl:if>
</xsl:template>
 
<xsl:template match="text()"></xsl:template>
 
<xsl:template match="*|@*|text()" mode="any">
  <xsl:copy>
    <xsl:apply-templates select="*|@*|text()" mode="any"/>
  </xsl:copy>
</xsl:template>
 
</xsl:stylesheet>

First, there are three types of content model in element type declaration: ANY, EMPTY, and element content. There are mixed content in original DTD, but there is no mixed content in DTD of XTL because DTD of XTL is extended to handle #PCDATA and element in the same way (meaning that mixed content is combined with element content).

<xsl:template match="*|@*|text()" mode="firstname">
  <xsl:variable name="firstname" select="."/>
  <xsl:param name="author"/>
  <xsl:param name="bib"/>
  <xsl:element name="firstname">
    <xsl:apply-templates select="child::node()" mode="any"/>
  </xsl:element>
</xsl:template>

<xsl:template match="*|@*|text()" mode="lastname">
  <xsl:variable name="lastname" select="."/>
  <xsl:param name="author"/>
  <xsl:param name="bib"/>
  <xsl:if test=".=''">
    <xsl:element name="lastname">
    </xsl:element>
  </xsl:if>
</xsl:template>

<xsl:template match="*|@*|text()" mode="title">
  <xsl:variable name="title" select="."/>
  <xsl:param name="author"/>
  <xsl:param name="bib"/>
  <xsl:if test="count(../@year)>=1">
    <xsl:element name="title">
      <xsl:variable name="year" select="../@year"/>
      <xsl:if test="count($year)>=1">
        <xsl:attribute name="year">
          <xsl:value-of select="$year"/>
        </xsl:attribute>
      </xsl:if>
      <xsl:value-of select="."/>
    </xsl:element>
  </xsl:if>
</xsl:template>

<xsl:when test="C">
  <xsl:for-each select="C">
    <xsl:apply-templates select="(C1)[1]" mode="C1">
      <xsl:with-param name="author" select="$author"/>
      <xsl:with-param name="bib" select="$bib"/>
    </xsl:apply-templates>
    <xsl:apply-templates select="(C2)[1]" mode="C2">
      <xsl:with-param name="author" select="$author"/>
      <xsl:with-param name="bib" select="$bib"/>
    </xsl:apply-templates>
  </xsl:for-each>
</xsl:when>

<xsl:template match="*|@*|text()" mode="author_.">
  <xsl:param name="nodes"/>
  <xsl:param name="bib"/>
  <xsl:variable name="pos" select="position()"/>
  <xsl:if test="count($nodes[$pos>position() and .=current()/.])=0">
    <xsl:apply-templates select="." mode="author">
      <xsl:with-param name="bib" select="$bib"/>
    </xsl:apply-templates>
  </xsl:if>
</xsl:template>

<!ELEMENT author (firstname?, lastname, title* AS {//title[../author=$author]} ORDER BY {.})> 

<xsl:apply-templates select="(//title[../author=$author])" mode="title">
  <xsl:with-param name="author" select="$author"/>
  <xsl:with-param name="bib" select="$bib"/>
  <xsl:sort select="." order="ascending"/>
</xsl:apply-templates>

<xsl:variable name="year" select="../@year"/>
<xsl:if test="count($year)>=1">
  <xsl:attribute name="year">
    <xsl:value-of select="$year"/>
  </xsl:attribute>
</xsl:if>
<xsl:value-of select="."/>

Limitations

There are several limitations in this translation algorithm from XTL expresion to XSLT exprssion.

Query feature

Even though both XTL and Quilt query feature are based on XPath, XTL Querying feature is inferior to that of Quilt. Because Quilt has more additional functionality like FOR, WHERE clause and AFTER, BEFORE operators. They are good supplement of XPath function.

1. FOR clause: It declares any variables and that sometimes simplifies XPath expression by referring those declared variables.
2. WHERE clause: It simplifies XPath expression and sometimes is more powerful than XPath expression especially when an XPath selection condition gets deeply nested.
3. AFTER, BEFORE: It simplifies XPath expression and sometimes is more powerful than XPath expression in specifying some order of nodes.

Basically XPath issues may motivate these functions. I hope XPath 2.0 will improve some existing issues of XPath1.0.

Define output structure feature

XTL defining output structure feature is superior to that of Quilt because XTL can define an output structure based on grammar (extended DTD). Quilt's output structure is base on XML instance so it gets rather complex to specify choice (| in DTD) and some recursive structure. In addition, ANY in XTL is powerful to transform a small part of an input XML data, because users have to specify only a part where a transformation is needed (In Quilt, users have to specify s whole structure from root node including a part where a transformation is not needed).

XTL expressions written in Quilt

I will describe examples of 2. Examples of XTL expressions written in Quilt. These examples are for the purpose of clarify the difference of XTL and Quilt.

Projection while preserving structure

<bib>
  (
  FOR     $a IN document("bib.xml")/bib/book
  RETURN  <book>$a</book>
  )
</bib>

<bib>
  (
  FOR       $a IN document("bib.xml")/bib
    (
    FOR     $b IN $a/book | $a/article
    RETURN
       <book Year=$b/year/text()>
         <title>$b/title/text()</title>
           (
           FOR $c IN $b/author
           RETURN
             <author>
               <author_name>concat($c/firstname/text(), ' ',$c/lastname/text())</author_name>
             </author>
           )
         <publisher>$b/publisher/text()</publisher>
       </book>
    )
  )
</bib>

Selection

<bib>
  (
  FOR      $a IN document("bib.xml")/bib/book
  WHERE    contains($a/title, "XML") AND $a/@year >1995
  RETURN
    <book>$a</book>
  )
</bib>

Rename

<Bib>
  (
  FOR       $a IN document("bib.xml")/bib
    (
    FOR     $b IN $a/book | $a/article
    RETURN
      <Book Year=$b/year/text()>
         <Title>$b/title/text()</Title>
            (
            FOR $c IN $b/author
            RETURN
             <Author>
               <Firstname>$c/firstname/text()</Firstname>,
               <Lastname>$c/lastname/text()</Lastname>
             </Author>
            )
          <Publisher><name>$b/publisher/name/text()</name></Publisher>
      </Book>
    )
  )
</Bib>

Changing Structure

<bib>
  (
  FOR       $a IN DISTINCT document("bib.xml")//author
  RETURN    $a
  )
</bib>

<bib>
  (
  FOR            $a IN DISTINCT document("bib.xml")//author
  RETURN
    <author>
      <firstname>$a/firstname</firstname>,
      <lastname>$a/lastname</lastname>,
        (
        FOR      $b IN document("bib.xml")//title[../author=$a]
        RETURN   $b/title
        )
    </author>
  )
</bib>

Sort

<bib>
  (
  FOR       $a IN DISTINCT document("bib.xml")//author
  RETURN    $a SORTBY(.)
  )
</bib>

Selection

<bib>
  (
  FOR       $a IN DISTINCT document("bib.xml")//author
  RETURN    $a SORTBY(.) DESCENDING
  )
</bib>

<bib>
  (
  FOR         $a IN DISTINCT document("bib.xml")//author
  RETURN      $a SORTBY(.)          
 // I am not sure this SORTBY posistion is correct
      (
      FOR     $b IN document("bib.xml")//title[../author=$a]
      RETURN  $b/title SORTBY(title)
      )
  )
</bib>

Join

<bib>
  (
  FOR         $a IN document("BookCatalogue.xml")/Book
  RETURN    
      <book>
         $a/Title
         (
            FOR    $c IN $a/Auhtor
            RETURN $c
         )
         $a/Date
         $a/ISBN
         $a/Publisher
         (
            FOR    $b IN document("BookCosts.xml")/BookCosts/Book[Title=$a/Title]/Cost
            RETURN $b
         )
      </book>
  )
</bib>