scispace - formally typeset
Open AccessJournal Article

Performance Challenges in Object-Relational DBMSs.

Reads0
Chats0
TLDR
The purpose of this paper is to present the results of an initial study about storing and querying XML data, focusing on the use of relational database systems and on very simplistic schemes to store and query XML data.
Abstract
XML is rapidly becoming a popular data format. It can be expected that soon large volumes of XML data will exist. XML data is either produced manually (like html documents today), or it is generated by a new generation of software tools for the WWW and/or electronic data interchange (EDI). The purpose of this paper is to present the results of an initial study about storing and querying XML data. As a first step, this study was focussed on the use of relational database systems and on very simplistic schemes to store and query XML data. In other words, we would like to study how the simplest and most obvious approaches perform, before thinking about more sophisticated approaches. In general, numerous different options to store and query XML data exist. In addition to a relational database, XML data can be stored in a file system, an object-oriented database (e.g., Excelon), or a special-purpose (or semi-structured) system such as Lore (Stanford), Lotus Notes, or Tamino (Software AG). It is still unclear which of these options will ultimately find wide-spread acceptance. A file system could be used with very little effort to store XML data, but a file system would not provide any support for querying the XML data. Object-oriented database systems would allow to cluster XML elements and sub-elements; this feature might be useful for certain applications, but the current generation of object-oriented database systems is not mature enough to process complex queries on large databases. It is going to take even longer before special-purpose systems are mature. Even when using an RDBMS, there are many different ways to store XML data. One strategy is to ask the user or a system administrator in order to decide how XML elements are stored in relational tables. Such an approach is supported, e.g., by Oracle 8i. Another option is to infer from the DTDs of the XML documents how the XML elements should be mapped into tables; such an approach has been studied in [4]. Yet another option is to analyze the XML data and the expected query workload; such an approach has been devised, e.g., in [2]. In this work, we will only study very simple ad-hoc schemes; we think that such a study is necessary before adopting a more complex approach. The schemes that we analyze require no input by the user, they work in the absence of DTDs or if DTDs are meaningless, and they do not involve any analysis of the XML data. Due to their simplicity, the approaches we study will not show the best possible performance, but as we will see, some of them will show very good query performance in most situations. Also, there is no guarantee that any of the more sophisticated approaches known so far will perform better than our simple schemes; see [3] for some experimental results in this respect. Furthermore, the results of our study can be used as input for more sophisticated approaches.

read more

Content maybe subject to copyright    Report

Citations
More filters
Proceedings ArticleDOI

Holistic twig joins: optimal XML pattern matching

TL;DR: This paper proposes a novel holistic twig join algorithm, TwigStack, that uses a chain of linked stacks to compactly represent partial results to root-to-leaf query paths, which are then composed to obtain matches for the twig pattern.
Proceedings ArticleDOI

Structural joins: a primitive for efficient XML query pattern matching

TL;DR: It is shown that, in some cases, tree-merge algorithms can have performance comparable to stack-tree algorithms, in many cases they are considerably worse, and this behavior is explained by analytical results that demonstrate that, on sorted inputs, the stack- tree algorithms have worst-case I/O and CPU complexities linear in the sum of the sizes of inputs and output, while the tree-MERge algorithms do not have the same guarantee.
Proceedings ArticleDOI

On supporting containment queries in relational database management systems

TL;DR: The results suggest that contrary to most expectations, with some modifications, a native implementations in an RDBMS can support this class of query much more efficiently.
Book ChapterDOI

XMark: a benchmark for XML data management

TL;DR: This work provides a framework to assess the abilities of an XML database to cope with a broad range of different query types typically encountered in real-world scenarios and offers a set of queries where each query is intended to challenge a particular aspect of the query processor.
Proceedings Article

Scalable semantic web data management using vertical partitioning

TL;DR: The results show that a vertical partitioned schema achieves similar performance to the property table technique while being much simpler to design, and if a column-oriented DBMS is used instead of a row-oriented database, another order of magnitude performance improvement is observed, with query times dropping from minutes to several seconds.
References
More filters
Proceedings Article

Relational Databases for Querying XML Documents: Limitations and Opportunities

TL;DR: It turns out that the relational approach can handle most (but not all) of the semantics of semi-structured queries over XML data, but is likely to be effective only in some cases.
Journal ArticleDOI

Storing semistructured data with STORED

TL;DR: It is shown how a document-type-descriptor (DTD), when present, can be exploited to further improve performance and is interested in applying STORED to XML data, which is an instance of semistructured data.

A Performance Evaluation of Alternative Mapping Schemes for Storing XML Data in a Relational Database

TL;DR: This paper studies how XML data can be stored and queried using a standard relational database system and presents alternative mapping schemes to store XML data in a relational database and discusses how XML-QL queries can be translated into SQL queries for every mapping scheme.
Proceedings ArticleDOI

Flattening an object algebra to provide performance

TL;DR: It is shown how flattening enabled us to implement a query algebra, using only a very limited set of simple operations, and was evaluated on the 1-GByte TPC-D (Transaction-processing Performance Council's Benchmark D), showing that the divide-and-conquer approach yields excellent results.
Related Papers (5)