Relational database systems may be turned into efficient XML and XPath processors if the system is provided with a suitable relational tree encoding. This paper extends this relational XML processing stack and shows that an RDBMS can also serve as a highly efficient XQuery runtime environment. Our approach is purely relational: XQuery expressions are compiled into SQL code which operates on the tree encoding. The core of the compilation procedure trades XQuery’s notions of variable scopes and nested iteration (FLWOR blocks) for equi-joins. The resulting relational XQuery processor closely adheres to the language semantics, e.g., it respects node identity as well as document and sequence order, and can support XQuery’s full axis feature. The system exhibits quite promising performance figures in experiments. Somewhat unexpectedly, we will also see that the XQuery compiler can make good use of SQL’s OLAP functionality. 1

This work may be seen as a further proof of the versatility of the relational database model. Here, we add XQuery to the catalog of languages which RDBMSs are able to "speak" fluently. Given suitable relational encodings of sequences and ordered, unranked trees

We report on a compilation procedure that derives relational algebra plans from arbitrarily nested XQuery FLWOR blocks. While recent research was able to develop relational encodings of trees which may turn RDBMSs into highly efficient XPath and XML Schema processors, here we describe relational encodings of nested iteration, variables, andthe item sequences to which variables are bound. The developed techniques are purely relational in more than one sense: (a) we rely on a standard (or rather: classical) algebra that is readily supported by relational engines, and (b) we use relational concepts like functional and multivalued dependencies to significantly simplify the emitted plans. This work blends well with the mentioned tree encodings and thus contributes a further important building block to investigations into XQuery processors based on relational database technology. 1.

Abstract — Streams are preferable over data stored in memory in contexts where data is too large or volatile, or a standard approach to data processing based on storing is too time or space consuming. Emerging applications such as publishsubscribe systems, data monitoring in sensor networks, financial and traffic monitoring, and routing of MPEG-7 call for querying streams. In many such applications, XML streams are arguably more appropriate than flat streams, for they convey (possibly unbounded) unranked ordered trees with labeled nodes. However, the flexibility enabled by XML streams in data modeling makes query evaluation different from traditional settings and challenging. This article describes SPEX, a streamed and progressive evaluation of XPath. SPEX compiles queries into networks of simple and independent transducers and processes XML streams with polynomial combined complexity. This makes SPEX especially suitable for implementation on devices with low-memory and simple logic as used, e.g., in mobile computing.

There are more spots than immediately obvious in XQuery expressions where order is immaterial for evaluation— this affects most notably, but not exclusively, expressions in the scope of unordered { } and the argument of fn:unordered (). Clearly, performance gains are lurking behind such expression contexts but the prevalent impact of order on the XQuery semantics reaches deep into any compliant XQuery processor, making it non-trivial to set this potential free. Here, we describe how the relational XQuery compiler Pathfinder uniformly exploits such order indifference in a purely algebraic fashion: Pathfinder-emitted plans faithfully implement the required XQuery order semantics but (locally) ignore order wherever this is admitted.

the capabilities of an earlier server and to provide more rapid access to a large knowledge base than the Protégé knowledge acquisition tool. The system architecture was optimized using indexes for the most common classes of queries. Additional performance benefits were gained by pre-computing the transitive closure of appropriate relationships. Flexible, random access of the data is provided via a declarative query language, derived from StruQL, a language for querying semi-structured data. The poster provides several examples of queries supported by OQAFMA. BACKGROUND AND RELATED WORK The Foundational Model of Anatomy 1 (FMA) is a semantically expressive ontology of anatomical entities

There are two ways to write a program for manipulating tree-structured data such as XML documents and S-expressions: One is to write a tree-processing program focusing on the logical structure of the data and the other is to write a stream-processing program focusing on the physical structure. While tree-processing programs are easier to write than stream-processing programs, tree-processing programs are less efficient in memory usage since they use trees as intermediate data. Our aim is to establish a method for automatically translating a tree-processing program to a stream-processing one in order to take the best of both worlds. We define a programming language for processing binary trees and a type system based on ordered linear type, and show that every well-typed program can be translated to an equivalent stream-processing program.

Relational query processors are probably the best understood (as well as the best engineered) query engines available today. Although carefully tuned to process instances of the relational model (tables of tuples),

Software agents can be used to automate many of the tedious, time-consuming information processing tasks that humans currently have to complete manually. However, to do so, agent plans must be capable of representing the myriad of actions and control flows required to perform those tasks. In addition, since these tasks can require integrating multiple sources of remote information – typically, a slow, I/O-bound process – it is desirable to make execution as efficient as possible. To address both of these needs, we present a flexible software agent plan language and a highly parallel execution system that enable the efficient execution of expressive agent plans. The plan language allows complex tasks to be more easily expressed by providing a variety of operators for flexibly processing the data as well as supporting subplans (for modularity) and recursion (for indeterminate looping). The executor is based on a streaming dataflow model of execution to maximize the amount of operator and data parallelism possible at runtime. We have implemented both the language and executor in a system called THESEUS. Our results from testing THESEUS show that streaming dataflow execution can yield significant speedups over both traditional serial (von Neumann) as well as non-streaming dataflow-style execution that existing software and robot agent execution systems currently support. In addition, we show how plans written in the language we present can represent certain types of subtasks that cannot be accomplished using the languages supported by network query engines. Finally, we demonstrate that the increased expressivity of our plan language does not hamper performance; specifically, we show how data can be integrated from multiple remote sources just as efficiently using our architecture as is possible with a state-of-the-art streaming-dataflow network query engine.

The mobile office devices market is currently growing, mainly due to the descending cost of wireless technology as well as the high diversity of functions and features covered. Diversity and proliferation become a hard problem when a person or organization aims at selecting the appropriate device for their particular needs. We propose here a framework for producing device recommendations based on personal or business needs. The framework is articulated through an architecture that includes subsystems for data extraction, recommendation and personalization. All these subsystems operate upon a goal-oriented knowledge base whose presentation is the subject of this paper. Our approach is built upon three independent models: a market model, which contains descriptions of the current devices offered in the marketplace; a domain model, which states the needs of the person or organization; and a mediator model, which describes the types of devices available. We show the actors and processes around these models. Last, we present a prototype that acts as proof-of-concept of the recommender system.