XML is a widespread W3C standard used by several kinds of applications for data representation and exchange over the web. In the context of a system that provides semantic integration of heterogeneous XML sources, the same information at a semantic level may have different representations in XML. However, the syntax of an XML query depends on the structure of the specific XML source. Therefore, in order to obtain the same query result, one must write a specific query for each XML source. To deal with such problem, a much better solution is to state queries against a global conceptual schema and then translate them into an XML query against each specific data source. This paper presents CXPath (Conceptual XPath), a language for querying XML sources at the conceptual level, as well as a translation mechanism that converts a CXPath query to an XPath query against a specific XML source.

This work presents an OO software production method that defines a systematic process for conceptual modelling of web applications. The paper discusses a set of minimum primitives to capture the essentials of dynamic web applications and it discusses how to introduce them in a classical model-centered OO method that provides systematic code generation. Finally, the paper presents some ideas to extend this generation process for developing web solutions taking as an input these web enhanced conceptual schemas.

While the Internet has facilitated access to information sources, the task of scalable integration of these heterogeneous data sources remains a challenge. The adoption of the eXtensible Markup Language (XML) as the standard for data representation and exchange has led to an increasing number of XML data sources, both native and non-native. Recent integration work has mainly focused on developing matching techniques to find equivalent elements and attributes among the different XML sources. In this paper, we introduce a semantic approach to resolve structural conflicts in the integration of XML schemas. We employ a data model called the ORA-SS (Object-Relationship-Attribute Model for Semi-Structured Data) to capture the implicit semantics in an XML schema. We present a comprehensive algorithm to integrate XML schemas. Compared to existing methods, our algorithm adopts an n-nary integration strategy that takes into account the data semantics, importance of a source, and how the majority of the sources model their data when resolving structural conflicts such as attribute/object class conflict and ancestor-descendant conflict. Further, redundant object classes and transitive relationship sets are removed to obtain a more concise integrated schema.

The availability of large amounts of heterogeneous distributed web data necessitates the integration and querying of XML data from multiple XML sources for many reasons. For example, currently many government agencies in US such as IRS, INS, FBI, CIA are integrating their system to deal with new security threats, and these different departments uses legacy database systems including relational data, flat files, spreadsheets, and html pages, and simple text data. Similarly, there are many e-commerce companies, which sell similar products but represent data using different XML schemas. When any two such companies merge, or make an effort to service customers in cooperation, there is a need for a uniform schema integration methodology. In some applications like comparison-shopping, there is a need for an illusionary centralized homogeneous information system. Such systems need a uniform data representation and access platform, which is provided by XML. However, the XML schema and data are still heterogeneous and represent their constraints differently. To avoid the overhead of system integration and system specific data access mechanisms, applications should be provided with data in an integrated form. The idea is to use XML as an intermediate medium to achieve date integration from heterogeneous data resources. There are many efforts currently on generating views or representing data in only XML format, but internally stored in legacy databases. Using wrappers, applications can view the data in XML, instead of moving the data from their original format to XML. However, wrappers fail if the structure of the data is dynamically changed. Our approach is two phase; the integration of the local XML schemas into a global schema, and the integration of the resultant XML data produced in response to the queries to the local XML data sources. A global schema eliminates data model differences by integrating local schemas. The heterogeneous XML data sources need not be represented in an integrated fashion. This is because integrating the XML data and storing it in the new integrated schema occupies extra resources, and may result in duplication, and thus, creates the problems of multiple updates and data inconsistencies. For this reason, we present a dynamic mechanism, which can interface the different XML data and can present an integrated representation of the XML sources, rather than physically integration of data.

The need for managing large repositories of data coming from XML documents is increasing; in fact, XML is emerging as the standard format for documents exchanged over the internet. At University of Bergamo, recently we developed the ERX Data Management System, to study issues concerning the management of data coming from XML documents; its data model, called ERX (Entity Relationship for XML), being an extension of the classical ER model, allows to deal with concepts coming from XML documents at the conceptual level, and allows to reason about integration of data coming from different XML document classes. This paper focuses on the problem of automatically deriving Entity-Relationship Schemas (ERX Schemas) from DTDs (Document Type Definition). In fact, the derivation of such schemas from DTDs might be a hard work to do by hand, since real DTDs are very complex and large.

Much research has been devoted over the years to investigating and advancing the techniques and tools used by analysts when they model. As opposed to what academics, software providers and their resellers promote as should be happening, the aim of this research was to determine whether practitioners still embraced conceptual modelling seriously. In addition, what are the most popular techniques and tools used for conceptual modelling? What are the major purposes for which conceptual modelling is used? The study found that the top six most frequently used modelling techniques and methods were ER diagramming, data flow diagramming, systems flowcharting, workflow modelling, RAD, and UML. However, the primary contribution of this study was the identification of the factors that uniquely influence the continued-use decision of analysts, viz., communication (using diagrams) to/from stakeholders, internal knowledge (lack of) of techniques, user expectations management, understanding models integration into the business, and tool/software deficiencies.

An open challenge is to integrate XML and conceptual modeling in order to satisfy large-scale enterprise needs. Because enterprises typically have many data sources using different assumptions, formats, and schemas, all expressed in — or soon to be expressed in — XML, it is easy to become lost in an avalanche of XML detail. This creates an opportunity for the conceptual modeling community to provide improved abstractions to help manage this detail. We present a vision for Conceptual XML (C-XML) that builds on the established work of the conceptual modeling community over the last several decades to bring improved modeling capabilities to XML-based development. Building on a framework such as C-XML will enable better management of enterprise-scale data and more rapid development of enterprise applications.

XML is an effective universal data-interchange format, and XML Schema has become the preeminent mechanism for describing valid XML document structures. Generalization/specialization and its constraints are fundamental concepts in system modeling and design, but are difficult to express and enforce with XML Schema. This mismatch leads to unnecessary complexity and uncertainty in XML-based models. In this paper we describe how to translate various aspects of generalization/specialization from a conceptual model into XML Schema. We also explore what needs to be added to XML Schema to handle the other aspects of this fundamental modeling construct. If XML Schema were to include our proposed constructs, it would be fully capable of faithfully representing generalization/specialization, thus reducing the complexity of the XML models that rely on generalization/specialization.

The Extensible Markup Language (XML) is based on the concept of schema languages, which are used for validation of XML documents. In most cases, the metamodeling view of XML-based application is rather simple, with XML documents being instances of some schema, which in turn is based on some schema language. In this paper, a metaschema layering approach for XML is presented, which is demonstrated in the context of various application scenarios. This approach is based on two generalizations of the standard XML schema language usage scenario: (1) it is assumed that one or more schema languages are acceptable as foundations for an XML scenario, but these schema languages should be customized by restricting, extending, or combining them; (2) for applications requiring application-specific schema languages, these schema languages can be implemented by reusing existing schema languages, thus introducing an additional metaschema layer. Metaschema layering can be used in a variety of application areas, and this paper shows some possible applications and mentions some more possibilities. XML is increasingly entering the modeling domain, since it is gradually moving from an exchange format for structured data into the applications as their inherent model. XML modeling still is in its infancy, and the metaschema layering approach presented in this paper is one contribution how to leverage the most important of XML feature's, which is the reuse of existing concepts and implementations.

Today, XML is primarily regarded as a syntax for exchanging structured data, and therefore the question of how to develop well-designed XML models has not been studied extensively. As applications are increasingly penetrated by XML technologies, and because query and programming languages provide native XML support, it would be beneficial to use these features to work with well-designed XML models. In order to better focus on XML-oriented technologies in systems engineering and programming languages, an XML modeling language should be used, which is more focused on modeling and structure than typical XML schema languages. In this paper, we examine the current state of the art in XML schema languages and XML modeling, and present a list of requirements for a XML conceptual modeling language.

The goal of this article is to present an algorithm to simplify the automatic generation of descriptions of XML document structures. In particular we show how to obtain a DTD (document type definition) for data whose structure is described by a conceptual data model. An important objective of this translation is to preserve as much structural information from the conceptual schema as possible. This enables partial constraint checking by validating XML parsers and thus simplifies exchange of data between different databases, in particular the import of data in an XML document into another database schema. In detail we present translations of all constructs of an extended entity-relationship model to DTDs and integrate these into an algorithm. By basing the algorithm on conceptual schemas it is very general and may be customized for data in (object-)relational databases as well as data in databases of any other paradigm, e.g. native XML databases.

The need for managing large repositories of data coming from XML documents is increasing, in particular to support new EDI applications and information systems which provide e-commerce functionality. In fact, XML is emerging as the standard format for documents exchanged over the internet; then information systems will have to deal with XML documents, both incoming and outcoming. This is an exciting research area, because new technologies are arising, such as XSLT, but former and rather stable technologies, such as relational DBMSs, still have to play an important role. It is clear that novel information systems will integrate different technologies, but at the moment it is not clear how. This paper reports about our experience in developing the ERX Data Management System, a system devised to collect data coming from different XML data sources, and store them into a database in a way independent of the source format; its query language, named ERX-QL, is able to query the database and generate new XML documents. We developed the ERX Data Management System to explore the possibility of integrating three different basic technologies, Relational DBMS, Java and XSLT, under a unifying framework which makes the system interoperable w.r.t. the particular adopted technology (for example Relational vs Object-Oriented database technology); hence, this framework is based on an Entity-Relationship-like Data Model (ERX), which is not tied to any specific technical and/or commercial solution. The paper discusses the architecture of the ERX system, and the adopted technical solutions.

XML Schemas provide a generalization of Document Type Definitions for describing the validity of a set of XML documents. There is a growing number of applications that deal with XML documents in various respects. One area of programs is concerned with analyzing XML documents arriving, for example, over the internet. Another rapidly expanding area is best described by the term XML generators. XML generators usually are part of a WWW system, for example generators for XML documents serving as views of data bases. Although XML Schemas provide a concise means for describing the syntax of correct XML documents in a specific domain, XML generators usually treat the XML documents as unstructured strings or, in the context of the Document Object Model, as trees the nodes of which belong to an unspecific Element-interface. The syntactical correctness, i.e. the validity of the generated XML documents cannot be guaranteed at compile time but must be tested at runtime. This means that, in general, t here is no ultimate proof that an XML generator generates only valid documents according to an underlying XML schema. This paper addresses this problem by introducing a new distinct interface for each element defined within an XML schema. Each interface extends the Element-interface of the Document Object Model. This mechanism provides a generalization of a previous approach based on the weaker concept of Document Type Definitions presented by the authors.

The goal of this paper is to propose a method in which relational database system is used to process queries on semistructured data. The method uses a combination of relational and semistructured techniques to process XML documents. First, the document is entirely stored within the relational system. Next, an SQL query is evaluated over the relational data representing XML document. Finally, the resulting XML document is constructed which, in turn, can be represented in the standard way within relational database system (by means of an edge table). The proposed method is presented as the XML-SQL language. The language is described formally and by a number of examples. Some implementation solutions are described.

The location path language XPath is of particular importance for XML applications since it is a core component of many XML processing standards such as XSLT or XQuery. In this paper, based on axis symmetry of XPath, equivalences of XPath 1.0 location paths involving reverse axes, such as anc and prec, are established. These equivalences are used as rewriting rules in an algorithm for transforming location paths with reverse axes into equivalent reverse-axis-free ones. Location paths without reverse axes, as generated by the presented rewriting algorithm, enable efficient SAX-like streamed data processing of XPath.

Database systems are well-known for consistent storage, retrieval, and manipulation of data. At the same time, the Extensible Markup Language (XML) is generally accepted as data description language for both web-based information systems and electronic data interchange between different organizations. Since database systems form the backbone of essentially any information system, the integration of XML and database systems is a must. Data model heterogeneity and schema heterogeneity, however, makes this a challenging task, for example when mapping XML documents to relational database systems (RDBS). This paper focuses on data model heterogeneity and provides an in-depth comparison of concepts available in RDBS and XML schema specification languages, comprising XML DTD and XML Schema. Such an analysis provides the basis for developing appropriate middleware bridging the gap between XML and RDBS.

XML is rapidly becoming the standard method for sending information across the Internet. XML Schema, since its elevation to W3C Recommendation on the 2nd May 2001, is fast becoming the preferred means of describing structured XML data. However, until recently, there has been no effective means of graphically designing XML Schemas without exposing designers to low-level implementation issues. Bird, Goodchild and Halpin (2000) proposed a method to address this shortfall using the 'Object Role Modelling' conceptual language to generate XML Schemas. This paper seeks to build on this approach by defining a mapping between the Unified Modeling Language (UML) class diagrams and XML Schema using the traditional three level database design approach (ie. using conceptual, logical and physical design levels). In our approach, the conceptual level is represented using standard UML class notation, annotated with a few additional conceptual constraints, the logical level is represented in UML, using a set of UML stereotypes, and the XML Schema itself represents the physical level. The goal of this three level design methodology is to allow conceptual level UML class models to be automatically mapped into the logical level, while minimizing redundancy and maximizing connectivity.

With the advent of XML and its use as a database language, dependency and normal form theory has attracted novel research interest. Several approaches to build up a dependency and normal form theory for XML databases have been published, mainly concentrating on functional dependencies and keys. XML-like database structures can be modelled by rational trees using constructors for lists and disjoint unions. This involves restructuring rules on subattributes. The absence of redundancy can be characterised by the nested list normal form. If ordering is ignored, constructors for sets or multisets have to be employed. For these the theory can be extended using counter-free functional dependencies. Finally, for keys an important research question is which systems of subattributes permit Armstrong instances. While this gives just a glimpse of a starting promising theory, a research agenda for further research will be set up.

With the rise of the Web as the major platform for making data and services available for both, humans and applications, interorganizational workflows became a crucial issue. Several languages for the specification of interorganizational workflows have been already proposed, each of them having different origins and pursuing different goals for dealing with the unique characteristics of interorganizational workflows. This paper compares these proposals, trying to identify their strengths and shortcomings. As a pre-requisite, a framework of requirements is suggested which categorizes the major characteristics of specification languages for interorganizational workflows into different perspectives. For each of these perspectives, a set of functional requirements is proposed thereby emphasizing the difference to traditional intraorganizational workflows. On the basis of this framework, seven representative specification languages are surveyed and compared to each other.

XML is fast becoming the standard for information exchange on the WWW. As such, information expressed in XML will need to be integrated with existing information systems, which are mostly based on structured data models such as relational, object-oriented or object/relational data models. This paper shows how our previous framework for integrating heterogeneous structured data sources can also be used for integrating XML data sources with each other and/or with other structured data sources. Our framework allows constructs from multiple modelling languages to co-exist within the same intermediate schema, and allows automatic translation of data, queries and updates between semantically equivalent or overlapping heterogenous schemas.

Semistructured data has become prevalent with the growth of the Internet. The data is usually stored in a database system or in a specialized repository. Many information providers have presented their databases on the web as semistructured data, while others are developing repositories for new applications. Designing a “good” semistructured database is important to prevent data redundancy and updating anomalies. In this paper, we propose a conceptual approach to design semistructured databases. A conceptual layer based on the Entity-Relationship model is used to remove redundancies at the semantic level. An algorithm to map an ER diagram involving composite attributes weak entity types, recursive, n-ary and ISA relationship sets, and aggregations to a semistructured schema graph (S3-Graph) is also given.

The unique selling point of XML as standard representation of content is its ease of use thus facilitating interoperability between various partners and platforms. To overcome XML Schema's weakness concerning semantic expressiveness, tailored XML schema languages would be favorable to represent domain specific knowledge. The contribution of this paper is to identify various approaches to implementing tailored XML schema languages with XML Schema.

Web services are emerging as a promising technology for the effective automation of inter-organizational interactions. However, despite the growing interest, several issues still need to be addressed to provide Web services with benefits similar to what traditional middleware brings to intra-organizational application integration. In this paper, we present a framework that supports the model-driven development of Web services. Specifically, we show how, starting from the external specifications of a Web service (e.g., interface and protocol specifications), we can support the generation of extensible service implementation templates as well as of complete (executable) service specifications, thereby considerably simplifying the service development work.

In software engineering as well as in any engineering domain, a way of customizing the collaborative work to various modes of collaboration, i.e. synchronous and asynchronous, and the possibility of alternating these modes along the phases of a project is required. Our goal is to develop a universal information platform that can support collaboration in a range of application domains, the basic sharing unit being the document. Since not all user groups have the same conventions and not all tasks have the same requirements, this implies that it should be possible to customize the collaborative environment at the level of both communities and individual tasks. In this paper we present the consistency maintenance models underlying the synchronous and asynchronous modes of collaboration. We highlight the importance of choosing a general structured model of the document and particularly analyze the multi-mode collaboration for two main representative types of documents: textual and graphical.

The Extensible Markup Language (XML) has found acceptance as a standard for storing and exchanging structured and semi-structured data. With its expressive power, XML enables a great variety of applications relying on such structures. As the data schema, an XML schema is a means by which documents and objects can be structured. Our approach is to model XML schemata and thus classes of documents on the basis of UML (Unified Modeling Language). We consider UML to be the connecting link between software engineering and document design, i.e., it is possible to design object-oriented software together with the necessary XML structures. For this reason, we describe how to transform the static part of UML, i.e. class diagrams, into XML schemata. The major challenge for the transformation is to define a suitable mapping reflecting the semantics of a UML specification in an XML schema correctly. Because of XML's specific properties, we slightly extend UML in a UML compliant way. Additionally, the resulting XML schema profile supports the tuning of the transformation to XML schema. Our approach provides the stepping stone to bridge the gap between object-oriented software design and the development of XML data schemata.

The goal of automating information systems building was stated in the sixties. Forty years later it is clear that the goal has not been achieved in a satisfactory degree. One of the problems has been the lack of standards in languages and platforms. In this respect, the recent efforts on standardization provide an opportunity to revive the automation goal. This is the main purpose of this paper. We have named the goal "conceptual schema-centric development" (CSCD) in order to emphasize that the conceptual schema should be the center of the development of information systems. We show that to develop an information system it is necessary to define its conceptual schema and that, therefore, the CSCD approach does not place an extra burden on developers. In CSCD, conceptual schemas would be explicit, executable in the production environment and the basis for the system evolution. To achieve the CSCD goal it is necessary to solve many research problems. We identify and comment on a few problems that should be included in a research agenda for CSCD. Finally, we show that the CSCD goal can be qualified as a grand challenge for the information systems research community.

To cope with the ever increasing diversity of markup languages, programming languages, tool kits and interface development environments, conceptual modeling of user interfaces could bring a framework for specifying, designing, and developing user interfaces at a level of abstraction that is higher than the level where code is merely manipulated. For this purpose, a complete environment is presented based on conceptual modeling of user interfaces of information systems structured around three axes: the models that characterize a user interface from the end user's viewpoint and the specification language that allows designers to specify such interfaces, the method for developing interfaces in forward, reverse, and lateral engineering based on these models, and a suite of tools that support designers in applying the method based on the models. This environment is compatible with the Model-Driven Architecture recommendations in the sense that all models adhere to the principle of separation of concerns and are based on model transformation between the MDA levels. The models and the transformations of these models are all expressed in UsiXML (User Interface eXtensible Markup Language) and maintained in a model repository that can be accessed by the suite of tools. Thanks to this environment, it is possible to quickly develop and deploy a wide array of user interfaces for different computing platforms, for different interaction modalities, for different markup and programming languages, and for various contexts of use.

The eXtensible Markup Language (XML) is increasingly finding acceptance as a standard for storing and exchanging structured and semi-structured information. With its expressive power, XML enables a great variety of applications relying on such structures — notably product catalogs, digital libraries, and electronic data interchange (EDI). As the data schema, an XML Document Type Definition (DTD) is a means by which documents and objects can be structured. Currently, there is no suitable way to model DTDs conceptually. Our approach is to model DTDs and thus classes of documents on the basis of UML (Unified Modeling Language). We consider UML to be the connecting link between software engineering and document design, i.e., it is possible to design object-oriented software together with the necessary XML structures. For this reason, we describe how to transform the static part of UML, i.e. class diagrams, into XML DTDs. The major challenge for the transformation is to define a suitable mapping reflecting the semantics of a UML specification in a DTD correctly. Because of XML's specific properties, we slightly extend the UML language in a UML-compliant way. Our approach provides the stepping stone to bridge the gap between object-oriented software design and the development of XML data schemata.

XML is increasingly becoming the preferred method of encoding structured data for exchange over the Internet. XML-Schema, which is an emerging text-based schema definition language, promises to become the most popular method for describing these XML-documents. While text-based languages, such as XML-Schema, offer great advantages for data interchange on the Internet, graphical modelling languages are widely accepted as a more visually effective means of specifying and communicating data requirements for a human audience. With this in mind, this paper investigates the use of Object Role Modelling (ORM), a graphical, conceptual modelling technique, as a means for designing XML-Schemas. The primary benefit of using ORM is that it is much easier to get the model ‘correct' by designing it in ORM first, rather than in XML. To facilitate this process we describe an algorithm that enables an XML-Schema file to be automatically generated from an ORM conceptual data model. Our approach aims to reduce data redundancy and increase the connectivity of the resulting XML instances.

Most research on XML has so far largely neglected the data modeling aspects of XML schemas. In this paper, we attempt to make a systematic approach to data modeling capabilities of XML schemas. We first formalize a core set of features among a dozen competing XML schema language proposals and introduce a new notion of XGrammar. The benefits of such formal description is that it is both concise and precise. We then compare the features of XGrammar with those of the Entity-Relationship (ER) model. We especially focus on three data modeling capabilities of XGrammar: (a) the ability to represent ordered binary relationships, (b) the ability to represent a set of semantically equivalent but structurally different types as "one" type using the closure properties, and (c) the ability to represent recursive relationships.

XML is a common standard for semi-structured and structured data representation and exchange over the Web. This paper describes a semi-automatic process for converting an XML DTD to a schema in a canonical conceptual model based on ORM/NIAM and extended ER models. This process is part of a bottom-up approach for integration of XML sources that takes a set of DTDs and generates an ontology for query purposes. A conceptual schema for a DTD simplifies the integration activity because provides a semantically rich representation of an XML source. The core of the process is a set of conversion rules that consider the DTD structure and heuristics related to default semantic interpretations on such structure in order to generate the corresponding concepts in the canonical conceptual schema.

Many XML documents are being produced, but there are no agreed-upon standards formally defining what it means for complying XML documents to have “good” properties. In this paper we present a formal definition for a proposed canonical normal form for XML documents called XNF. XNF guarantees that complying XML documents have maximally compact connectivity while simultaneously guaranteeing that the data in complying XML documents cannot be redundant. Further, we present a conceptual-model-based methodology that automatically generates XNF-compliant DTDs and prove that the algorithms, which are part of the methodology, produce DTDs to ensure that all complying XML documents satisfy the properties of XNF.

Much research has focused on the problem of knowledge accessibility, sharing and reuse. Specific languages (e.g. KIF, CG, RDF) and ontologies have been proposed. Common characteristics, conventions or ontological distinctions are beginning to emerge. Since knowledge providers (humans and software agents) must follow common conventions for the knowledge to be widely accessed and re-used, we propose lexical, structural, semantic and ontological conventions based on various knowledge representation projects and our own research. These are minimal conventions that can be followed by most and cover the most common knowledge representation cases. However, agreement and refinements are still required. We also show that a notation can be both readable and expressive by quickly presenting two notations — Formalized English (FE) and Frame-CG (FCG) — that we have derived from CG and Frame-Logics. These notations support the above conventions, and are implemented in our Web-based knowledge representation and document indexation tool, WebKB.

XML has become the standard format for representing structured and semi-structured data on the Web. To describe the structure and content of XML data, several XML schema languages have been proposed. Although being very useful for validating XML documents, an XML schema is not suitable for tasks requiring knowledge about the semantics of the represented data. For such tasks it is better to use a conceptual schema. This paper presents an extension of the Entity Relationship (ER) model, called X-Entity, for conceptual modeling of XML schemas. We also present the process of converting a schema, defined in the XML Schema language, to an X-Entity schema. The conversion process is based on a set of rules that consider element declarations and type definitions and generates the corresponding conceptual elements. Such representation provides a cleaner description for XML schemas by focusing only on semantically relevant concepts. The X-Entity model has been used in the context of a Web data integration system with the goal of providing a concise and semantic description for local schemas defined in XML Schema.

The use of relational database management systems (RDBMSs) to store and query XML data has attracted considerable interest with a view to leveraging their powerful and reliable data management services. Due to the mismatch between the relational and XML data models, it is necessary to first shred and load the XML data into relational tables, and then translate XML queries over the original data into equivalent SQL queries over the mapped tables. Although there is a rich literature on XML-relational storage, none of the existing solutions addresses all the storage problems in a single framework. Works on mapping strategies often have little or no details about query translation, and proposals for query translation often target a specific mapping strategy. XML-storage solutions provided by RDBMS also have limitations. Notably, they are tied to a specific backend and use proprietary mapping languages, which not only may require a steep learning curve, but often are unable to express certain desirable mappings. In order to address these limitations, we developed ShreX, a XML-to-relational mapping framework and system that provides the first comprehensive and end-to-end solution to the relational storage of XML data. Mappings in ShreX are defined through annotations to an XML Schema. The use of XML Schema simplifies the mapping process, since it does not require users to master a new specialized mapping language. The use of annotations allows mapping choices to be combined in many different ways. As a result, ShreX not only supports all the mapping strategies proposed in the literature, but also new useful strategies that had not been considered previously. ShreX provides generic (and automatic) document shredding and query translation capabilities; and it is portable — its mapping specifications are independent of the database backend.

In XML retrieval, two distinct approaches have been established and pursued without much cross-fertilization taking place so far. On the one hand, native XML databases tailored to the semistructured data model have received considerable attention, and a wealth of index structures, join algorithms, tree encodings and query rewriting techniques for XML have been proposed. On the other hand, the question how to make XML fit the relational data model has been studied in great detail, giving rise to a multitude of storage schemes for XML in relational database systems (RDBSs). In this paper we examine how native XML indexing techniques can boost the retrieval of XML stored in an RDBS. We present the Relational CADG (RCADG), an adaptation of several native indexing approaches to the relational model, and show how it supports the evaluation of a clean formal language of conjunctive XML queries. Unlike relational storage schemes for XML, the RCADG largely preserves the underlying tree structure of the data in the RDBS, thus addressing several open problems known from the literature. Experiments show that the RCADG accelerates retrieval by up to two or even three orders of magnitude compared to both native and relational approaches.

In thi