Search

With the rapid development of computer technology, the barriers of communication among different systems caused by system heterogeneity or data structure have been broken down. However, the demands for personalized content for accuracy in resource exchange and delivery are becoming increasingly high. The structures of existing literature resources like papers, patents and books, with different formats and structures, leading to lots of problems in content delivery and inheritance. Thus, based on the XML technology, we design and develop the data exchange system. This system supports the mapping and integration of different structures of literature resource, and parsing resources at the same time, so that users can upload and verify the XML schema files according to their individual demands for data exchange.

The introduction of data semantics in various fields of science by referring to the ontological database is becoming more and more necessary. With the proliferation of domain ontologies and the large volume of data to be processed, it has become necessary to have data management systems based on ontological systems. Such a system can be exploited via the web as is the case with XML databases, which will allow us to: - use semantic databases via the Internet. - To enrich responses to XML queries by using domain terminology ontology. Also, XML present a flexible hierarchical model suitable to represent huge amounts of data with no absolute and fixed schema, In order to highlight the usefulness of introducing the semantics in the XML database and to enrich the answers to the queries, we have proposed a semi-automatic solution that we applied it for pharmaceutical databases, and which gave very encouraging preliminary results.

Database outsourcing has gained significance like the "Application-as-a-Service" model wherein a third party provider has not trusted. The problems related to security and privacy of outsourced XML data are data confidentiality, user privacy/data privacy and finally query assurance. Existing techniques of query assurance involve properties of certain cryptographic primitives in static scenarios. A novel dynamic index structure is called Merkle Hash and B+- Tree. The combination of B+- Tree and Merkle Hash Tree advantages has been proposed in this paper for dynamic outsourced XML databases. The query assurances having the issues are correctness query Completeness and Freshness for the stored XML Database. In addition, the outsourced XML database with integrity verification has been shown to be more efficient and supports updates in cloud paradigms.

XML is widely used to store and share information over the World Wide Web. A labeling scheme is required to efficiently store, process and query an XML document in data management systems. XML documents are assumed as XML trees then a labeling scheme is applied to uniquely identify the XML nodes effectively through the labels. Efficiency of a labeling scheme is measured based on the memory space required to store the labels and the time taken for labeling the XML nodes. Also, labels should preserve the structural relationship present between the nodes of an XML document to answer structural queries. Secure XML labeling schemes are exclusively used for secure content dissemination in publish/subscribe systems. Along with the basic properties of a labeling scheme, a secure labeling scheme should prevent structural information leakage exists in labels. In this paper, we present the recently available secure XML labeling schemes with the fundamental labeling schemes. Additionally, we also analyze the labeling schemes efficiency based on memory space, labeling time and the structural relationships they support.

The characteristics of XML (eXtensible Markup Language) documents have favored the need to develop specific and flexible querying systems while taking into account the coexistence of both structural and content information. The ultimate goal of these systems is to respond to different user expectations which tend to return appropriate answers to their preferences. However, people have often insufficient knowledge about XML data structure and contents, thus frequently obtaining empty answers or having to reformulate the queries several times. To solve this problem, we propose an ontology-based query refinement model for semi-structured information retrieval. It consists in reformulating a query by adding attributes from domain ontologies extracted from XML schemas.

Controlling access to the XML data warehouse without affecting the performances of the decision-support queries, allows protecting its XML data against unauthorized access, and helps to a good decision making leading to the growth of the company. In this paper, we propose to secure the XML documents of the warehouse at a fine level without deteriorating its performances. To achieve this, we implement independently of the XML data warehouse, a role based access control system by exploiting both the policy language, and the architecture of the XACML standard.

The aim of this paper is to present a solution to automatically generate an XML schema from an existing relational database (RDB). The important goal of this translation is to enriching the source schema using semantics that might have not been clearly expressed in it, by acquiring as much information as possible about objects and relationships that exist among them. The next step is to produce an enhanced meta data model, which captures essential characteristics of target XML schema, and is suitable for translation. In details, we present translations of all constructs of an RDB into an XML Schema and integrated these into an algorithm. This process is to simplify exchange of data between different databases, practically the import of data of RDBs into XML documents. A prototype has been developed to realize the algorithm and generate target schema. To validate our proposal, we present experimental results using both schemas. The results show that the proposed algorithm is correct.

The Extensible Markup Language (XML) has become a widely adopted data interchange format. With the rise of Linked Data published using the Resource Description Framework (RDF), a number of tools for transforming XML to RDF have been developed. Specifying XML→RDF mappings for these tools often requires skills in programming languages such as XSLT or XQuery. Moreover, these tools are rarely able to deal with large XML inputs. We introduce an XML to RDF transformation approach, which is based on mappings comprising RDF triple templates that employ simple XPath expressions. Thanks to the restricted XPath expressions, which can be evaluated against a stream of XML data, our implementation can handle extremely large input XML files. To process the XML input efficiently, we employ XML filtering techniques and a strategy for selecting relevant XML nodes to generate RDF triples from. We show that the time complexity of our mapping algorithm is linear in the size of the XML input and also prove its practical efficiency with an evaluation on large real-world data.

Constraints are very important part of every database management system (DBMS). There are different taxonomies of constraints in every data model. In this paper we propose a constraint taxonomy for XML data model. One of the constraints that exists in the database design practice is the inverse referential integrity constraint (IRIC). In relational database management systems (RDBMSs) there are techniques for implementation of this type of constraint. Those techniques are procedures and/or triggers. Current XML database management systems (XML DBMSs) support constraints like key, foreign key and unique constraints. IRIC is not implemented in current XML DBMSs. In this paper we also present an approach to the specification of the inverse referential integrity constraint and its implementation for the XML DBMS in the two techniques: XQuery functions and triggers. Those techniques correspond to the characteristics of a selected XML DBMS. The former can be used in those XML DBMSs which do not support triggers, such as eXist DBMS. The latter can be used in XML DBMSs which support triggers, such as Sedna.

Currently there exists a number of tools for generating synthetic XML data. But in this paper we approach this problem from a completely new direction. We propose a generator which enables to generate synthetic XML data with regards to a given set of XML queries expressed in XPath. Thus we enable versatility of the output, its applicability for a particular situation, and, at the same time, simplicity of input parameters. We have implemented a prototype of the generator, further optimized its performance, and experimentally demonstrated its properties.

The flexibility of XML allows document to be annotated easily. However, these annotations come from different sources like Wordnet thesaurus, POS, DTD, semantic roles etc. These annotations can either be combined in the same document or captured separately in different document. The former, though richer in annotations, may look messy and requires more parsing time. The latter needs control of document consistency. This paper proposes a string-trees model to represent XML document for multiple sources of annotations. This model extends the existing string-tree structure for linguistic content in order to support structured contents of XML document. In this paper, we describe how this model is refined and applied on XML document.

Faceted search for XML data is one of the promising exploration methods with high usability to find desired subtrees from a given XML data. This paper proposes improved approach of faceted search over XML data by utilizing facets containing unique and longer textual values, like titles of papers in bibliographic database. Our approach is to extract suitable terms which categorize the current results into several groups. Also we propose a task designing method for evaluating exploratory search by defining specificity of tasks called specification level, and we introduce how to generate tasks with given specification level as well. With this task design, we evaluate our proposed approach and the results show our proposed approach improves search performance comparing with the previous approaches, especially when tasks have low specification levels.

XML Schema standards often undergo several revisions to fit application requirements and business demands. In order to be successful, the development process of such standards must be collaborative allowing multiple users to work on the same schema. In this editing environment, the ability to merge branched versions of the schema is significant in certain situations. Using conventional three-way XML merging tools is not suitable for the purpose of merging XML Schema because the tree model of XML Schema is different from that of XML document. This paper deals with an essential activity enabling automatic XML Schema merging and conflict resolution based on the model of XML Schemas. We present rules for XSD merging and conflict handling, and describe how this can be achieved by combining three-way and operational-transformation approaches. Developing a prototype of our approach, we test it against a set of XSDs. Experimental results (compared to other three-way merge tools, including, 3DM and DeltaXML) show that our approach produces merged versions of high quality and reports more meaningful conflicts with respect to schema changes.

Generating system inputs satisfying complex constraints is still a challenge for modern test generators. We present XMLMATE, a search-based test generator specially aimed at XML-based systems. XMLMATE leverages program structure, existing XML schemas, and XML inputs to generate, mutate, recombine, and evolve valid XML inputs. Over a set of seven XML-based systems, XMLMATE detected 31 new unique failures in production code, all triggered by system inputs and thus true alarms.

XML is a widespread, text-based format used for exchanging information on the Web and representing metadata. Since the amount of XML information is rapidly increasing, efficient querying of large data repositories, containing XML data, is a significant challenge faced by system designers and data analysts who need to support operational actions and decision-making. In this paper we propose a technique for integrating large amount of XML data and use the Map-Reduce framework to efficiently query the integrated data. Each XML document obtained from the sources is transformed properly in order to fit into a predefined, virtual XML structure. Although the transformed documents are not physically integrated, the user is able to pose queries over a single XML structure. To achieve this feature we propose a single-step, Map-Reduce algorithm which takes advantage of virtual structure and computes efficiently the answer of a given XPath queries in a distributed manner.

A domain-specific language (DSL) is designed for a certain problem domain. Its notation is tailored to the relevant concepts and features of that domain. In this paper, we present a basis for a DSL for XML security standards. In particular, we focus on three prominent examples, i.e. XML Signature, XML Encryption, and SAML that are integrated into a common DSL. The main goals of our DSL are to make it easily comprehensible for security domain experts, easily applicable for people being familiar with at least one GPL, and easily extensible for further XML standards.

Data exchange has been one of the most popular topics in the database community for the past several years. Data exchange is essential for transferring, unifying and querying heterogeneous data -- tasks which very often arise in practice. Although the field is quite well-established and the theoretical foundations are clear for relational and XML data exchange, there are still some open problems motivated by both theory and practice. In this proposal we show one example of a data exchange problem which is not captured by the conventional data exchange setting for XML. In this example the central objective in the process of data exchange is to preserve the document order. This kind of data exchange setting we call document-centric data exchange. With introducing a new formalism to capture such a data exchange scenario, new solutions for common data exchange related problems are needed.

Studying structural similarity between XML documents are important for many tasks like XML data classification and XML document management. In this paper, we formally introduce the edit distance between trees and tree grammars using tree alignments. A sketch of the proof for the correctness of the algorithm is presented followed by the analysis of the efficiency of the algorithm. Experiments are conducted to show the time efficiency and validness of the distance in the context of XML document clustering.

Applications are increasingly using XML to represent semi-structured data and, consequently, a large amount of XML documents is available worldwide. As XML documents evolve over time, comparing XML documents to understand their evolution becomes fundamental. The main focus of existing research for comparing XML documents resides in identifying syntactic changes. However, a deeper notion of the change meaning is usually desired. This paper presents an inference-based XML evolution approach using Prolog to deal with this problem. Differently from existing XML diff approaches, our approach composes multiple syntactic changes, which usually have a common purpose, to infer semantic changes. We evaluated our approach through ten versions of an employment XML document. In this evaluation, we could observe that each new version introduced syntactic changes that could be summarized into semantic changes.

XML has achieved the leading role among languages for data representation and, thus, the amount of related technologies and applications exploiting them grows fast. However, only a small percentage of applications is static and remains unchanged since its first deployment. Most of the applications change with newly coming user requirements and changing environment. In this paper we describe a framework and a methodology for management of evolution and change propagation throughout XML applications. We also introduce its proof-of-concept implementation called eXolutio, which has been developed and improved in our research group during last few years. We also provide an evaluation of the methodology in the domain of electronic health.

In the last decade XML became a ubiquitous standard for representation of data. Despite the significant research efforts invested in the efficient processing techniques of XML documents we still need the operators of XML algebra specifically optimized for online processing of XML data. Online processing means that operators act on theoretically infinite sequences of XML documents and they never "see" an entire set of data. Most of XML algebras proposed so far are too resource expensive for online processing of XML documents. This paper proposes a new system of XML operators based on a formal model of extended tree grammars. We define a minimal set of basic operators and we show how the other operators can be derived from the basic ones. Our system of operators allows for processing of XML documents to any possible depth. The system eliminates the limitations of the previous approaches to online processing XML documents by allowing each operator be computed in the incremental and/or decremental way. The paper compares the functionality of the new system of operators with a number of XML algebras defined earlier.

XML SCHEMA is a standard defined by W3C widely used in the specification of XML elements. Another standard by W3C is XML Linking Language (XLink), a language that specifies how elements should be declared in XML documents in order to define links between two or more resources. XLink and XML Schema are emerging Internet standards applied in varying contexts such as XBRL Language. Similarity evaluation is an important process in data management and serves as support for one of its core activity: duplicate detection. Thus, the classification of XML elements according to the similarity between them is becoming increasingly useful in the area of XML data management. This paper presents a process for similarity evaluation between XML elements defined with the use of XML Schema and XLink and an experiment. The experiment applies the proposed process to the context of the XBRL concepts, an example of XML elements created with extensive use of XML Schema and XLink.

Version control systems provide a methodology for maintaining changes to a document over its lifetime and provide better management and control of evolving document collections, such as source code for large software systems. However, no version control system supports similar functionalities for office documents. Version Aware XML documents integrate full versioning functionality into an XML document type, using XML namespaces to avoid document type errors. Version aware XML documents contain a preamble with versions stored in reverse delta format, plus unique ID attributes attached to the nodes of the documents. They support the full branching and merging functionalities familiar to software engineers, in contrast to the constrained versioning models typical of Office applications. LibreOffice is an open source office document suite which is widely used for document creation. Each document is represented in the Open Office Document Format, which is a collection of XML files. The current project is an endeavor to show the practicality of the version aware XML documents approach by modifying the LibreOffice document suite to support version awareness. We are modifying LibreOffice to accept and preserve both the preamble and the IDs of the version aware framework. Initially, other functionality will be provided by wrapper applications and independent tools, but full integration into the LibreOffice user interface is envisioned.

In very large XML documents or collections, the query response times are not always satisfactory. To overcome this limitation, parallel processing can be applied. Data can be replicated in several processors and queries can be partitioned to run over different virtual data partitions on each processor, on an approach called virtual partitioning. PartiX-VP is a simple XML virtual partitioning approach that generates virtual data partitions by dividing the cardinality of the partitioning attribute by the number of allocated processors, resulting in intervals of equal size for each processor. In this approach, the XML query is rewritten and selection predicates are added to define the virtual partitions. These selection predicates use the position() XPath function that addresses a set of elements on a given position in the document. In this paper, we present an experimental evaluation of the position() XPath function in five XML native DBMS. We have identified differences in the processing time of the position() XPath function in large collections of XML documents. This may lead to load unbalancing in simple virtual partitioning approaches, thus this analysis opens space for improvements in virtual partitioning.

Over the years, XML has become a prominent standard for data exchange on the Web. Although XML can support syntactic inter-operability, problems arise when data sources represented as XML documents are needed to be integrated. The reason is that XML does not support sharing of concepts. This issues can be overcome by having suitable ontology representations of XML documents. The Semantic Web languages can play an important role here as they support ontology representation. Topic Map is a Semantic Web formalism (an ISO standard) for knowledge representation and interchange with an emphasis on navigation and retrieval of information. In this work we propose a framework for automatically generating Topic Map ontology from XML. We make use of XQuery and Tolog to validate our method. We illustrate our technique on examples. We also provide performance measures of our approach on some standard data sets.

In the information retrieval (IR) domain a collection of documents is represented as a set of documents where cross references between documents are usually not taken into account in the querying process. This standard document model is not tailored to legal professional uses where the context of interpretation is crucial. Existing access tools do not take into account the complexity of references between legal documents. XML based standards have been created to facilitate access and management of legal data. Their exploitation for IR purposes offers new possibilities for advanced search techniques. In this work, we propose a novel approach allowing to exploit the XML standard formats of legal documents to query a collection of related documents and return relevant answers to the end-user. We consider exploiting at the same time the semantic content of the documents and their interrelationships using Formal and Relational Concept Analysis. Answers are presented as documents or graphs of interlinked documents.

Outsourcing XML documents is a challenging task, because it encrypts the documents, while still requiring efficient query processing. Past approaches on this topic either leak structural information or fail to support searching that has constraints on XML node content. In addition, they adopt a filtering-and-refining framework, which requires the users to prune false positives from the query results. To address these problems, we present a solution for efficient evaluation of tree pattern queries (TPQs) on encrypted XML documents. We create a domain hierarchy, such that each XML document can be embedded in it. By assigning each node in the hierarchy a position, we create for each document a vector, which encodes both the structural and textual information about the document. Similarly, a vector is created also for a TPQ. Then, the matching between a TPQ and a document is reduced to calculating the distance between their vectors. For the sake of privacy, such vectors are encrypted before being outsourced. To improve the matching efficiency, we use a k-d tree to partition the vectors into non-overlapping subsets, such that non-matchable documents are pruned as early as possible. The extensive evaluation shows that our solution is efficient and scalable to large dataset.

XML is used to store and exchange data not only in the web and has advantages like self-describing content. Sensor nodes have limited hardware resources such that processing verbose data formats like XML is hard or even impossible if no intelligent techniques are used. This paper proposes such an intelligent technique for compression of XML data and query reformulation with the goal of eliminating superfluous computations already at compile time for programs with embedded XML data and queries. An experimental analysis shows the superior performance of the proposed approach when applied in sensor networks as well as on typical PC hardware.

An XML document is usually stored with its schema so that the structural consistency of the document is ensured. In general, schemas are continuously updated according to changes in real world. Thus, we have to precisely know how a schema is updated to keep the validity of the XML documents. In order to know how a schema is updated, we need to extract the difference between "old" and "new" schemas. However, schemas are recently becoming larger and more complex, thus it becomes more difficult to know how a schema is updated. In this paper, we consider the problem of extracting the difference between regular tree grammars, a popular formal model of XML schema languages. We first show that the problem is NP-hard. Then we give a sufficient condition under which the problem can be solved efficiently, and present a polynomial-time algorithm for solving the problem under the sufficient condition. Finally, we show some experimental results.

A great deal of research into the learning of schemas from XML data has been conducted in recent years to enable the automatic discovery of XML schemas from XML documents when no schema or only a low-quality one is available. Unfortunately, and in strong contrast to, for instance, the relational model, the automatic discovery of even the simplest of XML constraints, namely XML keys, has been left largely unexplored in this context. A major obstacle here is the unavailability of a theory on reasoning about XML keys in the presence of XML schemas, which is needed to validate the quality of candidate keys. The present article embarks on a fundamental study of such a theory and classifies the complexity of several crucial properties concerning XML keys in the presence of an XSD, like, for instance, testing for consistency, boundedness, satisfiability, universality, and equivalence. Of independent interest, novel results are obtained related to cardinality estimation of XPath result sets. A mining algorithm is then developed within the framework of levelwise search. The algorithm leverages known discovery algorithms for functional dependencies in the relational model, but incorporates the properties mentioned before to assess and refine the quality of derived keys. An experimental study on an extensive body of real-world XML data evaluating the effectiveness of the proposed algorithm is provided. The computational resources and services used in this work were provided by the VSC (Flemish Supercomputer Center), funded by the Research Foundation - Flanders (FWO) and the Flemish Government – department EWI. The authors acknowledge the financial support of the Fondecyt grant no. 1131049, FP7-ICT-233599, FWO G082109, and ERC grant agreement DIADEM, no. 246858.

Recognising textual structures (paragraphs, sections, etc.) provides abstract and more general mechanisms for describing documents independent of the particular semantics of specific markup schemas, tools and presentation stylesheets. In this paper we propose an algorithm that allows us to identify the structural role of each element in a set of homogeneous scientific articles stored as XML files.

Purpose – This paper considers schemaless XML data stored in a column-oriented storage, particularly in C-store. Axes of the XPath language are studied and a design and analysis of algorithms for processing the XPath fragment XP{*, //, /} are described in detail. The paper aims to discuss these issues. Design/methodology/approach – A two-level model of C-store based on XML-enabled relational databases is supposed. The axes of XPath language in this environment have been studied by Cástková and Pokorný. The associated algorithms have been used for the implementation of the XPath fragment XP{*, //, /}. Findings – The main advantage of this approach is algorithms implementing axes evaluations that are mostly of logarithmic complexity in n, where n is the number of nodes of XML tree associated with an XML document. A low-level memory system enables the estimation of the number of two abstract operations providing an interface to an external memory. The algorithms developed are mostly of logarithmic complexity in n, where n is the number of nodes of XML tree associated with an XML document. Originality/value – The paper extends the approach of querying XML data stored in a column-oriented storage to the XPath fragment using only child and descendant axes and estimates the complexity of evaluating its queries.

very few research works have been done on XML security over relational databases despite that XML became the de facto standard for the data representation and exchange on the internet and a lot of XML documents are stored in RDBMS. In [14], the author proposed an access control model for schema-based storage of XML documents in relational storage and translating XML access control rules to relational access control rules. However, the proposed algorithms had performance drawbacks. In this paper, we will use the same access control model of [14] and try to overcome the drawbacks of [14] by proposing an efficient technique to store the XML access control rules in a relational storage of XML DTD. The mapping of the XML DTD to relational schema is proposed in [7]. We also propose an algorithm to translate XPath queries to SQL queries based on the mapping algorithm in [7].

One of main research areas concerning XML documents is how to store them. Researchers usually suggest the use of relational databases for this task. However, object-relational databases with their extended data model are better for this purpose, because the "flat" relational model is not ideal for mapping of hierarchic structure of XML. Several papers have been published, which describe how structures and constraints of XML documents can be mapped to object-relational databases (ORDBs). However, their results cannot be applied in practice, because the available technology is usually not aware of object-oriented concepts, which are used. In this paper we propose mapping rules that are practicable for existing ORDBMSs in general. Specifically, we analyze object-oriented concepts implemented in an existing ORDBMS (DB2) and show how XML Schema parts can be mapped to them. We also perform a case study to illustrate mappings according to our rules. Although the paper discusses the use of XML Schema instances as metadata, existing DTD instances can also be used, because they can be easily transformed to corresponding XML Schema documents. To our knowledge this is the first such proposition for the database system mentioned above.

We propose a principled method to specify XML document transformation so that the outcome of a transformation can be ensured to conform to certain structural constraints as required by the target XML document type. We view XML document types as graphs, and model transformations as relations between the two graphs. Starting from this abstraction, we use and extend graph homomorphism as a formalism for the specifications of transformations between XML document types. A specification can then be checked to ensure whether results from the transformation will always be structure-conforming.

XML is among the preferred formats for storing the structure of documents such as scientific articles, manuals, documentation, literary works, etc. Sometimes publishers adopt established and well-known vocabularies such as DocBook and TEI, other times they create partially or entirely new ones that better deal with the particular requirements of their documents. The (explicit and implicit) requirements of use in these vocabularies often follow well-established patterns, creating meta-structures (the block, the container, the inline element, etc.) that persist across vocabularies and authors and that describe a truer and more general conceptualization of the documents' building blocks. Addressing such meta-structures not only gives a better insight of what documents really are composed of, but provides abstract and more general mechanisms to work on documents regardless of the availability of specific schemas, tools and presentation stylesheets. In this paper we introduce a schemaindependent theory based on eleven structural patterns. We provide a definition of such patterns and how they synthesize characteristics emerging from real markup documents. Additionally, we propose an algorithm that allows us to identify the pattern of each element in a set of homogeneous markup documents.

XML has become an industry standard for data representation and exchange of voluminous data among heterogeneous sources in a distributed environment. There are many ways to query a XML database. Some of the commonly used query languages are Xpath, Xquery, etc. In order to query a XML database, the users should have a proper knowledge of the XML database structure as well as the syntax of the query language that is used. If the users have only partial knowledge of the XML database and are not aware of query languages, partial path query language which was introduced recently can be used. Partial path queries are a subclass of XPath queries. Three algorithms such as Index Path, Partial MJ and Partial Path Stack were implemented over an index streaming model in order to retrieve all path solutions for the partial path query. The storage space required for the index streaming model is large and also the process of evaluating the partial path query using the existing algorithms is complex. To overcome these problems, the PQUICX (Partial Path Pattern Queries over QUICX) algorithm is proposed in this paper. The proposed algorithm evaluates partial path queries over a compact XML storage structure, QUICX (Query and Update Support for Indexed and Compressed XML). Partial path queries are evaluated using the meta table of the QUICX. The possible path solutions are retrieved by the method of path and relationship (parent/child-ancestor/descendant) checking. Also users can retrieve values for the path solutions from the containers of the QUICX. PQUICX algorithm has proved to be efficient in terms of memory requirements and execution time of the query as well.

In this paper, we are interested in aggregated search in structured XML documents. We present a structured information retrieval model based on the Bayesian networks theory. Query-terms and terms-elements relations are modeled through probability. In this model, the user's query starts a propagation process to recover the XML elements. Thus, instead of retrieving a whole document or a list of disjoint elements that are likely to answer partially the query, we attempt to built a virtual document that aggregates a set of elements, that are relevant all together. We evaluated our approach using the INEX 2009 collection and presented some empirical results for evaluating the impact of the aggregation approach.

Testing and benchmarking of XML related algorithms, XML data processors and applications often require a set of XML documents and the corresponding XQueries that can be applied over the test set. Groups of real-world workloads or specialized benchmarking data like [7] are often used in such cases, but generating synthetic sets of XMLs and XQueries could provide more variety and value to tests. Generator described in this paper is developed for the purpose of testing of the enhanced XML indexing support in Microsoft SQL Server 2012 and unlike existing generators, it combines both XML document generation and corresponding XQueries generation, providing richer set of data. Structure of generated XML documents is specified using Data Guide (DG) [3], [5] which also describes cardinality of the nodes and data types. Generator provides controlled randomness of produced XML data and XQueries, greatly improving the overall test coverage.

Regular expressions can be found in a wide array of technology for data processing on the web. We are motivated by two such technologies: schema languages for XML and query languages for graph-structured or linked data. Our focus is on theoretical aspects of regular expressions in these contexts.

The amount of Web data stored in XML continues to increase as the XML technology is adopted by various fields. XML-enabled Web-based applications play an important role in efficient processing of the data stored in XML over the Web. Academic bibliography sources are stored in XML as well as in other data formats on the Web. However, the XML bibliography sources are missing the required XML tools for querying and retrieving fine-grained information. For instance, there is no bibliography portal which support searching publications based on author position or the number of pages to our best knowledge. In this poster paper, we present a prototype system which efficiently queries an online XML bibliography source through a middleware environment and supports fine-grained queries using XML technology.

General-purpose streaming systems support diverse application domains with powerful and user-defined stream operators. Most general-purpose streaming systems have their own, non-XML, internal data representation. However, streaming input is often either a sequence of small XML documents, or a scan of a huge document. Prior work on XML streaming focuses on filtering, not transforming, XML, and does not describe how to integrate with a general-purpose streaming system. This paper describes how to integrate an XML transformer with a streaming system by designing a specification syntax that is both consistent with the existing system and familiar to XML users. After type-checking the specification, we compile it to an efficient automaton driven by SAX events. Our approach extends the underlying streaming system with XML support without changing its core architecture, and the same technique could be used for other extensions beyond XML.

So far, many XML-RDB mapping methods have been proposed, but all of them deal only with either one-to-one or one-to-N mapping from XML elements to relational attributes, even though other mappings, such as N-to-one mapping, are possible. To extend the expressiveness, this paper proposes C-Mapping, which enables us to deal with N-to-one mapping as well as one-to-one and one-to-N mappings in XML-RDB mapping. C-Mapping takes functional and inclusion dependencies in XML data as input, and generates an XML view constructed over relational tables. An important feature of C-Mapping is that, since dependencies in XML data are captured and represented in XML-RDB mapping, we can make the best use of RDB's functionality to maintain the consistencies in the XML view. In addition, we show that C-Mapping is powerful enough to simulate a variety of mapping schemes proposed so far.

XML files are ideal for describing semi structured data. The advent of native XML databases has enhanced storage of a large number of XML files preserving the hierarchical format. The challenge is to serve and access XML data from geographically distributed native XML databases. In this paper, we discuss the modus operandi for insertion and querying of data in a location transparent manner in decentralised networks. We present the design for a cluster based architecture where query processingF is achieved using distributed hash tables. A bulk insertion method has been employed for insertion of XML data. The proposed design was implemented on eXist-db, a native XML database engine. Experiments were conducted and the effectiveness of the proposed design was evaluated.

In general, the design of XML schemas involves translating conceptual schemas into XML schemas which aim to be: (i) normalized schemas, and (ii) connected structures in order to achieve good performance on queries. However, these requirements address a trade-off because highly connected XML structures allow data redundancy, and normalized schemas generate disconnected XML structures. This paper describes a workload-based approach which balances this trade-off on translating conceptual schemas into XML structures. An experimental study on an XML database shows that our XML schemas provide high query performance on the relevant elements for the workload and, at the same time, low cost of data redundancy on elements that are not relevant for update operations.

In this paper, we propose a framework of faceted navigation over XML data. General faceted navigation schemes are used to browse objects (or records) containing multiple properties. However, because XML is semi-structured in nature, it is not straightforward to apply faceted navigation to XML data. Specifically, we need to cope with three major technical issues: 1) objects in XML data are not predetermined, 2) objects may have flexible and/or recursive structure, and 3) properties of an object need to be automatically detected and extracted. To these problems, in this paper, we formulate faceted navigation over XML data by giving definitions of class, property, object, and facet in XML data. We then formulate typical user interactions in faceted navigation as operations over aforementioned concepts (class, object, and facet). We also propose a framework based on these definitions and operations, and construct a prototype system based on the framework. Finally, we show experimental evaluations using the prototype system to show the effectiveness of our proposed scheme.

Content-based online collaborative platforms and office applications are widely used for collaborating and exchanging data, in particular in the form of XML-based electronic documents. Usually, a version control system is built-in in these applications to support collaboration and to properly manage document evolution. However, most version control models require error-prone and time-consuming manual management of conflicts and uncertainties, thus heavily affecting collaborative work. Since in collaborative contexts conflicts are of a more semantic nature, i.e., due to uncertainty on what is really true, we focus on a version control model that deals with uncertain data. We introduce an XML version control model to assess uncertainty in data and to automatically resolve conflicts. Office documents and those of content-based online collaborative platforms are described in XML. We give features and requirements of our targeted model by identifying important characteristics of versioning systems, in particular XML version control systems. As first results, we propose a version-space formalism for collaborative data and we put forward an uncertainty management approach by translating the problem in the framework of XML data integration.

Converting non-Semantic Web encoded information to ontology-based languages such as the Web Ontology Lan-guage (OWL) is an important knowledge acquisition chal-lenge. In many domains, a large amount of information is represented in eXtensible Markup Language (XML), which has driven the development of general-purpose tools for converting XML to OWL. These tools suffer from a variety of shortcomings, however, including a requirement for multi-stage mapping processes and limited mapping tech-niques. A general shortcoming is that the mapping methods are not OWL-centric and thus limit the complexity of the generated OWL ontologies. To address these shortcomings, we developed an OWL-based language that can transform XML documents to arbitrary OWL ontologies. The lan-guage is based on the Manchester OWL Syntax and ex-tends it with XPath queries to support references to XML documents. Our language provides a compact, user-friendly approach for converting XML to OWL.

While XML is nowadays adopted as the de facto standard for data exchange, historically, its predecessor SGML was invented for describing electronic documents, i.e., marked up text. Actually, today there are still large volumes of such XML texts. We consider simple transformations which can change the internal structure of documents, that is, the mark-up, and can filter out parts of the text but do not disrupt the ordering of the words. Specifically, we focus on XML transformations where the transformed document is a subsequence of the input document when ignoring mark-up. We call the latter text-preserving XML transformations. We characterize such transformations as copy- and rearrange-free transductions. Furthermore, we study the problem of deciding whether a given XML transducer is text-preserving over a given tree language. We consider top-down transducers as well as the abstraction of XSLT called DTL. We show that deciding whether a transformation is text-preserving over an unranked regular tree language is in PTime for top-down transducers, EXPTime-complete for DTL with XPath, and decidable for DTL with MSO patterns. Finally, we obtain that for every transducer in one of the above mentioned classes, the maximal subset of the input schema can be computed on which the transformation is text-preserving.

We demonstrate a system for querying probabilistic XML documents with simple XPath queries. A user chooses between a variety of query answering techniques, both exact and approximate, and observes the running behavior, pros, and cons, of each method, in terms of efficiency, precision of the result, and data model and query language supported.