4 Enhancements to nRQL: Server-side programming

nRQL has been revised extensively. Some important features of the new nRQL versions are:

• nRQL offers now termination-safe functional lambda expressions. These lambda expressions can be used in query heads and rule antecedences. nRQL allows a restricted kind of server-sided programming and can thus be used to implement, for example
  1. user-defined output formats for query results (e.g., the query results can also be written into a file),
  2. certain kinds of combined ABox/TBox queries,
  3. efficient aggregation operators (e.g., sum, avg, like in SQL).
• Adequate handling of synonym individuals and proper treatment of same-as assertions.
• A more complete told-value-if-exists head projection operator to retrieve told values of concrete domain attributes
• Enhanced data substrates.
• Enhanced TBox queries.
• The RCC substrate now works for OWL.
• New head projection operators (e.g., types, direct-types, describe,
  individual-synonyms)
• Various bug fixes and speed enhancements.

Here are some nRQL examples which demonstrates the points 1. to 3. Consider the following simple ABox:

Suppose you want to create a comma separated values file called test.csv which contains all the (possible implied) R role assertions. nRQL allows you to do this:

So, the query body retrieves all ?x, ?y individuals which stand in an R relationship; for each ?x, ?y tuple, one more line is attached to the file test.csv.

Regarding point 2, let us illustrate how “combined” TBox/ABox queries can be used to retrieve the direct instances of a concept, which has been requested by many users.

Let us create two concepts c and d such that d is a sub concept (child concept) of c:

We can verify that d is indeed a child concept of c, using a so-called TBox query:

Let us create two individuals so that i and j are instances of c; moreover, j is also an instances of d:

Thus, both i and j are c instances. However, only i is a direct c instance. We can retrieve these direct instances of c as follows:

Basically, retrieve1 is like retrieve, but first comes the body, and then the head. Thus, ?x is bound to a c instance. Using this binding, it is checked by means of a TBox subquery (tbox-retrieve1) whether the individual bound to ?x is also an instance of any subclass of c. If this is the case, the result tuple (resp. the current binding of ?x) is rejected (see the special :reject token); otherwise, the result tuple is constructed and returned. The returned result tuples make up the final result set.

Please note that the combination of lambda expressions and :reject token gives you the ability to define arbitrary, used-defined filter predicates which are executed efficiently since they are directly on the RacerPro server.

Finally, let us consider how aggregation operators can be implemented. Consider the following book store scenario:

We can now determine the number of authors of the single books with the following query:

Another interesting question might be to ask for the average price of all the books. This is a little bit more tricky, but works in nRQL as well:

The trick here is to use the always true query body true-query in order to let nRQL first evaluate the lambda body (since lambda bodies are only valid in nRQL heads, but not available as “first order statements” in RacerPro); thus, the lambda simply acquires all the prices of the individual books and then computes and returns the average price, as expected.

Please refer to the chapter on nRQL in the RacerPro User Guide in order to learn how to implement even more efficient versions of these queries.

Functional programming statements cannot only be used in Lambda terms in queries, but also at toplevel.

Often, user-defined query format output must be generated from query results, e.g., HTML reports. This is easy with nRQL as well. For example, the result of the query

on the famous people+pets.owl KB is

Suppose this result shall be presented as an HTML table, together with some additional information about the query which has been posed. In principle, it is easy to generate a HTML file using with-open-output-file and print (format) statements to write some HTML. However, this results in ugly code. For this reason, some syntactic sugar is available. The following query will generate an HTML file example.html which is shown in Figure 8: