Abstract:
A grammar for mapping a first grouping of XML data into a second grouping of XML data and a method for accomplishing same to incorporate the first grouping into the second grouping. The grammar includes a first rule for computing a first child element attribute and a second rule for computing a second parent element attribute. The first rule and second rule vary according to a production of an element type of the first grouping. The element types include PCDATA, disjunctive, conjunctive and Kleene star, each having a unique rule set for defining inherited and synthesized attributes of the parent and child elements. The method includes the step of executing a mapping of a first grouping having at least one parent element and a set of corresponding child elements into a second grouping in accordance with the grammar rules based on the production of the element type.

Description:
FIELD OF THE INVENTION  
       [0001]     This invention relates to the processing of XML data and, more particularly, to the integration of XML data from one or more sources into a single XML document.  
       DESCRIPTION OF THE BACKGROUND ART  
       [0002]     eXtensible Markup Language (XML) is rapidly emerging as the standard for data representation and exchange on the World Wide Web. The diversity of next-generation Web applications that rely on XML as a data-exchange format dictates the need for tools that can efficiently collect data from multiple distributed XML sources and incorporate same in a target XML document. In practice, such XML integration is typically DTD-directed. That is, the integration task is constrained by a predefined Document Type Definition (DTD) that the target XML document is required to conform. DTD-conformance is evident when, for example, enterprises agree on a common DTD and then exchange and interpret their XML data based on this predefined DTD. Another important application of DTD-conformance concerns security. That is, the integrated XML document, as a view of the original data, is required to conform to a pre-specified “view DTD” in order to both hide confidential information and facilitate effective formulation of user queries over the secure integrated view.  
         [0003]     Ensuring the conformance of an integrated XML document (created through multiple XML data sources) to a predefined target DTD is a non-trivial problem. First, the target DTD itself may specify a fairly complex schema structure, e.g., recursive and/or non-deterministic with disjunctions. Second, the integration task may be large-scale and naturally “hierarchical”. In other words, the integration may involve a large number of distributed data sources, where some of the sources are virtual, in the sense that they are views that need to be created via XML integration. This latter requirement indicates that effective XML-integration specifications should be composable, such that large, complex integration tasks can be built via composition of simpler sub-tasks.  
         [0004]     A straightforward solution to DTD-directed XML data integration employs a well-known XML query language (e.g., XQuery, XSLT) to define an integrated XML view, and then check whether the resulting view conforms to the prescribed DTD. Unfortunately, such an approach fails for a number of reasons. First, using full XML query languages to define an integrated view cannot guarantee DTD-conformance. Specifically, type inference for such derived XML views is too expensive to be used in practice. That is, it is intractable for extremely restricted view definitions, and undecidable for realistic views. Similarly, accurate XML type checking is difficult. Accordingly, languages such as XQuery typically implement only approximate type checking. Such an approach provides no guidance on how to specify a DTD-conforming XML view. This means that DTD-directed integration becomes a trial-and-error process where, if a resulting view fails to type-check, the view definition needs to be modified and the type-checking process must be repeated. For complex integration mappings, reaching a DTD-conforming integrated view through repeated trial-and-error is a time consuming and arduous process. Second, while Turing-Complete XML query languages (such as XQuery) can express very complex integration mappings, optimization for such languages still remains to be explored, and their complexity makes it desirable to work within a more limited formalism. That is, when it comes to large scale XML data integration, it is often desirable to trade expressive power for efficiency and ease-of-use.  
         [0005]     Attribute Integration Grammars (AIGs), a grammar-based formalism for schema-directed integration of relational data in XML, are another possible solution. AIGs extend a target DTD with tuple-valued attributes and SQL queries over the relations, whereas a mild variation of AIGs can support DTD-directed XML-to-XML transformations. However, these proposals are inadequate for XML integration because they are restricted to flat, relational sources and they are not composable. Developing an effective, modular solution for large-scale, DTD-directed XML data integration poses a new set of challenges including the need for a significantly more powerful, composable formalism technique. Accordingly, there is a need for language construction rules or grammars that collect XML data from various sources and cost effectively and correctly integrate such data into a single XML document that conforms to a desired target DTD.  
       SUMMARY OF THE INVENTION  
       [0006]     The disadvantages associated with the prior art are overcome by the present invention of a grammar for mapping a first grouping of XML data having at least one parent element and a set of corresponding child elements into a second grouping of XML data and a method for accomplishing same to incorporate the first grouping of XML data into the second grouping of XML data. In an embodiment of the invention, the grammar includes a first rule for computing a first child element attribute by extracting data from one or more sources via a query which takes a first parent element attribute as a constant; and a second rule for computing a second parent element attribute by grouping one or more second child element attributes. The first rule and second rule vary according to a production of an element type of the first grouping of XML data that is being evaluated. The element types capable of being evaluated include PCDATA, disjunctive, conjunctive and Kleene star, each having a unique rule set for defining inherited and synthesized attributes of the parent and child elements.  
         [0007]     Additionally, the method for performing the integration (thereby specifying Document Type Definition (DTD) integration of XML data) includes the step of executing a mapping of a first grouping of XML data having at least one parent element and a set of corresponding child elements into a second grouping of XML data. The mapping further includes following at least one rule for computing a first child element attribute and a second parent element according to a production type of the XML data. The production types being selected from those identified above with respect to the grammar of the subject invention.  
     
    
     BRIEF DESCRIPTION OF THE DRAWINGS  
       [0008]     The teachings of the present invention can be readily understood by considering the following detailed description in conjunction with the accompanying drawings, in which:  
         [0009]      FIG. 1  depicts source and target Document Type Definitions of XML data to be processed in accordance with one example of the subject invention;  
         [0010]      FIG. 2  depicts source and target Document Type Definitions of integrated XML data of one example of the subject invention; and  
         [0011]      FIG. 3  depicts an XML Integration Grammar (XIG) in accordance with the subject invention. 
     
    
     DETAILED DESCRIPTION  
       [0012]     The inventors provide a novel formalism, denoted as XML Integration Grammars (XIGs), for a modular specification of complex, DTD-directed XML integration tasks. The invention is described Within the context of specific functions and processes. However, it will be appreciated that the teachings of the invention are adaptable to many other functions and processes. An XIG is a (partial) function defined with a target DTD D, a fragment of a query language (such as XQuery), and tree-valued attributes that, given a collection of XML data sources, constructs an integrated XML document that conforms to D. The definition of an XIG is built on top of the individual element productions in the target DTD D using a collection of localized semantic rules. These rules for a DTD element production are used to compute intermediate results in tree-valued attributes that correspond to the appropriate data elements in the integrated XML document, and include (1) queries over the XML sources expressed in the XQuery fragment used, and (2) embedded XIG calls which can be either local (i.e., executed at the same site) or remote (i.e., executed remotely).  
         [0013]     An XIG call is essentially treated as a “black box” that returns an XML tree conforming to its target DTD, thus allowing for modular XIG specifications of complex integration tasks. Based on this XIG formalism, a middleware-system architecture for DTD-directed XML integration and novel techniques for optimizing the evaluation of XIGs is proposed. Taking a middleware-based approach to XIG evaluation, results in several effective XIG-specific optimization techniques that can be applied outside the generic XQuery engine. More specifically, it is possible to capture recursive DTDs and recursive XIGs in a uniform framework, and propose a cost-based algorithm for scheduling local XML queries/XlGs and remote XIGs to maximize parallelism. An algorithm for merging multiple XQuery expressions into a single query without using “outer-union/outerjoin” is also proposed. Combined with possible optimization techniques for the XQuery fragment used in XIG definitions, such optimizations can yield efficient evaluation strategies for DTD-directed XML integration.  
         [0014]     Note that XIG formalism is not an XML transformation language. XIGs serve as a user/application level interface for specifying DTD-directed integration in query languages. Being built around the productions in the target DTD, XIGs provide guidance on how to specify XML integration in a manner that automatically guarantees DTD conformance. Furthermore, XIGs rely on semantic rules that are local to each DTD production, thereby allowing integration sub-tasks to be declaratively specified for each production in isolation. Such a feature allows XIGs to simplify a complex integration task by breaking it into small, production/element-specific pieces that can be specified independently. XIG definitions rely solely on DTDs and a query language. As such, there is no need to study any new, specialized integration language. XIGs can be compiled into, for example, XQuery functions that impose control over computation and data flow of queries to automatically ensure DTD-conformance. Moreover, XIGs can be defined using some specific XQuery fragment that allows for more optimizations than full-fledged XQuery, thus providing better performance. Other types of query languages known to those skilled in the art can also be used to achieve the desired results and are within the scope of this invention.  
         [0015]     A brief review of DTDs and XQuery expressions is useful in describing the subject invention. Without loss of generality, a DTD is defined as (Ele, P, r), where Ele is a finite set of element types; r is a distinguished type in Ele, called the root type; P defines the element types: for each A in Ele, P(A) is a regular expression of the following form:
 
α::= PC DATA|ε| B   1   , . . . , B   n   |B   1   + . . . +B   n   |B* 
 
 where ε is the empty word, B is a type in Ele (referred to as a child type of A), and ‘+’, ‘,’ and ‘*’ denote disjunction, concatenation and the Kleene star, respectively. A→P(A) is referred to as the production of A. It has been shown that all DTDs can be converted to this form in linear time by introducing new element types. Examples of DTDs can be found in  FIGS. 1 and 2 . Consider the XML-to-XML transformation of promotional data for a car sale. The source data is specified by the DTD Dsale  102  depicted in  FIG. 1 ( a ), in which ‘*’ indicates one or more occurrences. It consists of cars promoted and their features. Each feature is identified by a fid, a key of the feature, and may be composed of other features. To exchange the data, one wants to convert the source data to a target document conforming to the DTD Dsale  106  given in  FIG. 1 ( c ). The target DTD  106  groups features under each car for sale, along with the composition hierarchy of each feature. Observe that the target DTD is recursive: the element type features is indirectly defined in terms of itself. 
 
         [0016]     As another example, consider a view for car dealers. Each dealer maintains a local XML document specified by a source DTD D dealer    104  which describes the dealer, cars carried by the dealer, and invoice, as depicted in  FIG. 1 ( b ). Some information is confidential, such as invoice and quantity, as indicated by the shadowed nodes in  FIG. 1 ( b ), which should not be made public. To hide the confidential data, one wants to define a view for each dealer such that the dealer data can only be accessed through the view. As a user interface the dealers want to provide the view DTD D dealer    108  given in  FIG. 1 ( c ) and requires the views to conform to D dealer    104 .  
         [0017]     Also consider integration of XML data for car dealers in a region together with sale promotion data. The regional integration is to extract data from XML sources and construct a single target document that consists of sale data, information of all the dealers in the region, and cars carried by these dealers and promoted by sale. As shown in  FIG. 2 ( a ), the XML sources include (1) a sale document conforming to DTD D sale    102  and (2) dealer views conforming to DTD D dealer    104 . The target document  202  is required to conform to the DTD D  204  given in  FIG. 2 ( b ). Specifically, the integration is to transform the sale source data to and collect dealer information from the views; for each dealer, it only gathers data for cars that are promoted by sale.  
         [0018]     This integration task is rather complex. First, the target DTD  204  is recursive and non-deterministic; its DTD graph  206  given in  FIG. 2 ( c ) is cyclic and contains dashed edges (used to denote disjunction to distinguish from solid edges for concatenation). Second, the integration is “hierarchical”. That is, it involves a number of XML views distributed across the dealers&#39; sites, which are in turn the result of transformation from local documents conforming to D dealer .  
         [0019]     An XML document (tree) T conforms to a DTD D if (1) there is a unique node, the root, in T labeled with r; (2) each node in T is labeled either with an Ele type A, called an A element, or with PCDATA, called a text node; (3) each A element has a list of children of elements and text nodes such that their labels are in the regular language defined by P(A); and, (4) each text node carries a string value (PCDATA) and is a leaf of the tree. T is referred to as a document (instance) of D if T conforms to D.  
         [0020]     XIGs can be defined with any fragment of XQuery that supports FLWR constructs as discussed in XQuery 1.0: An XML Query Language, by D. Chamberlin et al., W3C Working Draft, June 2001, herein incorporated by reference, and permits effective optimization. Given a fragment of XQuery, the syntax is extended by incorporating XIG calls in the top level let clauses. Specifically, consider the class of queries defined as follows:
 
 Q::=q| let$ χ :=XIG _call Q XIG _call:: =U   V   :V ( U )| V ( U )
 
 where q is a query in the fragment, V is an XIG, U v  is the URI of V (for remote XIG), and U is the URI of a source XML document. Here U V :V(U) denotes a remote XIG call, and V(U) is a local XIG call. The semantics of a query “let$ χ:=XIG_call Q” is to first evaluate the XIG, assign the result of the evaluation to $x as a constant, and then evaluate the XQuery expression q. This extension is referred to as XQ e . An XIG is defined with a target DTD D and is evaluated to an XML document of D; thus, the XIG can be viewed as an XML expression of “type” D. 
 
         [0021]     An XIG V is a partial function from a collection X of XML sources to documents of a target DTD D, referred to as an XIG from X to D and denoted by V:X→D. Specifically, let D=(Ele, P, r); then V is defined on top of D as follows. 
    Attributes: For each element type A in Ele, V defines an inherited attribute Inh(A) and a synthesized attribute Syn(A); the values of these attributes are a single XML element. Intuitively, inherited attributes are to pass data and control, and synthesized attributes are to hold partial results (subtrees).     Rules: For each production p=A→α in P, V defines a set rule (p) of semantic rules consisting of: 
        for each child type B in α, a rule for computing Inh(B) by extracting data from sources via an XQ e  query, which may take the parent Inh(A) as a parameter;     for the parent type A, a rule Syn(A) by grouping together Syn(B) for children B in α.    
        Input/Output: The sources X is called the input of V, the value of the synthesized attribute Syn(r) of the root is the output of V, and D is the type of V. 
 
 Given an input X, V(X) returns Syn(r), which is an XML document conforming to the target DTD D. 
   
 
         [0027]      FIG. 3  depicts an XIG  300  in accordance with the subject invention. The XIG  300  defines a view for local dealers: given the URI U of a local document specified by the DTD D s   dealer  of  FIG. 1 ( b ), Vdealer (U) returns an XML document conforming to D dealer  of  FIG. 1 ( c ). Thus V dealer  can be treated as a function: D s   dealer →D dealer . The XIG  300  is defined on top of the view DTD D dealer  with XQ e  queries and tree attribution. For each element type A in D dealer , it defines two attributes Inh(A) and Syn(A), which contain a single XML element as their value. For each production of D dealer , it defines a set of rules via XQ e  to compute the inherited attributes of the children, using the inherited attribute of the parent as a parameter. In addition, there is a single rule for computing the synthesized attribute of the parent, by collecting the synthesized attributes of its children.  
         [0028]     For a production p=A→α, the semantic rules rule(p) enforce that Syn(A) is indeed an A element as follows.  
         [0029]     P=A→PCDATA. Then rule(p) is defined as  
         [0030]     Syn(A)={Q(Inh(A))/value( )},  
         [0031]     Where Q is an XQ e  query that returns PCDATA and treats Inh(A) as a constant parameter. See, e.g., the rule for production name→PCDATA in the XIG V dealer  of  FIG. 3 .  
         [0032]     P=A→B 1 , . . . , B n . Then rule(p) consists of
 
 Inh ( B   i )= Q   i ( Inh ( A ))/* for  iε[ 1, n]*/, Syn ( A )=&lt; A&gt;{Syn ( B   i ) . . .  Syn ( B   n )}&lt;/ A&gt;, 
 
 Where for each i ε[ 1 ,n], Q i  is an XQ e  query that returns a single element (subtree). As an example, see the rules for car→make, model, price, inStock in V dealer . 
 
         [0033]     P=A→B 1 + . . . +B n . Then rule(p) is defined as: 
    Inh(B i )=let $c:=Q c (Inh(A)) return {if C i ($c) then Q i (Inh(A)) else&lt;empty/&gt;}/*for iε[1,n]*/, Syn(A)=let $c:=Q c (Inh(A)) return 
        {if C 1 ($c) then &lt;A&gt;Syn(B 1 )&lt;/A&gt;else . . . else if C n ($c) then &lt;A&gt;Syn(B n )    
        &lt;/A&gt;else&lt;empty/&gt;}
 
 where Q c  is an XQ e  query, referred to as the condition query of rule(p), which is evaluated only once for all the rules in rule(p); Q i  is an XQ e  query that returns a single element; and, C i  is a Boolean XQ e  expression exclusive to each other: one and only one C i  is true for all iε[1,n]. For example, see the rules for the production inStock→yes+no in V dealer . 
   
 
         [0037]     P=A→B*. Then rule(p) is defined as:
 
 Inh ( B )→for $ b  in  Q ( Inh ( A )) where  C ($ b ) return $ b,Syn ( A ) =&lt;A&gt;   i    Syn ( B ) &lt;/A&gt;, 
 
 where Q is an XQ e  query that may return a (probably empty) set of elements, C is an XQ e  Boolean expression, and “           i ” is a list constructor. For each $b generated by Q, the rules for processing B are evaluated, treating $b as a value of Inh(B). Then the rule for Syn(A) groups together the corresponding Syn(B)&#39;s into a list using            i  in the same order as the one when the $b&#39;s are generated. For example, see the rules for cars→car* in V dealer . 
 
         [0038]     P=A→ε. Then rule(p) is defined by Syn(A)=Q(Inh(A)) where Q is an XQ e  query such that Q(Inh(A)) returns either &lt;A/&gt;, or &lt;empty/&gt; if the value of Syn(A) is not to be included in the target document. For example, see the rule for the production yes→ε in V dealer .  
         [0039]     Several subtleties are worth mentioning. First, recall that Syn(A) is defined in terms of Syn(Bi). In the rule for computing Syn(A) one may replace Syn(B i ) with the XQ e  query for computing Syn(B i )(defined in the rules for B i ). For example, in the XIG V dealer , the rules for dealer and car can be rewritten as: 
    Dealer→name, address, cars     Inh(cars)={U/dealer/cars};     Syn(dealer)=&lt;dealer&gt; {U/dealer/name} {U/dealer/addr} {Syn(cars)}&lt;/dealer&gt;    Car→make, model, price, inStock     Inh(inStock)={Inh(car)};     Syn(car)=&lt;car&gt;{Inh(car)/model} {Inh(car)/make} {Inh(car)/invoice/price}    {Syn(inStock)}&lt;/car&gt;
 
 These substitutions can avoid unnecessary computation of inherited attributes that are not needed elsewhere. Second, XML constraints are ignored, but the definition of XIGs can be easily extended to incorporate constraints as discussed for example in Capturing both Types and Constraints in Data Integration by Benedikt et al., SIGMOD,  2003  to ensure both DTD-conformance and constraint satisfaction in XML integration. Third, as XIGs support tree attribution and return XML trees, semantic attributes can be computed via other XlGs. Furthermore, as embedded XIGs ensure conformance to their target DTDs, one can use them as expressions without complicating the typing analyses, thus making XIGs composable. 
   
 
         [0047]     The operational semantics of an XIG (i.e., V: X→D as presented above) are now considered. Given an instance of X, V evaluates its attributes via its rules and returns Syn(r) of the root r of D as its output. The evaluation is carried out in a top-down manner, using a stack. The root r is first pushed onto the stack. For each node A at the top of the stack, a subtree Syn(A) is computed. This is accomplished by first identifying the production p=A→α in D, and for each B in α, Inh(B) is evaluated with rule(p) as follows:  
         [0048]     p=A→PCDATA—First, Q(Inh(A) is evaluated, treating Inh(A) as a constant. Note that if Q has an embedded XIG, the XIG is invoked and evaluated. Then, the PCDATA of Q(Inh(A) is assigned to Syn(A).  
         [0049]     p=A→B 1 , . . . , B n —For each Bi, Inh(B i ) is computed by evaluating Q i (Inh(A)). Then, Bi is pushed onto the stack and each is processed in the same way using the value of Inh(B i ). After all of the B i &#39;s are evaluated and popped off of the stack, i.e., when all the Syn(B i )&#39;s are available, Syn(A) is computed by collecting all of the Syn(B i )&#39;s such that A has a unique B i  child for each iε[1,n].  
         [0050]     p=A→B 1  + . . . +B n —First, the condition query Q c (Inh(A)) is evaluated and the first B i  is selected such that its corresponding C i  is true with respect to the result of Q c . Next, the rule for computing Inh(B i ) is evaluated. This B i  is pushed onto the stack and is processed inductively using the value of Inh(B i ). After this Bi is popped off of the stack and Syn(B i ) is available, Syn(A) is computed by means of Syn(B i ). Note that Inh(B j ) and Syn(B j ) are not computed if j≠i, i.e., Bi is the only child of A.  
         [0051]     P=A→B*—First, Q(Inh(A)) is evaluated in the rule for computing Inh(B) For each $c returned by Q, a copy of B is pushed onto the stack, taking $c as its inherited value. The B nodes are then processed in the same way. After these nodes have been evaluated and popped off of the stack, Syn(A) is assigned the list consisting of all the Syn(B)&#39;s. Note that is Q is empty, then Syn(A) is &lt;empty/&gt;, i.e., A has no children.  
         [0052]     p=A→ε—Q(Inh(A)) is evaluated and its result is treated as Syn(A). After Syn(A) is computed, A is popped off of the stack and Syn(A) is used to evaluate other nodes until no more nodes are in the stack. At this stage, Syn(r) is computed and returned as the output of the XIG evaluation. Note that for each A, its inherited attribute is evaluated first, then its synthesized attribute, which is an A-subtree. The evaluation takes one-sweep. That is, each A element is visited twice, first pushed onto the stack and then popped off after its subtree is constructed. Accordingly, such an XIG is capable of taking XML from various sources and integrating same into a single target DTD.  
         [0053]     Although various embodiments which incorporate the teachings of the present invention have been shown and described in detail herein, those skilled in the art can readily devise many other varied embodiments that still incorporate these teachings.