JP2003058530A - Program for generating xml document conversion rule - Google Patents

Abstract

PROBLEM TO BE SOLVED: To provide a program which enables anybody to easily generate a conversion rule for converting an XML document to another XML document. SOLUTION: A computer is provided with a function which generates relevant information object representative of the structure of a conversion destination XML document and a part related to the conversion destination XML document in a conversion source XML document, a function which specifies a route node of the conversion destination, and a function which starts processing for describing an individual rule for generation of a specific node of the conversion destination and processing for describing a rule specifying the position of a source node of the conversion source from the route node and alternately and recurrently executes these processing.

Description

Detailed Description of the Invention

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a program for automatically generating conversion rules used for converting one XML document into another XML document.

[0002]

2. Description of the Related Art A document created by an XML document
Data can be exchanged between different OSs and applications. However, if one XML document is
When converting to an ML document, the conversion rule is necessary. The XML document and the other XML document referred to here are both documents created by the XML document, but the data structures thereof are different or the contents of the data are different. As the above conversion rule, XSLT
There is an (Extensible Style Language Transformation). The XSLT is a script having a function of converting an XML document into another form of XML document by a programming process. Therefore, some XML
To convert a document to an XML document with a different structure,
An XSLT corresponding to both XML documents must be created.

[0003]

Conventionally, a programmer manually creates the above XSLT according to the structures of the conversion source XML document and the conversion destination XML document. However, in order to generate the above XSLT, an XML document or XSLT is used.
Advanced knowledge is required and not everyone can generate an XSLT. Moreover, X
The structure and format of ML documents vary widely, and such XM
The combination of the conversion source and the conversion destination by the L document is infinite. For such individual combinations, manually
Creating an SLT is almost impossible. An object of the present invention is to provide a program that enables anyone to easily create a conversion rule for converting an XML document into another XML document.

[0004]

A first aspect of the present invention is a conversion source X.
A program for creating a conversion rule for converting an ML document into a conversion destination XML document, the conversion destination X being stored in a computer.
Structure of ML document and conversion destination X in conversion source XML document
A function of generating a related information object representing a portion related to an ML document, a function of identifying a root node of a conversion destination, a process of describing an individual rule for generating a specific node of the conversion destination, and a conversion source Is a program for realizing the process of writing the rule for specifying the position of the source node of (1) and the function of starting recursively and recursively.

A second invention is characterized in that the program of the first invention is provided with a function of analyzing a tree structure of an input XML document in a computer. A third aspect of the invention relates to a function of displaying a tree structure of a conversion source XML document and a conversion destination XML document on a screen, a function of recognizing a relationship specified by a line on the screen, and related information based on the recognized relationship. It is characterized by the addition of the function of creating an object.

A fourth invention comprises a plurality of logics and logic icons corresponding to these logics, and a specific node of the conversion source XML document and a node of the conversion destination XML document are connected via the logic icon. In this case, the XML document conversion rule is created based on the logic corresponding to the logic icon. The fifth invention is characterized in that the operator selects a desired logic icon to replace the corresponding logic and create an XML document conversion rule based on the logic.

A sixth aspect of the present invention is characterized in that the above logic defines a processing method for the contents of data in a specific node of a conversion source. The seventh invention is characterized in that the logic defines a method of dividing / integrating individual nodes of a conversion source. Note that the above-mentioned division / integration of nodes includes division / integration in units of nodes and division / integration in units of instances forming nodes. The eighth invention is characterized in that the logic defines which instance is to be selected from a specific node that is a conversion source.

[0008]

BEST MODE FOR CARRYING OUT THE INVENTION An embodiment of the present invention will be described with reference to FIGS. Here, the conversion source XM shown in FIG.
An example of creating an XSLT which is a conversion rule used when converting the L document α into the conversion destination XML document β shown in FIG. 2 will be described. Here, the conversion rule is the XSLT document γ shown in FIG. That is, the computer automatically creates the conversion rule, that is, XSLYγ, based on the conversion source XML document α and the conversion destination XSL document β, the details of which will be described below.

The processing procedure of the computer by the XSLT creating program will be described with reference to the flow charts of FIGS. First, in step S1 of FIG.
The ML document and the conversion destination XML document are read. In step S2, the tree structure of both XML documents is recognized. XML
The document tree structure is a hierarchical structure as shown in FIGS. FIG. 7 shows the tree structure of the conversion source XML document α, and FIG. 8 shows the tree structure of the conversion destination XML document β. However, in FIG. 7, a part thereof is omitted.

In step S3, the paths of all the nodes are specified. Here, a node is a unit of an XML document. Further, the path specifies the location of the node by the relative position from the root node in the tree structure. Here, the conversion source XM
The positions of all the nodes in the L document and the conversion destination XML document are recognized.

In step S4, the conversion source XML document α
And the tree structure of the conversion destination XML document β is displayed on the screen. Necessary portions of the tree structure shown in FIGS. 7 and 8 are displayed as shown in FIG. 9, for example. In FIG. 9, the conversion source XML document α is shown on the left side, and the conversion destination XML document β is displayed on the right side. Next, step S5
Then, when the operator connects the node of the conversion destination XML document α and the node of the related conversion source XML document β with a line on the screen shown in FIG. 9 and clicks the conversion rule creation button, rule creation starts. To be done.

In step S6, a set of a conversion destination node and a conversion source source node, which are connected by a line, is specified by the path. This set is a set of a specific node of the conversion destination XML document and a conversion source node related to the node. Then, of the set of nodes, the conversion source node is called a source node. In other words, among the conversion source nodes, the node related to the conversion destination is the source node.

By doing so, in step S7,
The node map is completed. The node map represents the relationship between the two specified by the line by the path. For example, as shown in FIG. 9, a line 1 connecting the conversion destination node “row” and the conversion source node “row”, and a line 2 connecting the conversion destination “column” and the conversion source “column”.
Produces a node map. When the lines 1 and 2 are drawn, a special logic icon for instructing how to take the data may be interposed between the conversion source node and the conversion destination node. Each logic is associated with this logic icon.

The above logic includes the following functions. These functions include a function that defines the processing method for the contents of the data of a specific conversion source node, a function that specifies the method of dividing / integrating individual nodes of the conversion source, and a specific node of the conversion source. It is a function that regulates which instance is selected.

In step S8, from the above node map,
Generate related information object. This related information object includes the following data and program. The data is structure information indicating the structure of the conversion destination XML document β and which part of the conversion destination XML document β is related to which part of the conversion source. This structural information is shown in FIG. As can be seen from FIG. 10, this structure information indicates only the structure of the conversion destination XML document β and the portion of the conversion source XML document α related to the XML document β. The program of the related information object also includes a reference from the conversion source XML document α to the conversion destination XML document β to the logic that instructs how to bring the data.

In step S9, the root node of the conversion destination is specified. The root node is a node corresponding to the root part in the tree structure of the XML document. The tree structure is a structure in which the trunk extends from the root and branches off. The tree structures shown in FIGS. 7 and 8 are shown upside down. That is, in FIG. 7 and FIG. 8, the node shown at the top is the root node. In step S9, the root node in the conversion destination XML document β, that is, “csvfile” is specified. The steps up to step S9 are the steps for completing the related information object.

In the following, the step of actually describing the XSLT is entered, but from here onward, the following flow will be described without specifying the conversion source XML document and the conversion destination XML document as the documents of FIGS. 1 and 2. In step S10, the header of XSLT is described, and in step S11, the start tag of the root node of the conversion destination is described.

Next, in step S12, a child node of the root node of the conversion destination is specified. In step S13,
Call the compile target element function with the child node of the transformation destination root node as an argument. This compile target element function will be described again in the following steps.
This is a function to describe the position of the source node corresponding to a specific node of the ML document. However, the position of the source node is specified as the parent-child relationship of the nodes in the conversion source tree structure. A flowchart of this compile target element function A is shown in FIG.

In step S14, the compile target element function is started. In step S15, the source node is acquired. If there is no source node, record that fact. In step S16, the element logic for the conversion destination node designated by the argument is acquired. Here, if there is no element logic, that fact is recorded.

In step S17, it is determined whether or not the above node, that is, the child node of the root node has a source node. If there is a source node corresponding to the child node of the root node, the process proceeds to step S23, and if not, the process proceeds to step S18. If there is no source node, the process proceeds to step S18 to call the get element body function based on the above element logic. The get element body function is a function that describes an individual rule corresponding to a specific element to be converted based on the type of element logic, and the processing content thereof is shown in FIG. Shows.

Then, the process proceeds from step S18 to step S201 in FIG. In step S201, the get element body function based on the element logic is started. In step S202, a start tag is described. The tag described here is the start tag of the element corresponding to the specific node of the conversion destination, that is, the child node of the root node. In step S203, it is determined whether the node has a child node. If there is no child node, the process proceeds to step S208, and if there is a child node, the process proceeds to step S204. In step S204, the compile target element function having the child node of the child node of the conversion destination root node as an argument is called.

In step S205, the compile target element function is started. This step S205
Is the same step as step S101 in FIG.
The processing of steps S101 to S118 in FIG.
Since it is almost the same as the processing from step S11 to step S31 in FIG. 4, description thereof will be omitted here. And FIG.
6 returns to step S206 of FIG. 6 and the compile target element function ends.

In step S207, it is determined whether the content logic is for the currently specified node. Then, if there is content logic, the process proceeds to step S214, and the function corresponding to the content logic is called. If there is no content logic, the process proceeds to step 208, and the default content logic function is called. The content logic function is a function that describes an individual rule that specifies the content of the data that enters the specific node of the conversion destination, and the content logic is the data that is brought to the specific node of the conversion destination. It specifies a special operation for the contents of.

In step S209, the content logic function is started, and in step S210, an individual rule for specifying the data content is described. In step S211, the default content logic function ends.

Incidentally, this time, the default get element body function in which the element logic is not specified has been described based on the flowchart of FIG. However, when the element logic is designated, the get element body function based on the designated logic is realized. The flowchart in that case is shown in FIG.
Although it is different from the above, it realizes that function and
Reach 213. As described above, various conversion rules can be automatically generated by replacing the element logic. In step S211, an end tag corresponding to the start tag described in step S202 is described. This completes the get element body function (step S213).

On the other hand, if it is determined in step S203 that there is no child node, the process proceeds to step S207, and the process proceeds to step S213 as described above. From step S213, the procedure returns to step S19 of FIG. 4 and proceeds to step S20. In step S20, the compilation target element function of the child node of the root node ends, and in step S21, the end tag of the root node is described. Then, when the footer of XSLT is described in step S22, the conversion rule XSLT is completed.

If it is determined in step S17 of FIG. 4 that there is a source node that is a child node of the root node,
It proceeds to step S23. In step S23, the parent array of the source node is acquired. That is, all the parent nodes of the source node specified here are specified. Since all paths have already been recognized in the tree structure of the conversion source, it is possible to acquire the parent array of the source node from the paths. In step S24, the array of the part that has not been selected yet is extracted from the parent array and is acquired.

In step S25, it is determined whether or not each parent node obtained by the above extraction and the source node itself have a loop logic. If there is a loop logic, the process proceeds to step S34 to start the function according to the loop logic, but if there is no loop logic, the process proceeds to step S26 to start the default loop logic. In step S27, the pre-string of the element logic is described. This pre-string is an XSL that changes according to the element logic, if any.
This is a T command or the like. However, in the case of default element logic, nothing is written.

In step S28, a start tag based on the default loop logic is described. However, the start tags from the highest node to the source node among the parent node and the source node obtained in step S24 are described in order. In step S29, the get element body function based on the logic is called. That is, the processes of steps S201 to 213 of FIG. 6 are performed, and the process returns to step S30 of FIG. 4 to end the get element body function.

In step S31, the above step S28 is performed.
Describe the end tag corresponding to the start tag described in 1. from the source node to the parent node. With this, the processing for the node on the conversion source side related to the specific source node starts in order from parent to child, and ends in order from child to parent. In step S32, the post string is described.
The post ring is a command or end tag corresponding to the prestring. When the loop logic ends in step S33, the process proceeds to step S20, and the compile target element function ends.

The above is the flow of the conversion rule creating program. As described above, in this conversion rule creation program, the compile target element function and the get element body function are alternately recurred in order from the conversion destination root node in order to specify the position and content of the node. To execute. Executing a process recursively means starting the above function from the root node and not ending the process, but starting the process of the child node in the middle of the process, and if there are more child nodes, The processing of the child node is started in the middle of the processing of the parent, and when all the processing is started, the processing is sequentially ended from the child node. Further, as is clear from FIGS. 5 and 6, the compile target function includes a call to the get element body function, and further, the get element body function includes a call to the compile target function. Therefore, these will be executed recursively.

Next, as an example of actually generating a conversion rule, a procedure for generating XSLTγ of FIG. 3 from the structure information of the related information object shown in FIG. 10 will be described. Figure 4
The steps up to step S8 until completion of the related object will be omitted, and description will be given from step S9. First, in step S9, the root node of the conversion destination is specified. As is clear from FIG. 10, the root node of the conversion destination is “csvfile” 3. The header is described in step S10. This header is all the rows of header 21 of FIG.

In step 11, the root node "csvf"
ile ”3 start tag <csvfile> 22 is described (see FIG. 3). In step S12, child nodes of the root node are identified. As is apparent from FIG. 10, the child node of the root node “csvfile” 3 is “row” 4. In steps S13 and S14, the child node "ro
Invokes the compile target element function with w "4 as an argument and starts it. The source node is acquired in step S15, and the element logic is acquired in step S16.

In step S17, it is determined whether there is a source node. As shown in FIG. 10, the above “row” 4 includes
The source node “row” 9 is connected by the line 1. Therefore, the process proceeds to step S23. In step S23, the parent array of the source node is acquired. That is, the parent "rows" 8 of the source node "row" 9 and the parent "tab"
"ledata" 7 and its parent "table" 6 are specified. In step S24, the array of the part that has not been selected is extracted. Above "row" 9, "rows" 8, "tabledata"
7 and "table" 6 are not all selected, array "row" 9- "rows" 8- "tabledata" 7- "tabl"
e ”6 is pulled out.

As shown in FIG. 10, since the loop logic is included in the source node "row" 9 and each parent node, it is determined in step S25 that the source node and each parent node have no loop logic, Go to S26,
Start the default loop logic. Step S27
Then, describe the pre-string of the element logic, but here, since it is the default logic, do not describe anything. In step S28, start tags based on the loop logic are described in order from the parent node to the source node.

The start tag based on the above loop logic is <xsl: for-each select = "">. That is,
"Table" 6 which is the parent of the parent of the source node "row" 9
Starting from <start tag <xsl: for-each select = "table">
23, <xsl: for-each select = "tabledata"> 24, <
xsl: for-each select = "rows"> 25, <xsl: for-each
Describe select = "row"> 26 (see FIG. 3).

Next, in step S29, the get element body function of the default logic is called. That is, the process proceeds to step S201 in FIG. 6 to start the get element body function. As described above, the get element body function is a function of writing an individual rule for generating a specific element of a conversion destination. Here, the specific element of the conversion destination is the node "row" 4
Is. In step S202, the conversion destination node "row"
The start tag <row> 27 of No. 4 is described (FIG. 3).

In step S203, the node "row"
It is determined whether there are 4 child nodes. Above node "row" 4
Has a child node "column" 5, so step S2
In step 04, the compile target element function having this node "column" 5 as an argument is called. The start of the compile target element in step S205 is
Since it is step S101 in FIG. 5, next step S10
Go to 2. In step S102, obtain the source node,
In step S103, the element logic is acquired.

In step S104, the node "column" 5
Determine if there is a source node in. Above node "colum
In the “n” 5, as shown in FIG. 10, the source node “colum
Since there is n'10, the process proceeds to step S107. In step S107, the parent array of the source node "column" 10 is acquired. The parent of “column” 10 is “row” 9, its parent is “rows” 8, its parent is “tabledata” 7, and its parent is “table” 6. Of these, the part that has not been selected is extracted in step S108. "Ro
Since "w" 9 to "table" 6 have already been selected, only "column" 10 is extracted here.

As shown in FIG. 10, since the source node "column" 10 has no loop logic, it is determined in step S109 that there is no loop logic, and the process proceeds to step S110 to start the default loop logic. In step S111, the pre-string of element logic is described, but since it is the default logic,
Do not write anything. In step S112, start tags based on the loop logic are described in order from the parent node to the source node. Here, since there is only the source node “column” 10, as shown in FIG. 3, <xsl: for-each s
Describe elect = “column”> 28.

Next, in step S113, the get element body function is called, and in step S2 of FIG.
Proceed to 01 to start the get element body function.
In step S202, the start tag <column> 29 of the conversion destination node “column” 5 is described (FIG. 3). Since the node “column” 5 has no child node as shown in FIG.
When it is determined that there is no child node in, the process proceeds to step S207.

In step S207, it is determined whether or not there is content logic. However, since the node "column" 5 has no content logic, step S208 is performed.
Go to. In step S208, the default content logic function is called and started in step S208. In step S210, a rule for specifying the data content is described. Actually, <xsl: value-of sel in Fig. 3
ect = “text ()” /> 30 is described. Now the node "co
The contents of data to be entered in "lumn" 5 are specified, and step S21
At 1, the content logic function ends. Step S
In 212, the start tag <described in step S202 above
An end tag </ column> 31 corresponding to column> 29 is described (FIG. 3), the get element body function is ended in step S213, and the process returns to step S114 in FIG.

At step S115, the end tag </ xsl: for each> 32 of the loop logic is described. This end tag is the above start tag <xsl: for-each select = "column"
It corresponds to> 28. In the description of the post ring in step S116, nothing is described because it is the default logic here. Hereinafter, the process proceeds to steps S117 and S118, and returns to step S206 in FIG. This step S is in the middle of the get element body function of "row" 4. Therefore, by the processing from the call of the content logic function of step S208 to the description of the rule of step S210, the node "row" 4
Describe the rules that specify the content of the data contained in. This rule is <xsl: value-of select = "text ()" / in Figure 3.
> 33.

End tag </ row> 3 in step S212
4 is described, the get element body of "row" 4 ends (step S213), and step S30 of FIG.
Return to. That is, the source node “row” of the above “row” 4
It came back in the middle of the loop logic of 9. In step S31, the source node "row" 9 to the parent node "t
The end tag to "able6" is described. In FIG. 3, four end tags </ xsl: for-each> 35, 36, 37, 38 are described, and these are added to the start tags 26, 25, 24, 23 described above, respectively. It corresponds. That is, the pair of tags are nested.

At step S32, the post string is described, and at step S33, the loop logic function ends.
In step S20, the compile target element function with the node "row" 4 as an argument is terminated, and the process proceeds to step S21 in FIG. In step S21, the end tag of the conversion destination root node "csvfile" 3 is described. That is, the end tag </ cs which corresponds to <csvfile> 22 in FIG.
Describe vfile> 39. Footer 4 in step S22
If 0 is described, the conversion rule XSLTγ is completed.

The above-mentioned flow of XSLTγ preparation is summarized as shown in FIG. Since the creation of the above XSLT γ goes back and forth between the flowcharts shown in FIGS. 4, 5 and 6, the flow between the same flowcharts is shown by a solid line in FIG. Is indicated by a broken line. First, in the flowchart shown in FIG. 4, the program is started, and step S
When the process reaches 29, the process advances to step S201 in FIG. 6 to start the compile target element function B1 with “row” 4 as an argument. From step S205, the process proceeds to step S101 in FIG. 5, and the get element body function A1 is started. Proceeding from step S113 to step S201 in FIG. 6, the compile target element function B2 with "column" 5 as an argument is started.

When the compile target element function B2 is completed in step S213, the process proceeds to step S118 in FIG.
Start the continuation of 1. In step S118, the get element body function A1 is terminated, and step S in FIG.
Proceeding to 206, the compile target element function B1 is continued. In step S213, the compile target element function B1 is terminated, the process returns to step S30 in FIG. 4, and the following steps are processed to complete the process.

As is apparent from FIG. 11, the above process starts the process of the first compile target element function B1 in the process shown in FIG. 4, and the get element is acquired in the middle of the process. The processing of the body function A1 is started, and further, in the middle of the process, the second compile target element function B2 is started. Then, the processing started later is ended in order. That is, recursive processing is being performed.

Next, the conversion source XML document and the conversion destination XML document
A case where the logic icon is interposed between the document and the document will be described with reference to FIGS. 12 and 13. On the screen shown in FIG. 12, the tree structure of the conversion source XML document and the conversion destination X document are displayed.
The tree structure of the ML document W is displayed on the left and right sides so as to face each other. And at the bottom of the screen, a plurality of logic icons 2
1-27 are displayed. Each of these logic icons 21 to 27 corresponds to another logic.

These logics have been described above,
"Element logic" that has the function of defining the processing method for the contents of the data of the specific node of the conversion source,
"Content logic" that has a function that regulates the method of dividing / integrating individual nodes of the conversion source, "loop logic" that has a function that determines which instance is selected from the specific node of the conversion source, etc. There is. The logic icons 21 to 27 correspond to one or more of the functions of the logic.

Therefore, the plurality of logic icons 21 are
The operator selects a logic icon suitable for the desired conversion from among the above-mentioned items, and drags it to arrange it between the tree structure of the conversion source XML document and the tree structure of the conversion destination XML document. can do. Here, the logic icon 21 is interposed between the conversion source node and the return destination node. In practice, a desired logic icon is arranged on the screen and then the icon is connected to the conversion source node and the conversion destination node by a line.

As described above, when the logic icon 21 is arranged on the screen, the computer identifies the logic corresponding to the logic icon 21 and performs the processing based on the logic. For example, this logic icon 21
However, in the case of element logic, the contents of the get element body to be called in the step "call of get element body function based on element logic" in the flowcharts of FIGS. 4 to 6 are the default get elements described above. It is different from the body. However, the overall processing flow is the same.

When the content logic icon is interposed, the function corresponding to the logic is called in step S214 of FIG. Furthermore, if you insert the icon of loop logic,
In step S34 of FIG. 4 and step S119 of FIG. 5, the function based on each logic is called.

Next, as a specific example of the function of the above logic, the logic included in the element logic will be described with reference to FIG. 13 (a)-(d),
In the element logic, "SPLIT" and "C
It represents the functions of four logics, "ONCAT", "JOIN", and "SELECT". “SPLIT” is a function of dividing one instance into a plurality of instances as shown in FIG. That is, “SPLIT” divides an instance including “1, 2, 3, 4” in one node a and converts it into four instances. For example, “1, 2, 3, 4” above is “1 Shibuya, Shibuya-ku, Tokyo”
In this case, "SPLIT" divides it into four instances of "Tokyo", "Shibuya Ward", "Shibuya", and "1chome".

The "CONCAT" is a function of integrating a plurality of instances into one instance, as shown in FIG. 13 (b). That is, the "CONCAT" is a function of integrating four instances b included in one node a into one instance, and is a function opposite to the "SPLIT". The "JOIN" is a function of integrating a plurality of separate nodes into one node. At this time, the individual nodes of the conversion source become the individual nodes of the conversion destination. The above "SELECT" is a function of selecting individual instances of one node and making them separate nodes. At this time, from the conversion source instance,
Select a specific instance and only the selected instance will be the destination node.

Further, FIGS. 14 and 15 show the above-mentioned usage examples. As shown in FIG. 14, the conversion source XM displayed on the screen
A "JOIN" logic icon is arranged and connected between the tree structure of the L document and the tree structure of the conversion destination XML document. Then, when a conversion rule creation button (not shown) is clicked, a conversion rule for the XML document is created according to the procedure described above. That is, a plurality of nodes of the conversion source XML document displayed on the left side of FIG. 14 are integrated into one node to create a conversion rule for creating a conversion destination XML document. FIG. 15 shows the XSLT that is the conversion rule created here.

Although the example of the element logic has been described here, the content logic and the loop logic are also described.
Each has a function associated with it. The computer creates an XML document conversion rule according to the logic. That is, a conversion rule for generating an XML document to be generated by utilizing the function of the above logic is created. As described above, various conversion rules are automatically created according to the type of logic icon arranged on the screen. The operator
You don't need to write a special program, just place the logic icon on the screen. It should be noted that some of the above logics have a plurality of functions in combination, and a plurality of icons may be combined and arranged. However, there are some that can be combined and some that cannot be combined depending on the type of logic.

[0058]

According to the XML document conversion rule creating program of the first to eighth inventions, the computer can convert the conversion source X
A conversion rule for converting an ML document into a conversion destination XML document can be automatically created. Unlike the conventional method, a person having specialized knowledge can automatically create various conversion rules, unlike the case of manually creating it. Therefore, any kind of XML document can be converted, and the degree of freedom in data cooperation increases.

According to the second aspect of the present invention, when the source XML document and the destination XML document are input, the computer analyzes the tree structure of the XML document, so that the operator only needs to input the XML document itself. . There is no need to parse and enter the tree structure. According to the third aspect, the relationship between the conversion source node and the conversion destination node can be specified by drawing a line on the screen. It is easy to identify the relationship between both nodes. Therefore, the above relationship can be easily specified even for those who do not have a high level knowledge of XML documents.

According to the fourth to eighth inventions, various XML document conversion rules can be created depending on the type of logic. According to the sixth aspect, the contents of the data of the conversion source XML document can be variously changed and brought to the conversion destination XML document. Therefore, various data conversions can be performed. According to the seventh invention, various structure conversions of an XML document can be performed. According to the eighth invention, data can be extracted.

[Brief description of drawings]

FIG. 1 is an example of a conversion source XML document.

FIG. 2 is an example of a conversion destination XML document.

FIG. 3 is XSLT which is a conversion rule when converting the document shown in FIG. 1 into the document shown in FIG.

FIG. 4 is a flowchart of this embodiment.

FIG. 5 is a flowchart of this embodiment and shows a processing procedure of a compile target element function.

FIG. 6 is a flowchart of this embodiment showing a processing procedure of a get element body function.

FIG. 7 is a diagram showing a tree structure of a conversion source XML document.

FIG. 8 shows a tree structure of a conversion destination XML document.

FIG. 9 is a screen showing a tree structure of an XML document.

FIG. 10 is a diagram showing structure information of a related information object according to the embodiment.

FIG. 11 is a diagram showing a rough flow of processing of the embodiment.

FIG. 12 is a diagram showing a screen when logic is arranged.

FIG. 13 is a diagram illustrating the function of element logic.

FIG. 14 is a diagram showing a screen when a logic “JOIN” is used.

15 is a diagram showing XSLT which is a conversion rule for performing the conversion shown in FIG.

[Explanation of symbols]

α conversion source XML document β conversion destination XML document γ conversion rule (XSLT) 21-27 Logic icon

Claims (8)

[Claims] 1. A program for creating a conversion rule for converting a conversion source XML document into a conversion destination XML document, comprising a structure of the conversion destination XML document and a conversion source XML in a computer.
Describes a function of generating a related information object representing a portion of the L document related to the conversion destination XML document, a function of specifying a conversion destination root node, and an individual rule for generating a conversion destination specific node. XML document conversion rule creation for realizing processing and processing for describing rules for identifying the position of the source node of the conversion source, starting from the root node and alternately and recursively program. 2. The XML document conversion rule creating program according to claim 1, wherein the computer is provided with a function of analyzing the tree structure of the input XML document. 3. A function of displaying a tree structure of a conversion source XML document and a conversion destination XML document on a screen, a function of recognizing a relationship specified by a line on the screen, and a related information object based on the recognized relationship. The XML document conversion rule creating program according to claim 1 or 2, further comprising a function for creating. 4. A plurality of logics and logic icons corresponding to these logics are provided, and when a specific node of a conversion source XML document and a node of a conversion destination XML document are connected via the logic icon, 4. The XML document conversion rule creating program according to claim 3, which creates an XML document conversion rule based on the logic corresponding to the logic icon. 5. An operator selects a desired logic icon to replace the corresponding logic,
The XML document conversion rule creating program according to claim 4, which creates an XML document conversion rule based on the logic. 6. The logic of a specific node of a conversion source,
The XML document conversion rule creating program according to claim 4 or 5, which defines a processing method for the contents of data. 7. The X according to claim 4 or 5, wherein the logic defines a method of dividing / integrating individual nodes of a conversion source.
ML document conversion rule creation program. 8. The XML document conversion rule creating program according to claim 4, wherein the logic defines which instance is to be selected from a specific node that is a conversion source.