XQuery Expressions Research Articles

Enabling Schema-Free XQuery with meaningful query focus

The widespread adoption of XML holds the promise that document structure can be exploited to specify precise database queries. However, users may have only a limited knowledge of the XML structure, and may be unable to produce a correct XQuery expression, especially in the context of a heterogeneous information collection. The default is to use keyword-based search and we are all too familiar with how difficult it is to obtain precise answers by these means. We seek to address these problems by introducing the notion of Meaningful Query Focus (MQF) for finding related nodes within an XML document. MQF enables users to take full advantage of the preciseness and efficiency of XQuery without requiring (perfect) knowledge of the document structure. Such a Schema-Free XQuery is potentially of value not just to casual users with partial knowledge of schema, but also to experts working in data integration or data evolution. In such a context, a schema-free query, once written, can be applied universally to multiple data sources that supply similar content under different schemas, and applied "forever" as these schemas evolve. Our experimental evaluation found that it is possible to express a wide variety of queries in a schema-free manner and efficiently retrieve correct results over a broad diversity of schemas. Furthermore, the evaluation of a schema-free query is not expensive: using a novel stack-based algorithm we developed for computing MQF, the overhead is from 1 to 4 times the execution time of an equivalent schema-aware query. The evaluation cost of schema-free queries can be further reduced by as much as 68% using a selectivity-based algorithm we develop to enable the integration of MQF operation into the query pipeline.

Optimization of nested XQuery expressions with orderby clauses

XQuery, the defacto XML query language, is a functional language with operational semantics, which precludes the direct application of classical query optimization techniques. The features of XQuery, such as nested expressions and ordered semantics, further aggravate this situation. The appropriate extension of existing optimization techniques to XQuery processing hence represents an important and non-trivial task. We propose an algebraic rewriting technique of nested XQuery expressions containing explicit orderby clauses. Unlike prior work, this technique enables the optimization of nested XQuery expressions not only with set but also with ordered sequence semantics. Our technique is based on two steps. First, we perform order-sensitive algebraic query unnesting. Second, we apply query minimization techniques that exploit pairwise XPath set containment after pulling up order-sensitive operations. We illustrate how our proposed technique is able to not only successfully tackle the XQuery logical optimization problem solved in the NEXT framework, but also to correctly support ordered semantics. We have implemented the proposed optimization techniques on top of the XAT algebraic framework in our RainbowCore project. We show the performance gain achievable by our approach using an experimental study with the RainbowCore engine.

관계형 DBMS를 이용한 XML 질의 처리 시스템 XPERT의 개발

본 논문은 관계형 DBMS를 사용한 XML 질의 처리 시스템 XPERT(XML Query Processing Engine using Relational Technologies)의 개발 내용을 소개한다. 본 논문의 XPERT에서 제안하는 XML 저장 방식은 XML 문서를 여러 구성 성분별로 나누어 관계형 테이블에 저장하는 분할(decomposition 또는 shredded) 방식을 사용하고, 분할된 관계형 테이블을 바탕으로 XML 질의를 SQL로 변환하고, 관계형 DBMS에서 변환된 SQL을 실행하여 결과를 반환하는 방식을 사용한다. 제안한 XQuery 변환 방식은 먼저 XQuery의 구문 분석을 통하여 AST(Abstract Syntax Tree)를 생성하고, AST를 순회하면서 SQL 문장을 생성한다. 생성된 SQL 문장은 XML 문서의 경로를 사용함으로써 XQuery 연산의 조인 횟수를 감소시키며, 계층적 정보 검사나 문서에 내재된 결과의 순서를 지키기 위하여 사용하는 순서 정보는 Dewey 번호를 효과적으로 사용한다. 특히 XQuery의 XPath와 FLWOR 연산을 SQL로 변환하고 실행하는 효과적인 방법을 제시하고 제안된 XPERT시스템의 프로토타입을 개발하여 그 기능을 평가한다. This paper introduces the development XPERT(XML Query Processing Engine using Relational Technologies) which is based on relational model. In our system we have used a decomposed approach to store XML files in relational tables. XML queries are translated to SQLs according to the table schema, and then they are sent to the relational DBMS to get the results back. Our translation scheme produces AST(Abstract Syntax Tree) by analyzing XQuery expressions at first. And on traversing AST proper SQLs are generated. Translated SQLs can reduce the number of joins by using path information and utilize dewey number to preserve document originated orderings among compoments in XML. In addition we propose the efficient algorithms of XPath and XQuery translation. And finally we show the implementation of our prototype system for the functional evaluations.

LiXQuery

XQuery is considered to become the standard query language for XML documents. However, the complete XQuery syntax and semantics seem too complicated for research and educational purposes. By defining a concise backwards compatible subset of XQuery with a complete formal description, we provide a practical foundation for XQuery research. We pay special attention to usability by supporting the most typical XQuery expressions.

A unified approach to structured and XML data modeling and manipulation

In this paper we propose an approach to defining logical database models, based on the instantiation of a general abstract model, and discuss its application to the management of mixed XML/relational data. Our abstract model is equipped with a parametric query algebra and relational-like algebraic equivalences, that do not have to be redefined when new models are generated. We present an instantiation of our model that unifies the main approaches to represent and manipulate relational and XML data, and in particular SQL, SQL/XML, XQuery, and Oracle’s XML Type. Additionally, our algebra can represent queries not expressible by other algebras taken from the literature. Among others, it can represent nested XQuery expressions with no constraints on nesting and on node constructors.

Efficiently supporting order in XML query processing

XML is an ordered data model and XQuery expressions return results that have a well-defined order. However, little work on how order is supported in XML query processing has been done to date. In this paper we study the issues related to handling order in the XML context, namely challenges imposed by the XML data model, the variety of order requirements of the XQuery language, and the need to maintain order in the presence of updates to the XML data. We propose an efficient solution that addresses all these issues. Our solution is based on a key encoding for XML nodes that serves as node identity and at the same time encodes order. We design rules for encoding order of processed XML nodes based on the XML algebraic query execution model and the node key encoding. These rules do not require any actual sorting for intermediate results during execution. Our approach enables efficient order-sensitive incremental view maintenance as it makes most XML algebra operators distributive with respect to bag union. We prove the correctness of our order encoding approach. Our approach is implemented and integrated with Rainbow, an XML data management system developed at WPI. We have tested the efficiency of our approach using queries that have different order requirements. We have also measured the relative cost of different components related to our order solution in different types of queries. In general the overhead of maintaining order in our approach is very small relative to the query processing time.

SilkRoute

XML is the "lingua franca" for data exchange between interenterprise applications. In this work, we describe SilkRoute, a framework for publishing relational data in XML. In SilkRoute, relational data is published in three steps: the relational tables are presented to the database administrator in a canonical XML view; the database administrator defines in the XQuery query language a public, virtual XML view over the canonical XML view; and an application formulates an XQuery query over the public view. SilkRoute composes the application query with the public-view query, translates the result into SQL, executes this on the relational engine, and assembles the resulting tuple streams into an XML document. This work makes some key contributions to XML query processing. First, it describes an algorithm that translates an XQuery expression into SQL. The translation depends on a query representation that separates the structure of the output XML document from the computation that produces the document's content. The second contribution addresses the optimization problem of how to decompose an XML view over a relational database into an optimal set of SQL queries. We define formally the optimization problem, describe the search space, and propose a greedy, cost-based optimization algorithm, which obtains its cost estimates from the relational engine. Experiments confirm that the algorithm produces queries that are nearly optimal.