Evaluation of XML Query Implementations

Software AG's Quip

http://www.softwareag.com/developer/downloads/default.htm

1. Capabilities:
   • It is a prototype of XQuery for Windows 32 bit platforms;
   • It's easy to install & run.
   • Most of the XQuery language specification has been implemented including: DISTINCT, UNION, // (DESCENDANT), User defined function, NAMESPACE, etc.
   • Queries may be applied to XML files or XML stored in a Tamino database and queries can be saved.
   • Two non-standard additions:
     • function: 'fromCollection(name)' with a String argument 'name'
     • function: 'textsearch' with two String arguments
   • Examples include 76 queries and 51 XML files
   • Syntax conforms to the 07 June 2001 Working Draft of XQuery.
2. Limitations:
   • Not implemented are:
     • dereference symbol (->)
     • static type checking or any schema evaluation
     • basic types other than String, Integer
     • node identity
   • Known Problems - nitpicking about path names. In some situations it only accepts true Windows path notation (only backslashes are accepted, slashes are not valid).
   • No source code availability

Microsoft's XQuery Prototype

1. Capabilities:
   • Can formulate XQueries and parse and execute them via a website
   • Supports: FLWR expressions, Path Expressions, Conditional Expressions, Multiple For, min(), max(), avg(), sum(), count(), etc.
   • Gives examples for each of the W3C use cases. Some use cases don't work due to unimplemented features.
   • Provides a managed class library containing XQuery classes that can be programmed against using the beta 2 release of the .Net Frameworks SDK. These classes allow you to run XQuery queries over arbitrary XML documents. (Note***: The Beta 2 release of the .NET Framework runs on windows platform.)
   • Syntax conforms to the June 7, 2001 draft of XQuery Spec.
2. Limitations:
   • You can build query and execute it on the above website, but it is based on the predefined XML documents. If you want to run XQuery queries over arbitrary XML documents, you need to program using the XQuery classes provided.
   • The following are not implemented: -> (DEREF), DISTINCT, UNION, // (DESCENDANT), User defined functions, SORTBY, UNORDERED, FILTER, Namespace, BEFORE/AFTER, Insert/Update/Delete, No type checking.

Fatdog - XML Query Engine

1. Capabilities:
   • XML Query Engine is a local-file-based search engine tool for XML. It's a JavaBean component that lets you index and then search your file-based XML documents for element, attribute, and full-text content. The index, once built, can be queried using XQL.
   • Provides XML Query Engine API. For example, To index a document, you call setDocument(filePathStr_1). You can then pose queries against the index using setQuery(queryString). Any queries you make are posed against the sum content of all the documents you've indexed to that point.
   • Ships with very early support for XQuery (currently based on the February 15 specification ).
   • Supports FLWR's, element constructors, and XPath expressions with simple predicates.
   • XML Query Engine extends XQL's syntax to provide a full-text capability
   • Give five sample applications written in JAVA and XML Query Engine API
2. Limitation:
   • It's difficult to install and run the example because the readme file dosn't mention which version of the JAVA API is required for XML Parsing.
   • If you want to pose queries on your own XML files, you need to modify the sample code and recompile it, or you must write your own application using the XML Query Engine API.
   • Supports simple queries: FLWR expressions, Path Expressions, Multiple For
   • You have to build an index of the XML files first, then you can query on it.
   • No source code

SourceForge - XQuench

1. Capabilities:
   • XQuench is an XML Query parser and engine. The aim is to provide programmers with an API that implements the specifications at http://www.w3.org/XML/Query
   • Open-source
2. Limitation:
   • XQuench is in very early stages of development, so there are no user docs right now.
   • You should check out a CVS version from sourceforge website and try to compile it yourself. Before you compile it, you need to download JavaCC 2.0 (a parser generator for java programs) to generate a parser for the XML Query language and Ant 1.3 to build XQuench. So it takes some time to make it runnable, but the instructions are well written (much better than Fatdog).
   • What XQuench can currently do is to parse the XML Query language, that's why after you run it with its own test query, you got a list of syntax words: --Input: /home2/weiren/work/xmlquery/xquench/xquench/dist/doc/testsuite/simp1.xmq --Good Input! >Start > XQueryFile > XQueryUnit > FunctionLibrary > Query > Expression .........

Kweelt

http://db.cis.upenn.edu/Kweelt/

1. Capabilities:
   • Kweelt is a framework to query XML data.
   • Implements a query language for XML that satisfies all the requirements from the W3C query-language-requirements (February 15, 2001) with a lot of useful extensions.
   • Comes with numerous working examples
   • Offers multiple XML back-ends. The query evaluator does not impose any specific storage for XML but relies on a set of interfaces (Node and NodeList) implemented by a NodeFactory. It is storage-independent.
   • Open-source fully written in Java
   • Provides Kweelt API.
   • Extensible. The user can create his/her own user-defined functions (UDF) and make them available inside the query. Kweelt provides various template classes to make the creation of such functions very easy.
   • Comes with the Kweelt Server Pages (KSP) extension, a built-in Cocoon processor. KSP allows to embed Kweelt queries inside any XML page serviced by Cocoon.
2. Limitations:
   • Namespaces are Not supported;
   • Bugs are mentioned in the to-do list, but no details are provided.

X-HIVE XQuery

http://www.x-hive.com/xquery

1. Capabilities:
   • It is an on-line XQuery demo.
   • Works with XML documents stored in a native XML database(X-Hive/DB) which can be viewed through the database browser.
   • Supports queries over multiple XML documents. The sample queries from the XMach-1 benchmark have been included to demonstrate this feature.
   • Most of the XQuery language has been implemented including declarations, expressions, operators and many useful functions. See details on their URL.
   • Utilizes the documents and queries as described in the XML Query Use Cases document
   • Syntax conforms to the 07 June 2001 Working Draft of XQuery.
2. Limitations:
   • Can't run XQuery queries over arbitrary XML documents;
   • 4 queries from the XML Query Use Cases document do not work yet in this demo.
   • No source code

Summary: 

Quip, Microsoft, XQuench, Fatdog, Kweelt, X-Hive

1. Both Microsoft and X-Hive are web-based demo and can only query on predefined XML files. And conforms to the latest Xquery working draft (June 2001).While Microsoft can query on arbitary XML documents using the classe library provided.
2. Both X-Hive and Quip support queries over multiple XML documents.Quip works with XML documents stored in a Tamino database or as flat files in the file system, while X-Hive only works with XML documents stored in a native XML database(X-Hive/DB).
3. XQuench only has an XML query language parser and currently no query evaluator. They say their immediate priorities are to:
   • satisfy all of W3C's test cases
   • release a new version (I checked out the souce code from SourceForge website, maybe they haven't checked in the latest version of XQuench yet)
4. Fatdog - XML Query Engine - must first build an index for the XML files and then you can build query on that index. It supports simple query and provides an API.
5. Quip conforms to the latest XQuery working draft (June 2001). Most of the XQuery language features have been implemented. It runs on Windows 32 bit platforms. No source code, but provides many sample queries.
6. Kweelt is not just an implementation of a query language. It provides other extensible functions(details see above).It provides an API and source code. They claim to support all the use-cases published by W3C for the XML query requirements. But they don't mention which version of the requirements document is used. It is noteworthy that the timestamp of its downloaded file is Sep-2000.