XML Transformations Research Articles

Distributed Reactive XML

XML-centric models of computation have been proposed as an answer to the demand for interoperability, heterogeneity and openness in coordination models. We present a prototype implementation of an open XML-centric coordination middleware called Distributed Reactive XML. The middleware has as theoretical foundation a general distributed extensible process calculus inspired by the theory of Bigraphical Reactive Systems. The calculus is extensible just as XML is extensible, in that its signature and reaction rules are not fixed. It is distributed by allowing both the state of processes as well as the set of reaction rules to be distributed (or partly shared) between different clients. The calculus is implemented by representing process terms as XML documents stored in a value-oriented, peer-to-peer XML Store and reaction rules as XML transformations performed by the clients. The formalism does not require that only process terms are stored—inside process terms one may store application specific data as well. XML Store provides transparent sharing of process terms between all participating peers. Conflicts between concurrent reaction rules are handled by an optimistic concurrency control. The implementation thus provides an open XML-based coordination middleware with a formal foundation that encompasses both the shared data, processes and reaction rules.

Computing simple and complex matchings between XML schemas for transforming XML documents

This paper presents a schema matching method for the transformation of XML documents. The proposed method consists of two steps: computing preliminary matching relationships between leaf nodes in the two XML schemas based on proposed ontology and leaf node similarity, and extracting final matchings based on a proposed path similarity. Particularly, for a sophisticated schema matching, the proposed ontology is incrementally updated by users' feedback. Furthermore, since the ontology can describe various relationships between concepts, the proposed method can compute complex matchings as well as simple matchings. Experimental results with schemas used in various domains show that the proposed method performs better than previous methodologies, resulting in a precision of 97% and a recall of 83% on the average.

Implementing Metcast in Scheme

This paper describes the experience of implementing a core component of an operationally deployed large distributed system in Scheme. Metcast is a request-reply and subscription system for the dissemination of real-time weather information. The system stores vast amounts of weather observation reports, forecasts, gridded data produced by weather models, and satellite imagery. A Metcast server delivers a subset of these data in response to a query formulated in a domain-specific declarative language. Decoders of World Meteorological Organization's data feed, the Metcast application server, XML encoders and decoders, auxiliary and monitoring CGI scripts are all written in a mostly pure functional subset of Scheme. This paper describes three examples that demonstrate the benefits of our choice of the implementation language: parsing of the data feed; XML transformations and Web services; a modular interpreter for the extensible and expressive request language. We also discuss general-purpose extensions to Scheme developed in the project.

Type Checking with XML Schema in XACT

We show how to extend the program analysis technique used in the X<small>ACT</small> system to support XML Schema as type formalism. Moreover, we introduce optional type annotations to improve modularity of the type checking. The resulting system supports a flexible style of programming XML transformations and provides static guarantees of validity of the generated XML data.

The Design Space of Type Checkers for XML Transformation Languages

We survey work on statically type checking XML transformations, covering a wide range of notations and ambitions. The concept of <em>type</em> may vary from idealizations of DTD to full-blown XML Schema or even more expressive formalisms. The notion of <em>transformation</em> may vary from clean and simple transductions to domain-specific languages or integration of XML in general-purpose programming languages. Type annotations can be either explicit or implicit, and type checking ranges from exact decidability to pragmatic approximations.<br /> <br />We characterize and evaluate existing tools in this design space, including a recent result of the authors providing practical type checking of full unannotated XSLT 1.0 stylesheets given general DTDs that describe the input and output languages.

On the complexity of typechecking top-down XML transformations

We investigate the typechecking problem for XML transformations: statically verifying that every answer to a transformation conforms to a given output schema, for inputs satisfying a given input schema. As typechecking quickly turns undecidable for query languages capable of testing equality of data values, we return to the limited framework where we abstract XML documents as labeled ordered trees. We focus on simple top-down recursive transformations motivated by XSLT and structural recursion on trees. We parameterize the problem by several restrictions on the transformations (deleting, non-deleting, bounded width) and consider both tree automata and DTDs as input and output schemas. The complexity of the typechecking problems in this scenario ranges from PTIME to EXPTIME .

Static analysis of XML transformations in java

XML documents generated dynamically by programs are typically represented as text strings or DOM trees. This is a low-level approach for several reasons: 1) traversing and modifying such structures can be tedious and error prone, 2) although schema languages, e.g., DTD, allow classes of XML documents to be defined, there are generally no automatic mechanisms for statically checking that a program transforms from one class to another as intended. We introduce XACT, a high-level approach for Java using XML templates as a first-class data type with operations for manipulating XML values based on XPath. In addition to an efficient runtime representation, the data type permits static type checking using DTD schemas as types. By specifying schemes for the input and output of a program, our analysis algorithm will statically verify that valid input data is always transformed into valid output data and that the operations are used consistently.

Supporting metasearch with XSL

Metasearch engines offer better coverage and are more fault-tolerant and expandable than single search engines. A metasearch engine is required to post queries with and obtain retrieval results from several other Internet search engines. In this paper, we describe the use of the extensible style language (XSL) to support metasearches. We show how XSL can transform a query, expressed in XML, into different forms for different search engines. We show how the retrieval results could be transformed into a standard format so that the metasearch engine can interpret the retrieved data, filtering the irrelevant information (e.g. advertisement). The proposed structure treats the metasearch engine and the individual search engines as separate modules with a clearly defined communication structure through XSL. Thus, the system is more extensible than coding the structure and syntactic transformation processes. It allows other new search engines to be included just through plug-and-play, requiring only that the new transformation of XML for this search engine be included in the XSL.

Static Analysis of XML Transformations in Java

XML documents generated dynamically by programs are typically represented as text strings or DOM trees. This is a low-level approach for several reasons: 1) Traversing and modifying such structures can be tedious and error prone; 2) Although schema languages, e.g. DTD, allow classes of XML documents to be defined, there are generally no automatic mechanisms for statically checking that a program transforms from one class to another as intended. We introduce X<small>ACT</small>, a high-level approach for Java using XML templates as a first-class data type with operations for manipulating XML values based on XPath. In addition to an efficient runtime representation, the data type permits static type checking using DTD schemas as types. By specifying schemas for the input and output of a program, our algorithm will statically verify that valid input data is always transformed into valid output data and that no errors occur during processing.

Haskell and XML

We present two complementary approaches to writing XML document-processing applications in a functional language.In the first approach, the generic tree structure of XML documents is used as the basis for the design of a library of combinators for generic processing: selection, generation, and transformation of XML trees.The second approach is to use a type-translation framework for treating XML document type definitions (DTDs) as declarations of algebraic data types, and a derivation of the corresponding functions for reading and writing documents as typed values in Haskell.