1.9.4
Queries
1.9.4.1
Q1
Count the invoices shipped to the United
Kingdom.
Solution in XQuery:
import schema namespace ipo = "http://www.example.com/IPO"
count(
doc("ipo.xml")//shipTo[. instance of element(*, ipo:UKAddress)]
)
In this dataset, the data for an address does not
contain the name of the country, and the name of the
shipTo element is the same regardless of the country
to which items are shipped. Only the types allow us
to identify UK addresses - in the schema, there is
one address type for UK addresses and another for US
addresses, both derived from a common base class. In
the above query, we use the UKAddress type to
identify invoices shipped to the UK.
1.9.4.2
Q2
Write a function that tests an American address to
check if it has the right zip code.
In our solution, we will assume zip code data is
stored in a file called "zips.xml", which looks like
this.
<zips xmlns="http://www.example.com/zips">
<row>
<city>Old Town</city>
<state>PA</state>
<zip>95819</zip>
</row>
<row>
<city>Durham</city>
<state>NC</state>
<zip>27701</zip>
</row>
<row>
<city>Durham</city>
<state>NC</state>
<zip>27703</zip>
</row>
</zips>
Solution in XQuery:
module "http://www.example.com/xq/zips"
import schema namespace ipo = "http://www.example.com/IPO"
import schema namespace zips = "http://www.example.com/zips"
define function zip-ok($a as element(*, ipo:USAddress))
as xs:boolean
{
some $i in doc("zips.xml")/zips:zips/element(zips:row)
satisfies $i/zips:city = $a/city
and $i/zips:state = $a/state
and $i/zips:zip = $a/zip
}
An attempt to call this function with an element
of the wrong address type raises an error. For
instance, you can not call zip-ok() with an element
of type UKAddress.
Note that the parameter for this function
specifies the type rather than the element name,
since it is written to be used with any element that
has the proper address type - for instance, in our
sample schema, 'billTo' and 'shipTo' are two
different elements which may both have the USAddress
type.
1.9.4.3
Q3
Write a function that tests a UK address to see if
it has the right postal code.
For England, we store the information needed to
test postal codes in a file called "postals.xml",
which looks like this:
<postals xmlns="http://www.example.com/postals">
<row>
<city>Cambridge</city>
<prefix>CB</prefix>
</row>
<row>
<city>Oxford</city>
<prefix>OX</prefix>
</row>
</postals>
Solution in XQuery:
module "http://www.example.com/xq/postals"
import schema namespace ipo = "http://www.example.com/IPO"
import schema namespace pst = "http://www.example.com/postals"
define function postal-ok($a as element(*, ipo:UKAddress))
as xs:boolean
{
some $i in doc("postals.xml")/pst:postals/element(pst:row)
satisfies $i/pst:city = $a/city
and xf:starts-with($a/postcode, $i/pst:prefix)
}
1.9.4.4
Q4
Return purchase orders with an erroneous postal
code or zip code (depending on whether it is a UK
Address or a US Address).
Solution in XQuery:
import schema namespace ipo="http://www.example.com/IPO"
import schema namespace pst="http://www.example.com/postals"
import schema namespace zips="http://www.example.com/zips"
import module namespace zok="http://www.example.com/xq/zips"
import module namespace pok="http://www.example.com/xq/postals"
define function address-ok($a as element(*, ipo:Address))
as xs:boolean
{
typeswitch ($a)
case $zip as element(*, ipo:USAddress)
return zok:zip-ok($zip)
case $postal as element(*, ipo:UKAddress )
return pok:postal-ok($postal)
default return false()
}
for $p in doc("ipo.xml")//element(ipo:purchaseOrder)
where not( address-ok($p/shipTo) and address-ok($p/billTo))
return $p
This query calls the functions defined in Q2 and
Q3.
Note that the function address-ok() accepts any
element whose type is ipo:Address, which is the base
type for both ipo:UKAddress and ipo:USAddress. Note
also that this function uses a typeswitch to select
the appropriate function to test American or British
addresses. This can be considered a primitive form of
polymorphism.
1.9.4.5
Q5
Write a query that returns purchase orders where
the name in the shipping address does not match the
name in the billing address.
Solution in XQuery:
import schema namespace ipo="http://www.example.com/IPO"
define function names-match( $s as element(ipo:purchaseOrder/shipTo),
$b as element(ipo:purchaseOrder/billTo) )
as xs:boolean
{
$s/name = $b/name
}
for $p in doc("ipo.xml")//element(ipo:purchaseOrder)
where not( names-match( $p/shipTo, $p/billTo ) )
return $p
In this function, note that the function uses the
element names rather than the type names to specify
the parameters. The query should return an error if
the function is called with two ipo:billTo elements
by mistake, but it is not a mistake to have the
shipping address and billing address have different
types.
Note also that the schema says both of these
elements are local elements, defined only within a
purchase order. Since these elements are not globally
defined, the parameters specify a schema context in
which the name is defined. (In XML, local names
prevent name clash, but they do not invoke any form
of data hiding).
1.9.4.6
Q6
Find purchase orders where the billing address is
not a USAddress, but at least one price is a
USPrice.
Solution in XQuery:
import schema namespace ipo="http://www.example.com/IPO"
for $p in doc("ipo.xml")//element(ipo:purchaseOrder),
$b in $p/billTo
where not( $b instance of element(*, ipo:USAddress))
and exists( $p//USPrice )
return $p
Addresses are part of a type hierarchy, and the
element name, ipo:shipTo, does not tell us whether an
address is a US price or not, so we have to test the
type.
This example is rather contrived, since the schema
specifies that all prices are USPrice elements.
Nevertheless, it illustrates the ability to easily
combine information derived from type information
with information derived from structure.
1.9.4.7
Q7
Write a function that returns the text of a
comment. Call this function for each shipping comment
found in an item shipped to Helen Zoe on the date
1999-12-01.
The example in the XML Schema Primer uses the
following example for substitution groups:
<element name="comment" type="string"/>
. . .
<element name="shipComment" type="string"
substitutionGroup="ipo:comment"/>
<element name="customerComment" type="string"
substitutionGroup="ipo:comment"/>
The example in the XML Schema Primer provides the
following sample data to illustrate these
substitution groups:
<items>
<item partNum="833-AA">
<productName>Lapis necklace</productName>
<quantity>1</quantity>
<USPrice>99.95</USPrice>
<ipo:shipComment>
Use gold wrap if possible
</ipo:shipComment>
<ipo:customerComment>
Want this for the holidays!
</ipo:customerComment>
<shipDate>1999-12-05</shipDate>
</item>
</items>
Solution in XQuery:
import schema namespace ipo="http://www.example.com/IPO"
define function comment-text($c as element(ipo:comment))
as xs:string
{
xs:string( $c )
}
for $p in doc("ipo.xml")//element(ipo:purchaseOrder),
$t in comment-text( $p//ipo:shipComment )
where $p/shipTo/name="Helen Zoe"
and $p/orderDate = xs:date("1999-12-01")
return $t
In this query, the function specifies ipo:comment
as the name of the element, but any element in the
substitution group of ipo:comment may also be passed
to this function. That means that we can call the
same function for ipo:shipComment elements or
ipo:customerComment elements - for instance, the
following query also succeeds:
for $p in doc("ipo.xml")//element(ipo:purchaseOrder)
where $p/shipTo/name="Helen Zoe"
and $p/@orderDate = xs:date("1999-12-01")
return comment-text( $p//ipo:customerComment )
1.9.4.8
Q8
Find all comments found in an item shipped to
Helen Zoe on the date 1999-12-01, including all
elements in the substitution group for
ipo:comment.
Solution in XQuery:
import schema namespace ipo="http://www.example.com/IPO"
for $p in doc("ipo.xml")//element(ipo:purchaseOrder)
where $p/shipTo/name="Helen Zoe"
and $p/@orderDate = xs:date("1999-12-01")
return $p//element(ipo:comment)
Note that element(ipo:comment)
matches any valid element in the substitution group
of ipo:comment.
1.9.4.9
Q9
Write a function that returns all comments found
on an element, whether an item element or some other
element that may have a comment.
Solution in XQuery:
import schema namespace ipo="http://www.example.com/IPO"
define function comments-for-element( $e as element() )
as ipo:comment*
{
let $c := $e/element(ipo:comment)
return $c
}
In this schema, comments can occur on either a
purchase order or on an item. In a more complete
schema, they could presumably occur in other areas as
well. This function returns all comments found on an
element, regardless of the name of the element,
illustrating the need to write functions that can
accept any element as a parameter.
1.9.4.10
Q10
Write a function that determines whether the
person listed in a billTo element is known to be a
deadbeat, using a US database.
This query assumes that
"http://www.usa-deadbeats.com" maintains a database
of deadbeats.
Solution in XQuery:
import schema namespace ipo="http://www.example.com/IPO"
define function deadbeat( $b as element(billTo, ipo:USAddress) )
as xs:boolean
{
$b/name = doc("http://www.usa-deadbeats.com/current")/deadbeats/row/name
}
Note that this function specifies both the element
name and the type. The element name is specified
because we do not want to embarrass recipients of
gifts by calling this function for the shipping
address by mistake. The type is specified because we
would need to use a different database to identify
deadbeats in other countries.
1.9.4.11
Q11
Write a function that computes the total price for
a sequence of item elements.
Solution in XQuery:
module "http://www.example.com/calc"
import schema namespace ipo="http://www.example.com/IPO"
define function total-price( $i as element(ipo:item)* )
as xs:decimal
{
let $subtotals := for $s in $i return $s/quantity * $s/USPrice
return sum( $subtotals )
}
Here is a query that calls the function we just
defined to get the total for an invoice (before
calculating taxes and shipping charges):
import schema namespace ipo="http://www.example.com/IPO"
import module namespace calc = "http://www.example.com/calc"
for $p in doc("ipo.xml")//element(ipo:purchaseOrder)
where $p/shipTo/name="Helen Zoe"
and $p/orderDate = xs:date("1999-12-01")
return calc:total-price($p//ipo:item)
This query illustrates the need to be able to pass
a sequence as a parameter to a function.
If the input document contains more than one
purchase order for the given date and person, a total
will be computed for each invoice.
1.9.4.12
Q12
In [XMLSchema0], a
Quarterly Report is created, summarizing the types of
products that have been billed on a per region basis.
It creates the following sample report:
<purchaseReport
xmlns="http://www.example.com/Report"
period="P3M" periodEnding="1999-12-31">
<regions>
<zip code="95819">
<part number="872-AA" quantity="1"/>
<part number="926-AA" quantity="1"/>
<part number="833-AA" quantity="1"/>
<part number="455-BX" quantity="1"/>
</zip>
<zip code="63143">
<part number="455-BX" quantity="4"/>
</zip>
</regions>
<parts>
<part number="872-AA">Lawnmower</part>
<part number="926-AA">Baby Monitor</part>
<part number="833-AA">Lapis Necklace</part>
<part number="455-BX">Sturdy Shelves</part>
</parts>
</purchaseReport>
This is the schema given for the above report:
<schema targetNamespace="http://www.example.com/Report"
xmlns="http://www.w3.org/2001/XMLSchema"
xmlns:r="http://www.example.com/Report"
xmlns:xipo="http://www.example.com/IPO"
elementFormDefault="qualified">
<!-- for SKU -->
<import namespace="http://www.example.com/IPO"/>
<annotation>
<documentation xml:lang="en">
Report schema for Example.com
Copyright 2000 Example.com. All rights reserved.
</documentation>
</annotation>
<element name="purchaseReport">
<complexType>
<sequence>
<element name="regions" type="r:RegionsType">
<keyref name="dummy2" refer="r:pNumKey">
<selector xpath="r:zip/r:part"/>
<field xpath="@number"/>
</keyref>
</element>
<element name="parts" type="r:PartsType"/>
</sequence>
<attribute name="period" type="duration"/>
<attribute name="periodEnding" type="date"/>
</complexType>
<unique name="dummy1">
<selector xpath="r:regions/r:zip"/>
<field xpath="@code"/>
</unique>
<key name="pNumKey">
<selector xpath="r:parts/r:part"/>
<field xpath="@number"/>
</key>
</element>
<complexType name="RegionsType">
<sequence>
<element name="zip" maxOccurs="unbounded">
<complexType>
<sequence>
<element name="part" maxOccurs="unbounded">
<complexType>
<complexContent>
<restriction base="anyType">
<attribute name="number" type="xipo:SKU"/>
<attribute name="quantity" type="positiveInteger"/>
</restriction>
</complexContent>
</complexType>
</element>
</sequence>
<attribute name="code" type="positiveInteger"/>
</complexType>
</element>
</sequence>
</complexType>
<complexType name="PartsType">
<sequence>
<element name="part" maxOccurs="unbounded">
<complexType>
<simpleContent>
<extension base="string">
<attribute name="number" type="xipo:SKU"/>
</extension>
</simpleContent>
</complexType>
</element>
</sequence>
</complexType>
</schema>
This report, which lists products sold by zip
code, is based on US purchase orders, not on the
international purchase report used in previous
queries. In the XML Schema Primer, these US purchase
orders are defined without a namespace. Here is an
example of such a purchase order, taken from the XML
Schema Primer:
<?xml version="1.0"?>
<purchaseOrder orderDate="1999-10-20">
<shipTo country="US">
<name>Alice Smith</name>
<street>123 Maple Street</street>
<city>Mill Valley</city>
<state>CA</state>
<zip>90952</zip>
</shipTo>
<billTo country="US">
<name>Robert Smith</name>
<street>8 Oak Avenue</street>
<city>Old Town</city>
<state>PA</state>
<zip>95819</zip>
</billTo>
<comment>Hurry, my lawn is going wild!</comment>
<items>
<item partNum="872-AA">
<productName>Lawnmower</productName>
<quantity>1</quantity>
<USPrice>148.95</USPrice>
<comment>Confirm this is electric</comment>
</item>
<item partNum="926-AA">
<productName>Baby Monitor</productName>
<quantity>1</quantity>
<USPrice>39.98</USPrice>
<shipDate>1999-05-21</shipDate>
</item>
</items>
</purchaseOrder>
Here is a query that generates the desired report
from a collection that contains US purchase
orders:
declare namespace rpt="http://www.example.com/Report"
let $orders := collection("orders")/purchaseOrder
[orderDate ge date("1999-09-01")
and orderDate le date("1999-12-31")]
let $items := $orders/items/item
let $zips := distinct-values($orders/billTo/zip)
let $parts := distinct-values($items/@partNum)
return
<rpt:purchaseReport>
<rpt:regions>
{
for $zip in $zips
order by $zip
return
<rpt:zip code="{$zip}">
{
for $part in $parts
let $hits := $orders[ billTo/zip = $zip and items/item/@partNum = $part]
let $quantity := sum($hits//item[@partNum=$part]/quantity)
where count($hits) > 0
order by $part
return
<rpt:part number="{$part}" quantity="{$quantity}"/>
}
</rpt:zip>
}
</rpt:regions>
<rpt:parts>
{
for $part in $parts
return
<rpt:part number="{$part}">
{
string($items[@partNum = $part]/productName)
}
</rpt:part>
}
</rpt:parts>
</rpt:purchaseReport>