XQL: A Query Language for XML Data
Hiroshi Ishikawa, Kazumi Kubota, Yasuhiko Kanemasa
Fujitsu Laboratories Ltd.
hiro@flab.fujitsu.co.jp
   
1. Introduction
 
XML data are expected to be widely used in Web information systems and EC/EDI 
applications. Such applications usually use a large number of rather 
homogeneous XML data.  First, we must allow users to retrieve only necessary
portions of XML data by specifying search conditions to flexibly describe 
such applications. Second, we must allow users to combine XML data from 
different sources. To this end,  we will provide a query 
language for XML data tentatively called XQL (Xml data Query Language). 
A query language called XML-QL [XML-QL] has already been proposed to W3C, 
which has largely inspired the design of XQL. We have designed XQL, keeping
in mind its continuity with database standards such as SQL [ANSI X3] and OQL 
[ODMG].  We will describe DTD for example XML data in Section 2 and explain 
the functionality of XQL by using the example data in Section 3.
 
2. Database schema
 
We use database schemas or DTD by slightly changing example DTD used in XML-
QL[XML-QL] as follows:
 
 (DTD)
<!ELEMENT book (author+, title, publisher)>
<!ATTLIST book year CDATA>
<!ELEMENT article (author, title, year?)>
<!ATTLIST article type CDATA>
<!ELEMENT publisher (name, address)>
<!ELEMENT author (firstname?, lastname, office+)>
<!ELEMENT office (CDATA | longoffice)>
<!ELEMENT longoffice (building, room)>
<!ELEMENT car (name, brand)>
<!ELEMENT watch (name, brand)>
 
Here DTD for book elements indicates that a book has at least one author 
and one mandatory title and publisher. DTD for article elements indicates 
that an article has one mandatory author and title and one optional year. 
An article has a type as an attribute. Note that an author has at least 
one office, which has a variant structure of either literal data or a 
pair of building and room.
 
3. Functionality

We describe the functionality of XQL by using schemas introduced in the 
previous section.  XQL has a select-from-where construct as a basis, 
similar to SQL and OQL. We have borrowed examples from XML-QL [XML-QL].
 
(1) Data match
select $book.author
from bib:URL "www.a.b.c/bib.xml", book:$bib.book
where $book.publisher.name ="Addison-Wesley"
 
The basic unit of XQL is a path expression, that is, a series of element 
variables (explained just below) or tag names such as "$bib.book". The 
user declares element variables in a from-clause such as bib and book. 
The user can also bind XML documents specified by URL to element variables 
such as bib. References of element variables are done by prefixing "$" to 
them such as $bib.book. In a select-clause, the user specifies data as a 
result such as $book.author. Results have a tag for author as default in 
this case. The user checks data match in a where-clause, such as  
$book.publisher.name ="Addison-Wesley" 
 
(2) Data constructor
select result:<$book.author, $book.title>
from bib:URL "www.a.b.c/bib.xml", book:$bib.book
where $book.publisher.name = "Addison-Wesley"
 
Here "<>" in a select-clause creates new elements of a specified construct 
such as author and title tags. New elements have a name result. 
 
(3) Grouping
select result:<$book.title, $book.author>
from bib:URL "www.a.b.c/bib.xml", book:$bib.book
where $book.publisher.name ="Addison-Wesley"
groupby $book.title
 
A groupby-clause indicates that result elements are grouped by book title. 
Further, authors of result elements are nested. We don't use nested query 
for grouping unlike XML-QL [XML-QL].
 
(4) Sorting
select result: <$book.title, $book.author>
from bib:URL "www.a.b.c/bib.xml", book:$bib.book
where $book.publisher.name ="Addison-Wesley"
orderby $book.title
 
An orderby-clause sorts result elements by book title. In this case, 
however, book authors of result elements are not nested unlike groupby.
 
(5) Join
select $bib.article
from bib:URL "www.a.b.c/bib.xml"
where $bib.book.author.firstname 
�@�@		= $bib.article.firstname and
	$bib.book.author.lastname 
�@�@		= $bib.article.lastname and
	$bib.book.year > 1995
 
In a where-clause, the user specifies join of books and articles by authors. 
Attributes such as year are referenced similar to tags, such as $bib.book.year.
 
(6) Tag variable [XML-QL]
select result:<$title, $AorE>
from bib:URL "www.a.b.c/bib.xml", year:$bib.*.year, title:$bib.*.title, 
	AorE:$bib.*.(author | editor)
where $year= 1995 and $AorE ="Smith"
 
We don't use tag variables introduced by XML-QL [XML-QL]. Instead, we allow 
regular expressions as path expressions so that the user can simulate tag 
variables by using element variables declared as regular path expressions 
(See also (7) in this section). For example, "$bib.*.(author | editor) " 
matches path expressions such as "book.author", "book.editor", 
"article.author", and "article.editor". Multiple occurrences of "*" in a 
from-clause are supposed to be bound to the same path at the same time.
 
(7) Regular path expression
select result:<$name>
from bib:URL "www.a.b.c/bib.xml", name:$bib.*.name, brand:$bib.*.brand
where $brand = "Ford"
 
Brand and name are supposed to be tags of the same element.
 
select result:<$lastname>
from bib:URL "www.a.b.c/bib.xml", lastname:$bib.author.lastname, 
	office:$bib.author.(office | office.room)
where $office = "245"
 
"office" is bound to "$bib.author.office" or "$bib.auther.office.room". 
The above query is alternatively expressed like this:
 
select result:<$bib.author.lastname>
from bib:URL "www.a.b.c/bib.xml"	
where $bib.author.(office | office.room) = "245"
 
(8) Data conversion
select <id = PersonID($author.firstname, $author.lastname), 
		$author.firstname, $author.lastname, 
		publicationtitle: $title>
from bib:URL "www.a.b.c/bib.xml", any:$bib.*, author:$any.author, 
	title:$any.title
 
In a select-clause, the user inserts to id attribute values of functions 
such as "PersonID($author.firstname, $author.lastname)". "publicationtitle" 
is introduced as a new tag.
 
(9) Join of data from multiple sources
select result:<$d.name, $t.income>
from d:URL "www.a.b.c/data.xml", t:URL "www.irs.gov/taxpayers.xml"
where $d.ssn=$t.ssn

The user can specify join of XML data from different sources indicated by URL.
 
(10) Embedding query
<result>
 <articles>
	(select $article.title
	from bib:URL "www.a.b.c/bib.xml", article:$bib.article
	where $article.year > 1995)
 </>
 <books>
	(select $book.title
	from bib:URL "www.a.b.c/bib.xml", book:$bib.book
	where $book.year > 1995)
 </>
</>
 
The user can embed XQL query in XML data.
 
(11) Function definition
FUNCTION findDeclaredIncomes (Taxpayers, Employees)
select result:<$Employees.name, $Taxpayers.income>
from Taxpayers, Employees
where $Employees.ssn=$Taxpayers.ssn
 
The user defines a function by specifying XQL query in its body. The role 
of functions is similar to that of relational views. See (8) in this 
section for invocation of functions.
 
4. Conclusion
 
  We have proposed XQL as a query language for XML data of continuity 
with database standards. We expect to activate emergence of an easily 
understandable query language. We have a plan to explore approaches to 
mapping DTD to databases (RDB or ODB such as [Jasmine]) and to implement 
an XQL processor.
 
References
[ANSI X3] http://gatekeeper.dec.com/pub/standards/sql, 1998
[Jasmine] Ishikawa, H., et al.: An Object-Oriented Database System Jasmine: 
Implementation, Application, and Extension., IEEE Trans. Knowledge and Data 
Engineering, vol. 8, no. 2, pp.285-304 (1996).
[ODMG]R.G.G.Cattell, D.K.Barry, Eds., Object Database Standard: ODMG 2.0, 
Morgan Kaufmann Publishers, Inc., 1997
[XML-QL] http://www.w3.org/TR/NOTE-xml-ql, 1998