Indexing XML Data Stored in a Relational Database

The Extensible Markup Language (XML) is emerging as the dominant data format for data exchange between applications. Many translation techniques have been devised to publish large amounts of existing conventional relational data in XML format. There also exists a need to be able to represent imprecise data in both relational databases and XML. This paper describes a fuzzy XML schema model for representing a fuzzy relational database in XML format. It also outlines a translation algorithm to include fuzzy relations and similarity matrices with their associated conventional relations. We also describe how the proposed fuzzy XML schema and the conversion process from fuzzy relational data into fuzzy XML have been integrated into VIREX, which is a prototype with powerful visual tool for transforming relational data into XML.KeywordsFuzzy XMLFuzzy Relational DatabaseSchema ConversionVisual Interface

In this paper, we propose a new structure-based approach, called Xregion, to store XML data in relational databases. Our approach first partitions an XML document into several disjoint regions according to the cardinality of element nodes, and then maps these regions into separate relations. Our experimental results demonstrate that the proposed approach dramatically improves the performance of queries on the XML data over the existing approaches.

The XML support in relational databases and the SQL/XML language are still relatively new as compared to purely relational databases and traditional SQL. Today, most database users have a strong relational and SQL background. SQL/XML enables users to perform queries and updates across XML and relational data, but many struggle with writing SQL/XML statements or XQuery update expressions. One reason is the novelty of SQL/XML and of the XQuery expressions that must be included. Another problem is that the tree structure of the XML data may be unknown or difficult to understand for the user. Evolving XML Schemas as well as hybrid XML/relational schemas make it even harder to write SQL/XML statements. Also, legacy applications use SQL but may require access to XML data without costly code changes. Motivated by these challenges, we developed a method to generate SQL/XML query and update statements automatically. The input is either a GUI or a regular SQL statement that uses logical data item names irrespective of their actual location in relational or XML columns in the database. The output is a SQL/XML statement that queries or updates relational and XML data as needed to carry out the original user statement. This relieves the user and simplifies schema evolution and integration. We have prototyped and tested the proposed method on top of DB2 9.5.

The XML data is a typical kind of tree-data. However, the XML research community has given little attention to the traditional Relational database Management System(RDBMS) based encoding schemes for tree-data. In this paper, we will investigate one of the traditional RDBMS-based encoding schemes, called Nested Interval, for storage and retrieval of XML data. Especially, our approach is very robust for updating XML data, including insertion of new nodes. In fact, the existing RDBMS-based XML storage and indexing techniques work very poorly against XML data updates because they should be rebuilt from the scratch when any update occurs in XML data. In contract, our scheme does not require re-encoding. In this respect, our approach is a viable option for storing and querying update-intensive XML applications.

An adaptive path index for XML data using the query workload

An XML data allocation method on disks

Almost all existing approaches use certain numbering scheme to encode XML elements to facilitate query processing when XML data is stored in databases. For example, under the most popular region-based numbering scheme, the starting and ending positions of an element in a document are used as the code to identify the element so that the ancestor/descendant relationship between two elements can be determined by merely examining their codes. While such numbering scheme can greatly improve query performance, renumbering large amount of elements caused by updates becomes a performance bottleneck if XML documents are frequently updated. Unfortunately, no satisfactory work has been reported for efficient update of XML data. In this paper, we first formalize the XML data update problem by defining the basic operators to support most XML update queries. We then present a new numbering scheme that not only requires minimal code-length in comparison with existing numbering schema but also improves update performance when XML data is frequently updated at arbitrary positions. The fundamental difference between our new scheme and existing ones is that, instead of maintaining the explicit codes for elements, we only store the necessary information and generate the codes when they are needed in query processing. In addition to present the basic scheme, we also discuss some optimization techniques to further reduce the update cost. Results of a comprehensive performance study are provided to show the advantages of the new scheme.

Data warehousing accounts for a significant fraction of database use today. As XML becomes ever more popular, more and more XML data finds its way into data warehouse repositories. This paper examines the modeling mismatch between the tree structure of XML data model and the multidimensional model of a typical data warehouse, and proposes an XML warehouse model based on the multi-colored trees (MCT) logical data model that resolves the modeling issue naturally. Furthermore, this data model ameliorates some well-known modeling limitations of the XML data warehouse. To cope with ad-hoc OLAP queries, we extend bit-map join indices to the XML context. We then tackle the difference between the bit-map and the stack-based structural join processing paradigm popular in XML query processing, permitting both styles of query processing to be used seamlessly in consort to evaluate queries. We demonstrate experimentally the benefit of bit-map join indices for typical queries, and particularly those with low cardinality or high selectivity.

XML data warehouses give decision-support systems a chance to use complicated data by giving them a place to start. But native-XML database management systems are slow right now, so it is important to look into ways to make them faster. This study presents two strategies to think about. To start, we suggest using a link index that was made with the fact that XML warehouses have a lot of dimensions in mind. The join procedures are taken out, but the data from the first warehouse stays the same. Second, we show how to choose XML materialized views by grouping the query load to show how this can be done. To prove that these ideas work, we built a set of decision support XQuery tools and ran them against an XML data warehouse. We compared the results obtained with and without our optimization methods. Our tests show that it works, even though the queries themselves are a little hard to understand and the datasets themselves are very big. XML has emerged as the widely accepted standard for transmitting data over mobile wireless networks. In these kinds of networks, mobile clients can use a wireless broadcast channel to send queries to get the XML data they need. Because mobile devices are so small and have so little storage space and a short battery life, it may be hard for customers to download the whole XML data set on one of these devices. To solve this problem, you need to index XML data so that mobile clients only have to download the parts of the file they need. Users who want to access only certain parts of the XML content in an XML stream could use one of several indexing methods. Still, the indexing methods that are used now add more data to an XML stream that is already very large. This research comes up with a new XML stream structure for broadcasting XML data by compressing and summarizing the information about how XML nodes are put together. This study was conducted in the United Kingdom. When data is summed up before being sent, the time it takes to get it in XML format over a wireless broadcast channel can be cut down. The recommended XML stream structure also has indexes that will help you skip over any data that is not important. So, it could make it less likely that XML query results will drain the batteries of mobile devices when they are being processed. We also found that our suggested XML stream design was better than its predecessors in terms of access and tuning times for processing XML queries over the XML data stream. So, our architecture can be used to answer a wide range of XML questions.

Due to the rapid growth of XML representation for information exchange, XML databases have been widely adopted in a variety of applications. This paper presents two layers of optimisation for dealing with large XML databases: (1) OXDP (Object-Based Methodology for XML Data Partitioning) which has been developed to partition XML data efficiently and (2) OXiP (Object-Based XML Indexing for Partitions) which is an indexing and linking mechanism for partitioned data. OXDP provides optimal XML data partitioning based on an object’s semantic features which improves XML data query performance. The OXiP method tokenises all rooted label paths and preserves the pathways within each XML object partition. The semanticbased data partition ultimately enhances the notion of a frequently accessed data subset which is an advantageous feature in our proposed methods to decrease the time to answer queries. Experimentally, OXDP and OXiP can achieve an order of magnitude performance improvement for querying XML data.

IBM® DB2® 9 is a truly hybrid commercial database system that combines XML and relational data. It provides native support for XML storage and indexing, and query evaluation support for XQuery. By building a hybrid system, the designers of DB2 9 were able to use the existing SQL query evaluation and optimization techniques to develop similar methods for XQuery. However, SQL and XQuery are sufficiently different that new optimization techniques can and are being developed in the new XQuery domain. This paper describes a few such techniques, all based on static rewrites of XQuery expressions.

Detecting changes in XML data has emerged as an important research issue in the last decade, but the majority of change detection algorithms focus on XML documents rather than on their schemas because documents that contain data are deemed more significant than the schema itself. However, the XML schema change detection tool is essential, especially in situations where we need to maintain related XML documents with evolving schema, sustain relational schema generated by schema-conscious approach for storing XML data and provide support for XML versioning. This paper focuses on XML Schema (XSD) changes and provides a more meaningful description of the detected changes. Our proposed algorithm XS-Diff uses the technique of storing XML Schema versions in a relational database where the detection and storage of delta changes are employed on relational tables. We demonstrate the correctness of the proposed algorithm through both synthetic and real data sets without deteriorating the execution time.

To implement a XML data warehouse system, a key issue is how to efficiently maintain materialized views, to preserve their consistency with data sources when base data changes. Self-maintenance of views has been shown to dramatically improve performance for view maintenance, and studied extensively in the context of the relational data model. But for XML database, there are still lots of work left to be done. In this paper, we give a preliminary result on self-maintainability of deletions of views over XML data. We give a necessary and sufficient condition of self-maintainability of deletions, and an algorithm to implement self-maintenance of deletions of views for XML data.

Traditionally, searching XML data with a structured query often identifies the exact matches for the query and returns them as the qualified results. However, the structural heterogeneity of the large number of XML data sources will make it difficult to answer the structured queries exactly. As such, query relaxation is necessary when the exact results do not exist or the number of the exact results is not enough. Previous work on XML query relaxation poses the problem of unnecessary computation of a big number of unqualified relaxed queries. This thesis addresses several fundamental issues in ranking a set of heterogeneous XML data sources, designing the adaptive relaxation rules and efficiently processing the relaxed queries over the data sources. Relaxing the specified queries may loose the constraints of the users' original preferences, which can increase the number of relevant results significantly. Therefore, in this work the users' queries would be answered with a ranked list of the best matched results, e.g., top-k problem means that only the top k relevant results are interesting to users. In addition, at each time we prefer to evaluate the relaxed queries over the data source that is the most relevant to the specified queries, and incrementally output the retrieved results that are guaranteed to have the higher relevance to the queries than the candidates in the other data sources, thus minimizing query processing time. However, query relaxation would become time-consuming and ineffective in some cases, such as the data structure is too complex for users to write structured queries, or the users do not know structured query languages. To address this problem, we allow users to issue keyword queries. Different from previous keyword search methods, we first construct structured query templates based on the given keyword query and the underlying source schemas and then evaluate the query templates to answer the original keyword query based on our proposed ranking model.

We study the complexity of two central XML processing problems. The first is XPath 1.0 query processing, which has been shown to be in PTIME in previous work. We prove that both the data complexity and the query complexity of XPath 1.0 fall into lower (highly parallelizable) complexity classes, while the combined complexity is PTIME-hard. Subsequently, we study the sources of this hardness and identify a large and practically important fragment of XPath 1.0 for which the combined complexity is LOGCFL-complete and, therefore, in the highly parallelizable complexity class NC 2 . The second problem is the complexity of validating XML documents against various typing schemes like Document Type Definitions (DTDs), XML Schema Definitions (XSDs), and tree automata, both with respect to data and to combined complexity. For data complexity, we prove that validation is in LOGSPACE and depends crucially on how XML data is represented. For the combined complexity, we show that the complexity ranges from LOGSPACE to LOGCFL, depending on the typing scheme.