1.9.4 Queries and Results
1.9.4.1 Q1
Count the invoices shipped to the United Kingdom.
Solution in XQuery:
import schema "ipo.xsd"
declare namespace ipo="http://www.example.com/IPO"
count(
document("ipo.xml")//ipo:shipTo[. instance of element of type 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>
<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:
import schema "ipo.xsd"
import schema "zips.xsd"
declare namespace ipo="http://www.example.com/IPO"
declare namespace zips="http://www.example.com/zips"
define function zip-ok($a as element of type ipo:USAddress)
as xs:boolean
{
some $i in document("zips.xml")/zips:zips/zips:row
satisfies $i/zips:city = $a/ipo:city
and $i/zips:state = $a/ipo:state
and $i/zips:zip = $a/ipo:zip
} An attempt to call this functions 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>
<row>
<city>Cambridge</city>
<prefix>CB</prefix>
</row>
<row>
<city>Oxford</city>
<prefix>OX</prefix>
</row>
</postals> Solution in XQuery:
import schema "ipo.xsd"
import schema "postals.xsd"
declare namespace ipo="http://www.example.com/IPO"
declare namespace pst="http://www.example.com/postals"
define function postal-ok($a as element of type ipo:UKAddress)
as xs:boolean
{
some $i in document("postals.xml")/pst:postals/pst:row
satisfies $i/pst:city = $a/ipo:city
and xf:starts-with($a/ipo: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 "ipo.xsd"
import schema "postals.xsd"
import schema "zips.xsd"
declare namespace ipo="http://www.example.com/IPO"
declare namespace pst="http://www.example.com/postals"
declare namespace zips="http://www.example.com/zips"
define function postal-ok($a as element of type ipo:UKAddress)
as xs:boolean
{
some $i in document("postals.xml")/pst:postals/pst:row
satisfies $i/pst:city = $a/ipo:city
and starts-with($a/ipo:postcode, $i/pst:prefix)
}
define function zip-ok($a as element of type ipo:USAddress)
as xs:boolean
{
some $i in document("zips.xml")/zips:zips/zips:row
satisfies $i/zips:city = $a/ipo:city
and $i/zips:state = $a/ipo:state
and $i/zips:zip = $a/ipo:zip
}
define function address-ok($a as element of type ipo:Address)
as xs:boolean
{
typeswitch ($a)
case $zip as element of type ipo:USAddress
return zip-ok($zip)
case $postal as element of type ipo:UKAddress
return postal-ok($postal)
default return false()
}
for $p in document("ipo.xml")//ipo:purchaseOrder
where not( address-ok($p/ipo:shipTo) and address-ok($p/ipo: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 "ipo.xsd"
declare namespace ipo="http://www.example.com/IPO"
define function names-match( $s as element ipo:shipTo context ipo:purchaseOrder,
$b as element ipo:billTo context ipo:purchaseOrder )
as xs:boolean
{
$s/ipo:name = $b/ipo:name
}
for $p in document("ipo.xml")//ipo:purchaseOrder
where not( names-match( $p/ipo:shipTo, $p/ipo: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 "ipo.xsd"
declare namespace ipo="http://www.example.com/IPO"
for $p in document("ipo.xml")//ipo:purchaseOrder,
$s in $p/ipo:shipTo
where not( $s instance of element of type ipo:USAddress)
and exists( $p//ipo:USPrice )
return $p In this schema, prices are derived directly
from decimal, not from a common base
type. That means that we have to use the
element name USPrice to identify US
prices. 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 "ipo.xsd"
declare namespace ipo="http://www.example.com/IPO"
define function comment-text($c as element ipo:comment)
as xs:string
{
string( $c )
}
for $p in document("ipo.xml")//ipo:purchaseOrder,
$t in comment-text( $p//ipo:shipComment )
where $p/ipo:shipTo/ipo:name="Helen Zoe"
and $p/ipo:orderDate = 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 document("ipo.xml")//ipo:purchaseOrder
where $p/ipo:shipTo/ipo:name="Helen Zoe"
and $p/@orderDate = 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 "ipo.xsd"
declare namespace ipo="http://www.example.com/IPO"
for $p in document("ipo.xml")//ipo:purchaseOrder
where $p/ipo:shipTo/ipo:name="Helen Zoe"
and $p/@orderDate = date("1999-12-01")
return ($p//ipo:customerComment | $p//ipo:shipComment | $p//ipo:comment ) This solution cheats. In the current
Working Drafts, it is not possible to search
for all elements in a substitution group
without enumerating them. This is being
discussed in the Working Groups.
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 "ipo.xsd"
declare namespace ipo="http://www.example.com/IPO"
define function comments-for-element( $e as element )
as ipo:comment*
{
let $c := $e/(ipo:customerComment | ipo:shipComment | 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 "ipo.xsd"
declare namespace ipo="http://www.example.com/IPO"
define function deadbeat( $b as element ipo:billTo of type ipo:USAddress )
as xs:boolean
{
$b/ipo:name = document("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 specifed 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:
import schema "ipo.xsd"
declare 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/ipo:quantity * $s/ipo: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 "ipo.xsd"
declare namespace ipo="http://www.example.com/IPO"
for $p in document("ipo.xml")//ipo:purchaseOrder
where $p/ipo:shipTo/ipo:name="Helen Zoe"
and $p/ipo:orderDate = date("1999-12-01")
return total-price($p//ipo:item) This query illustrates the need to be able
to pass a sequence as a parameter to a
function.
The above query works under the assumption
that no more than one purchase order is
shipped to the same person on the same
date. There is no unique identifier for the
purchase orders in this schema; if there were,
we would have used it to select the purchase
order.
1.9.4.12 Q12
In [XMLSchema0], a Quarterly Report is
created, summarize how many of which types of products
have been billed on a per region basis. It shows 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 orderss, 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="{data($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="{data($part)}" quantity="{$quantity}"/>
}
</rpt:zip>
}
</rpt:regions>
<rpt:parts>
{
for $part in $parts
return
<rpt:part number="{data($part)}">
{
let $i := distinct-values($items[@partNum = $part])
return string-value($i/productName)
}
</rpt:part>
}
</rpt:parts>
</rpt:purchaseReport>