Qexo - The GNU Kawa implementation of XQuery

Qexo is a partial implementation of the XML Query language. It achieves high performance because a query is compiled down to Java bytecodes using the Kawa framework. Kawa also includes a proof-of-concept implementation of XSLT.

The Qexo mailing list is has address qexo-general@gnu.org. To subscribe, unsubscribe, or view the archives use the information page.

Qexo 1.9.1 is now available. Here are instructions for getting it.

Benefits

• XQuery allows convenient mixing of output xml or html fragments with calculations, like JSP and PHP do. However, XQuery is an expression-oriented language, so you don't need to clutter up your code with print or echo statements. More importantly, you can treat a document fragment as input to a function, which can then be processed by another function, and so on.
• Kawa-XQuery optimizes sequences and element constructors to avoid actually creating temporary values. In many cases the output will be written directly as xml/html, without constructing actual node or sequence objects.
• Other common html- and xml-generating frameworks (such as cgi scripts) are interpreted. Kawa-XQuery is compled to Java bytecode, so it benefits from highly-tuned JVMs. It does analysis and optimizations at compile-time. You also have the option of compiling down to native code using GCJ.
• XQuery is staticly typed (in contrast to xslt). This can help in producing better and earlier (compile-time) error messages, and it can aid the compiler in generating more efficient code.
• With Kawa-XQuery you have a choice of compiling a program ahead of time, or you can read and evaluate it on the fly. In the latter case, it will still be compiled, but without the overhead of having to invoke an external compiler.

Documentation

You can read a short introduction to XQuery;
an article on the XQuery Data Model and Types;
and a longer article on generating XML and HTML using XQuery.

You can read here for more on running Qexo.
Here is an article debugging and finding errors in Qexo programs.

If you're interested in servlets and web applications, you can read an article showing how to write and install a trivial web application, or an article with an older but useful information.

Examples

Data conversion

Here is a program for converting a table:

let $newline := "
",
$result := (document("tab.xml")/result)
  return
    (<table>
{for $x in ($result/row)
      return (<tr>{
        for $y in ($x/fld1) return (<td><b>{children($y)}</b></td>),
        for $y in ($x/fld2) return (<td>{list(100,children($y))}</td>)}</tr>,
        $newline)
}</table>,$newline)

This will convert an input table like this:

<result>
<row>
<fld1>a1</fld1>
<fld2>12</fld2>
</row>
<row>
<fld1>b1</fld1>
<fld2>22</fld2>
</row>
</result>

<table>
<tr><td><b>a1</b></td><td><list>100 12</list></td></tr>
<tr><td><b>b1</b></td><td><list>100 22</list></td></tr>
</table>

Formatted table generation

The following program generates a 10x10 multiplication table:

<table>{
  for $y in 1 to 10 return (
    <tr>{
      for $x in 1 to 10 return
        let $bg:=(if($x mod 2 + $y mod 2 <= 0) then "lightgreen"
                  else if ($y mod 2 <= 0) then "yellow"
                  else if ($x mod 2 <= 0) then "lightblue"
                  else "white"),
            $prod:=$x*$y
          return <td align="right" bgcolor="{$bg}">{
            if ($x > 1 and $y > 1) then $prod else <b>{$prod}</b>}</td>
    }</tr>,
    "
")
}</table>,"
"

This is the result:

1	2	3	4	5	6	7	8	9	10
2	4	6	8	10	12	14	16	18	20
3	6	9	12	15	18	21	24	27	30
4	8	12	16	20	24	28	32	36	40
5	10	15	20	25	30	35	40	45	50
6	12	18	24	30	36	42	48	54	60
7	14	21	28	35	42	49	56	63	70
8	16	24	32	40	48	56	64	72	80
9	18	27	36	45	54	63	72	81	90
10	20	30	40	50	60	70	80	90	100

Defining a function

Here is an example of defining and using a recursive function:

define function descendent-or-self ($x) {
  $x, for $z in children($x) return descendent-or-self($z) }
descendent-or-self (<a>text1<b>text2</b></a>)

Photo album

How to get and install Qexo

Qexo is part of Kawa. The easiest way to try Qexo out it to download a runnable jar. Alternatively, you can get the source code. Both are available from the Kawa ftp site http://ftp.gnu.org/pub/gnu/kawa/ or a mirror. Follow these instructions to build from source code. To keep up with the very latest changes you might prefer to get Kawa from the SVN repository, as described in the Kawa manual.

Usage

You run Kawa-XQuery just the way you run Kawa, except you need to specify the --xquery flag to specify the language. (By default Kawa expects Scheme source code.)

For example you can type in xquery expression directly at the command line. If the end of a the line occurs where the seen input is a valid XQuery expression, then that expression will be treated as a complete expression. (However, when parsing a file the entire file is parsed.)

$ java -jar kawa-1.9.jar --xquery
(: 1 :) for $x in (3,4,5) return <a>{$x}</a>
<a>3</a><a>4</a><a>5</a>
(: 2 :) string(<a>3+5 is {3+5}</a>)
3+5 is 8
(: 3 :)

You can also compile an XQuery program to a Java application:

$ java -jar kawa-1.9.jar --xquery --main -C prog.xql
$ java -cp .:kawa-1.9.jar prog

You can read here for more on running Qexo.

Generating and Running Servlets

You can compile an XQuery program to a Servlet. Here is a simple web application example. This article has additional but older information. The servlet can be run in a servlet-aware web server, or as a CGI script.

License

Qexo is is part of Kawa, whose licence is the X11/MIT license.