JP3968749B2 - XPath processing method, XPath processing device, XPath processing program, and storage medium storing the program - Google Patents

Description

[0001]
BACKGROUND OF THE INVENTION
The present invention relates to XPath processing using an automaton, and more particularly to an XPath processing method, an XPath processing device, an XPath processing program, and a storage medium storing the program for adding an XPath difference.
[0002]
[Prior art]
For example, NewsML is a new news distribution format based on XML (eXtensible Markup Language). NewsML can freely combine news materials such as news articles, images, videos, and voices, and can send information to various devices such as websites, mobile phones, and televisions (TV data broadcasts). A recipient (user) of NewsML can obtain necessary information by registering a search condition in the filter engine. Since the search condition is described in the XML query language, the filter engine processes the XPath group (individual XPath) and also adds the XPath.
[0003]
[Problems to be solved by the invention]
By the way, in the conventional XPath addition method, a deterministic automaton for processing the XPath is separately generated every time the XPath is added. For this reason, every time XPath is added, the number of deterministic automata increases, and as a result, there is a problem that the memory space of the computer constituting the filter engine is compressed. In particular, the problem becomes conspicuous when a lot of XPath is added.
[0004]
Accordingly, the present invention mainly provides an XPath processing method, an XPath processing device, an XPath processing program, and a storage medium storing the program that can effectively use the memory space for the addition of XPath. And
[0005]
[Means for Solving the Problems]
In view of the above problems, the present inventors have conducted intensive research and focused on the fact that the memory space can be effectively utilized by adding the difference of the XPath information to the existing DFA, thereby completing the present invention. It was.
[0006]
  [XPath processing method]
  That is, the present invention (Claim 1) that solves the above-described problem processes an XPath using an automaton.In XPath processing equipmentAn XPath processing method,The XPath processing apparatus isA step of generating a nondeterministic automaton (hereinafter referred to as “NFA”) from individual XPaths, and generating the combined nondeterministic automaton by integrating the generated nondeterministic automatonRegister to the storage deviceStep, inputIsGenerating a SAX event from the generated XML data, and generating a deterministic automaton (hereinafter referred to as “DFA”) using the combined non-deterministic automaton according to the generated SAX eventRegister to the storage deviceThe XPath to be added when there is an XPath addition.After converting to a non-deterministic automaton and updating the non-deterministic automaton by adding the XPath, all the start tags from the XML root tag to the tag currently being processed are stored in order. To add the difference of the XPath information,It is characterized by.
[0007]
  According to this configuration, since only the difference of the XPath information to be added is added to the DFA generated so far (existing DFA), it is not necessary to generate a new DFA separately. For this reason, the memory space can be effectively used. In the embodiment of the invention described later, the XPath (individual XPath, XPath group) is generated by the inquiry parsing module of FIG. NFA, combined NFA, and DFA are generated by the automaton management unit (data extraction module) in FIG. The determination of the XPath addition request is performed in step S14 of the flow of FIG. The addition of the difference of the XPath information to the DFA corresponds to the processing performed in step S16 (DFA update 1) and step S22 (DFA update 2) in the flow of FIG.In this configuration, for example, as in the flow (DFA update 1) shown in FIGS. 6 and 7 of the embodiment described later, the XPath information to be added is added to the existing DFA as a difference. In an embodiment described later, labelStack holds a list of element names that are not completed (currently being processed) by the SAX event currently input (the tag specifies the position of the element). The root expresses the DFA route state. Further, current represents the current state of DFA. By the way, “order” in “start tag in order” includes ascending order, descending order, random order (no order is specified), and the like.
[0010]
  Further, the present invention (claims)2) Claims1'sIn the configuration, in each state in the DFA, a difference is added to the added XPath information based on a state flag indicating that the state has been updated based on information up to the number of XPaths. And
[0011]
According to this configuration, the state flag can reliably update the portion to be updated without waste. In the embodiment described later, the status flag corresponds to varId.
[0014]
  Further, the present invention (claims)3) Claims1Or claim2When the state transition in the DFA is performed, the state flag of each state in the current DFA is checked. If the state is not updated based on the latest XPath, the state flag is used to check the state flag. The XPath added after the state is updated is specified, and the deterministic automaton is updated using the state of the NFA corresponding to the specified XPath.
[0015]
In this configuration, for example, an XPath is added as shown in FIG.
[0016]
[XPath processing equipment]
  Further, the XPath processing apparatus of the present invention (claims)4) EnterIsMeans for generating a SAX event from the XML data, means for converting individual XPaths based on user search conditions into NFA, integrating the generated NFA to generate a combined NFA, and registering it in a storage device; In response to the SAX event, there is a means for generating a DFA using the registered combined NFA and registering it in a storage device, and an XPath addition request.After updating the NFA by adding the XPath, by sequentially inputting all the start tags from the XML root tag stored in advance to the tag currently being processed to the NFA,And means for adding a difference in XPath information.
[0017]
  According to this configuration, since only the difference of the XPath information is added to the existing DFA, there is no need to generate a plurality of DFAs. Therefore, the memory space can be effectively used. In the embodiment described later, the filter engine corresponds to an XPath processing device. The XML parsing module corresponds to a means for generating a SAX event. The inquiry parsing module corresponds to a means for generating individual XPaths and adding XPaths to be added. In addition, the automaton management unit corresponds to a unit that performs conversion of XPath to NFA, generation of combined NFA, generation of DFA, and addition of difference of XPath information to DFA.Further, in this configuration, for example, as in the flow (DFA update 1) shown in FIGS. 6 and 7 of the embodiment described later, the difference of the XPath information to be added is added to the existing DFA.
[0020]
  [XPath processing program]
  Further, the XPath processing program of the present invention (claims)5) Is a computer to process XPath using automataXPath processing deviceIn addition,The XPath processing method according to any one of claims 1 to 3.It is made to perform.
[0021]
According to this configuration, the computer in which this program is installed is caused to execute each step based on the program, and XPath processing (DFA differential update) is performed.
[0022]
  [Storage medium storing XPath processing program]
  A storage medium storing the XPath processing program of the present invention (claims)6)Claim 5An XPath processing program is stored.
[0023]
This XPath processing program is copied and recorded on a recording medium such as a CD-ROM and distributed in the market, or transmitted over a network, for example. Then, the computer in which this program is installed is caused to execute XPath processing (DFA differential update).
[0024]
DETAILED DESCRIPTION OF THE INVENTION
Hereinafter, an embodiment (embodiment) of the XPath processing method of the present invention will be described in detail with reference to the drawings. Note that the XPath processing method described below also embodies an XPath processing apparatus and an XPath processing program.
[0025]
FIG. 1 is a diagram showing an outline of a filter engine to which the XPath processing method is applied.
XML data generated according to the XML format by a data provider (not shown) is transmitted to the filter engine 10 that executes the XPath processing method via a network such as an intranet. In the filter engine 10, each user who receives XML data registers in advance the data condition (personal profile) he wants in the filter engine 10 in the form of an XML query as in the conventional example.
[0026]
The filter engine 10 filters and converts XML data such as a news source sent according to the registered personal profile, and distributes the converted XML data to individual users. A specific example of XML data such as a news source is NewsML. As mentioned above, NewsML is a new news distribution format based on XML, which can freely combine news materials such as news articles, images, videos, and voices, and send information to various devices such as websites and mobile phones. be able to. It is also suitable for structuring and centrally managing various news materials such as news articles, images, videos, and voices.
[0027]
The filter engine 10 also includes an XPath processing device and an XPath processing program. Incidentally, XML is a meta language recommended by the World Wide Web Consortium (W3C) as an Internet standard. Meta language means the language that makes a language. XML data (also referred to as an XML document [XML Document]) is a document or data created using a language created by XML.
[0028]
FIG. 2 is a block diagram showing an internal configuration of the filter engine 10 of FIG. As shown in FIG. 2, the filter engine 10 includes an XML parsing module 11, an inquiry parsing module 12, a data extraction module 13, a storage device 14, an automaton management unit 15, and a data conversion module 16. It is assumed that the automaton management unit 15 includes the data extraction module 13 and the storage device 14. Incidentally, the filter engine 10 includes a main control device composed of a CPU and a RAM, an external storage device composed of a hard disk, a computer having a NIC (Network Interface Card) for communication, and a router. Consists of.
[0029]
The XML parsing module (XML parser) 11 parses input XML data, converts it into internal format XML data (SAX event), and outputs it to the data extraction module 13. Note that parsing is analysis processing that reads XML data described in a text format and analyzes document elements, attributes, and the like specified by XML tags (in the present invention, parsing procedures are particularly limited). Not a thing). Incidentally, API (Application Programming Interface) for manipulating XML data through the XML parsing module 11 includes two types of standard interfaces, DOM (Document Object Mode) and SAX (Simple API for XML). In this embodiment, the XML parsing module 11 corresponds to the latter SAX. Note that the XML parsing module 11 corresponding to SAX sequentially reads XML data and starts various handlers added in each time an XML tag (start tag, end tag, empty element tag) is detected. Here, the handler is a program that defines a method for processing each element of XML data based on the SAX interface. Further, the tag is a character string described in the XML data for clearly indicating the position of the element and storing the attribute.
[0030]
The inquiry parsing module 12 parses (analyzes) the personal profile to be added (search condition described in the XML inquiry language), and performs “data conversion operation” and data extraction operation “XPath (XPath group / individual XPath)”. ) ”. XPath is output to the data extraction module 13, and the data conversion operation is output to the data conversion module 16. XPath (XML Path Language) is a language indicating a specific part of XML data. If XPath is used, an arbitrary position in the data can be indicated even if no anchor or the like is embedded in the XML data.
[0031]
The data extraction module 13 converts each XPath input from the inquiry parsing module 12 into NFA (generates NFA) and registers / adds it to the storage device 14. Further, the data extraction module 13 sequentially generates / updates DFA using NFA in accordance with the SAX event input from the XML parsing module 11. Then, the data extraction module 13 outputs the partial XML extracted from the input XML data to the data conversion module 16 as internal format XML data (filtered internal format XML data) using DFA.
[0032]
Incidentally, an automaton is a general term for a model that mathematically represents a calculation mechanism such as a computer, and has an input, an output, and a state. Among these, DFA (deterministic automaton) is an automaton in which a transition destination (transition destination) with respect to an input is determined to be one. On the other hand, an NFA (nondeterministic automaton) is an automaton in which a plurality of transition destinations (transition destinations) for an input exist in a certain state.
[0033]
The detailed functions of the automaton management unit 15 including the data extraction module 13 and the storage device 14 will be described in detail later with reference to the drawings.
[0034]
The data conversion module 16 performs a predetermined conversion from the data conversion operation and the extracted XML data in the internal format, and outputs the result as filtered XML data (converted XML data). The predetermined conversion is not particularly limited in the present invention.
[0035]
Next, the automaton management unit 15 will be described in detail.
FIG. 3 is a diagram showing a data structure on the memory of the automaton management unit 15 in FIG. Details of the DFA are shown in FIG.
[0036]
As shown in FIG. 3, an NFA is generated for each XPath. The plurality of NFAs generated in this way are combined by one node, and connected to each NFA from the root by an epsilon edge (combined NFA). The epsilon edge is an “empty character string” normally defined in an automaton, for example.
The DFA uses a combined (integrated) NFA and sequentially generates / updates necessary states according to the input of XML data.
[0037]
FIG. 4 is a diagram showing a data structure on the specific program of FIG. In FIG. 4, a variable class (class variable) is a class that generates an instance for each XPath, and has the following attributes.
* "Id" which is an internal identifier that is different for each instance
* "Xpath" which is an individual XPath expression
* "VarName" which is a name for distinguishing Variable from the user Note that an instance refers to an object actually created using a class definition as a model in object-oriented programming, for example.
[0038]
The State class (class State) is a class that expresses the state of the NFA and has the following attributes.
* A set of edges “edges” representing transitions from one state to another
* "Type" indicating whether the terminal is in a terminal or non-terminal state
When the expression of XPath is converted to NFA, the last state is assumed to be a termination, and the other states are assumed to be non-termination.
* "Var" indicating from which Variable instance (that is, from its xpath) its state was created
[0039]
The DFAState class (class DFAState) represents the state of the DFA, the State class is defined using object-oriented inheritance, and has the following attributes.
* “States” that expresses the NFA state group that is required when generating a DFA using NFA
* In order to speed up the XPath addition process, “variId”, which is the maximum id of Variable indicating that the own state has been generated in consideration of up to XPath corresponding to which Variable instance.
This varId corresponds to the “state flag” in the claims, and expresses in what state in the DFA it has been updated based on the information up to the XPath.
Although “edges” is inherited from the “State” class, it can be redefined using a hash or map structure instead of “list” in order to increase the processing speed.
[0040]
The Edge class (class Edge) represents an edge between NFA state states or an edge between DFA states, and has the following attributes.
* State "to" that is the edge destination of its own edge
* State "from" which is the edge source of its own edge
[0041]
In addition, the following variables are used as global variables.
* “GMaxVarId”, which represents the id of the most recently created Variable instance in order to pay out the variable instance id.
* When processing an endElement event that is a SAX event, it is necessary to return the state transition of the automaton, and as a result, it is necessary to manage the path from the root state of the automaton to the current state. "StateStack" representing this state list
* In this embodiment, since the difference of XPath is added, an element name list that is not completed by the SAX event that is currently input (that is, startElement is input but endElement is not input) is held. "LabelStack" representing this element name list
* "Root" expressing the DFA route status
* "Current" that expresses the current state in DFA
[0042]
FIG. 5 is a diagram illustrating a data structure on the memory of the DFA of FIG. However, in FIG. 5, unlike FIG. 4, a map structure is used instead of a list in order to realize “edges”.
[0043]
DFAState located on the left side of FIG. 5 is an instance of the DFAState class, and expresses one state of DFA. In the state of FIG. 5, the values of states, edges, type, var, and varId that are attribute values are set.
Here, states represents an NFA state group. edge represents a set of a reference to an edge label and an edge instance. Since type is non-terminal, it is “non-terminal”. var is a reference to a Variable instance. In this example, varId is 3, which means that this DFAState reflects the state up to the third variable (XPath).
[0044]
An Edge instance group is located in the middle (left middle) of FIG.
Also, a DFAState instance group corresponding to Edge's child transition destination is located in the middle right of FIG. As shown in FIG. 5, the transition destination of Edge is allowed to be Null (DFAState is not generated).
[0045]
[Process flow]
6 to 9 are diagrams illustrating a processing flow in the present embodiment. Hereinafter, the present invention will be described more specifically with reference to the flow.
[0046]
FIG. 6 is an overall processing flow of the XPath processing method.
In the process of step S11 at the highest level, gMaxVarId, stateStack, and labelStack are initialized. Note that the number of XPaths is set in gMaxVarId. In the next step S12, an NFA is generated from each initially registered XPath (XPath group) and registered (updated) in the automaton management unit 15 (storage device 14).
[0047]
In the process of the next step S13, the generated NFA groups are integrated to generate a combined NFA (see the middle diagram in FIG. 3). Also, the root state of the DFA is generated and set to rootState and current. These settings are stored in the storage device 14 of the automaton management unit 15.
[0048]
In the next selection condition process, it is determined whether there is an XPath addition request. Specifically, if there is an XPath addition request in step S14, the addition of XPath is accepted in step S15, and the "DFA update 1" subroutine processing is performed in step S16. “DFA update 1” is the processing shown in FIG. 7, but will be described later. On the other hand, if there is no request for adding an XPath in step S14, the process proceeds to step S17.
[0049]
In the selection condition process of step S17, a SAX event from the input XML data is awaited. In step S18, when there is a SAX event, it is determined whether the SAX event is endEvent or startEvent. If the SAX event is startEvent (startElement, startDocument), it is determined whether or not the transition destination state corresponding to the SAX event is in DFA (step S19). If the destination state is not generated (Null) (No, if not), the DFA transition destination state is generated with reference to the NFA in step S20. In step S20, gMaxVarId is set to varId, which is a status flag. As a result, varId expresses in what state in the DFA it has been updated based on the information up to which XPath. These are reflected in the update of the automaton management unit 15. Then, the process proceeds to step S23.
[0050]
On the other hand, if the state of the transition destination corresponding to the SAX event is DFA (generated, Yes) in step S19, it is determined whether varId of the state after transition is equal to gMaxVarId (step S21).
[0051]
On the other hand, if they are not equal as determined in step S21 (No), the process proceeds to step S23 after performing “DFA update 2” in step S22. Note that “DFA update 2” is the processing shown in FIG. 8, but will be described later. If it is determined in step S21 that varId and gMaxVarId are equal (Yes), the process proceeds to step S23.
[0052]
In step S23, current is stacked in stateStack (adding one item), the tag name of StartEvent is stacked in labelStack (adding one item), and current is set in State after transition. Also, SAX events are output as necessary. And it transfers to step S25 and outputs a result (output internal format XML data).
[0053]
By the way, if the SAX event is endEvent (endElement, endDocument) in step S18, the stackState is popped in step S24, the result is set to current, and the labelStack is popped. Also, SAX events are output as necessary. Note that pop means extracting the last addition. After processing step S24, the process proceeds to step S25 to output the result (output internal format XML data).
[0054]
Then, in step S26, it is determined whether or not the process is completed. If the process is not completed (No), the process proceeds to step S14 to continue the process. When it is the end (Yes), the process shifts to End to end the process.
[0055]
FIG. 7 is a processing flow of the subroutine “DFA update 1” in step S16 of FIG.
The process of the first step S161 is incremented by adding 1 to gMaxVarId since one XPath is added (addition of a new XPath) as shown in the flowchart of FIG. In the processing of the next step S162, an NFA is generated from the added new XPath (added XPath) and added (inserted) to the combined NFA of the automaton management unit 15.
[0056]
In the process of the next step S163, a loop variable I to be used later is initialized (I = 0). Also, set the root state of the generated NFA to a temporary variable states, add states to the states of the rootState, add the edge (s) originating from the stateS to the edges of the rootState, and set gMaxVarId to the rootState's varId, Set rootState in current.
[0057]
In the determination processing in the next step S164, the loop variable I is set to labelStack. It is determined whether or not it is smaller than (or less than) size. If it is smaller (Yes), the I-th element is extracted from labelStack in step S165, and a start event (startElement, startDocument) is generated.
[0058]
In the determination process of the next step S166, the equivalence between varId and gMaxVarId of the transition destination state that is changed by the generated SAX event is determined. Specifically, if both are equal, the process proceeds to step S168. If they are not equal, in step S167, the transition destination states (states, edges, VarId) are updated as follows.
[0059]
That is, in step S167, the result of transit (states, transition destination varId, input SAX event) is set in the temporary variable newStates. The process of transit will be described with reference to FIG. In S167, as a result, the current DFA state is updated.
[0060]
Specifically, newStates is added to the state of the transition destination. The result of getEdges (newStates) is added to the transition destination edge. Set gMaxVarId to the destination varId. This means that the transition destination state is update completion. Incidentally, getEdges is a function that extracts all edge groups connected to the parameter newStates.
[0061]
In the next step S168, current is stacked on stateStack, the tag name is stacked on labelStack, and current is set to the state after transition.
[0062]
In the next process of step S169, the loop variable I is incremented, and the process returns to the loop determination process of step S164. In step S164, the loop variable I is set to labelStack. If it is not smaller than size (No), the process is terminated and the process returns to step S16 in FIG. 6 (Return, step S170).
[0063]
FIG. 8 is a flowchart showing the processing of the subroutine “DFA update 2” in step S22 of FIG.
In the processing of FIG. 8, the statuses, edges, and varId of the transition destination state are updated. That is, the result of transit (states, transition destination varId, input SAX event) is set in the temporary variable newStates. The process of transit will be described with reference to FIG. In this “DFA update 2”, the current DFA state is updated as a result.
[0064]
Specifically, in “DFA update 2”, newStates is added to the transition destination states. Deduplicate the entry of the transition destination states. The result of getEdges (newStates) is added to the transition destination edge. Set gMaxVarId to the destination varId. This means that the transition destination state is update completion. Incidentally, getEdges is a function that extracts all edge groups connected to the parameter newStates.
[0065]
FIG. 9 is a diagram showing a flow showing processing of the function “transit” used in FIGS. 7 and 8.
The input (parameter) in step S41 in the flow of FIG. 9 includes three (states (NFA state group)), VarId (variable instance attribute id value), and input SAX event.
[0066]
In the next step S42, the loop variable I is initialized (I = 0), and the calculation result storage area rstates is initialized. In the determination process of the next step S43, the loop variable I is set to states. It is determined whether it is smaller than size. I is state. If smaller than size (Yes), in step S44, the I-th element is extracted from the states and set in the temporary variable state, and the attribute var is set in the temporary variable vvar.
[0067]
In the determination process in the next step S45, it is determined whether or not the id of vvar is larger than the transition destination varId. If the id of the vvar exceeds the transition destination varId (Yes), as shown in step S46, all the NFA states that can be shifted from the state by the input SAX event are added to rstates, and the process proceeds to step S47. On the other hand, if the id of vvar is less than or equal to the transition destination varId (No), the process proceeds to step S47 as it is.
[0068]
In the process of the next step S47, the loop variable I is incremented, and the process proceeds to step S43 to return to the loop determination condition. In step S43, the loop variable I is set to states. If it is not smaller than size (No), the transit function is terminated and restates is returned. That is, it is substituted for NewStates in FIGS.
[0069]
[State of the automaton manager corresponding to the operation]
Next, an operation example of the XPath processing method of the present embodiment will be described more specifically.
10 to 14 are diagrams cited for explaining an operation example of the XPath processing method. Among these, FIG. 10 is a diagram showing the time of operation of the XPath processing method. FIGS. 11-14 illustrate the internal state of the automaton manager that changes at each point in time.
[0070]
First, in FIG. 10, the following 1. in the XPath processing method in this embodiment will be described. ~ 4. The time points of the four operations are shown.
1. When two XPath "/ a / b" and "/ a // c" are registered
2. After that, when XML is input halfway (<a> <b> <c /> <d>)
3. When XPath "/ a // d" is added
4). After that, when XML input is continued (test </ d> </ b> <d /> </a>)
[0071]
FIG. It is the figure which illustrated the mode inside the automaton management part in the time of. As shown in the upper diagram of FIG. 11, two XPaths, “/ a / b” and “/ a // c”, are registered. As described above, the XPath is separated and generated from the personal profile by the inquiry parsing module 12 (see FIG. 2).
[0072]
The NFA in the middle diagram of FIG. 11 shows an NFA (combined NFA) in which the two XPaths in the upper diagram are converted and connected to the root node. In the middle diagram, seven states and six edges connecting them are shown. Here, a double circle indicates a terminal state, and a single circle indicates a non-terminal state. Arrows are edges, each indicating a tag to be accepted. Also, ε represents the epsilon transition, * is an arbitrary tag, and (a, b, c) other than that represents the tag name itself.
[0073]
In the DFA in the lower diagram of FIG. 11, a root node is generated, and {0, 1, 4} is set as an NFA state group. This corresponds to a group of NFA states that can transition from the root state 0 of the NFA to the transition of the epsilon. Since only the edge a is connected to {0, 1, 4}, a is generated as an edge, and the transition destination is null. Note that “2” is shown at the top of the state in the DFA, which indicates varId, which is a state flag. Here, since the number of XPaths is 2, as shown in the upper diagram, varId is set to 2.
[0074]
12 is the same as FIG. This illustrates an internal state of the automaton management unit at the point of time. The difference from FIG. 11 is the DFA part in the lower diagram, and 2 in FIG. As shown in FIG. 4, the necessary DFA states and edges are generated by the XML inputs <a> <b> <c /> <d>.
[0075]
Since the NFA state group {0, 1, 4} in the root state of the DFA and the NFA state group that can be transferred by the XML input <a> are {2, 5}, the DFA state is generated. Since the edge group connected to {2, 5} is {b, c, *}, {b, c, other} is generated as an edge and connected to the DFA state. The transition destination is initially null.
[0076]
Similarly, the state and edge of the DFA are appropriately generated based on the XML input <b> <c /> <d>. Specifically, since the NFA state that can be transitioned by the input <b> is {3, 5}, the DFA state is generated. Since the edge group connected to {3, 5} is {c, *}, {c, other} is generated as an edge and connected to the DFA state. The transition destination is initially null. Next, input <c /> and input <d> are processed in order.
[0077]
13 is the same as FIG. This illustrates an internal state of the automaton management unit at the point of time. In the upper part of FIG. As shown in FIG. 6, one “/ a // d” is added as the XPath. In the middle diagram of FIG. 13, an NFA corresponding to the added XPath "/ a // d" is added. Specifically, states 7, 8, and 9 and edge groups related to them.
[0078]
In the DFA in the lower diagram of FIG. 13, updating according to the processing flows of FIGS. 6 to 9, that is, a process of adding a difference in the added XPath information to the DFA generated so far is executed.
[0079]
First, the route state 7 of the added XPath NFA is added to the DFA route state. Also, since the XPath to be processed is the third case, the status flag varId is incremented to 3.
[0080]
Since {a, b, d} is stacked in labelStack at this time, SAX events are generated and shifted in the order of a, b, d from the DFA root state. First, the next state is updated and changed by a. In this way, 8 is added to the states to become {2, 5, 8}, and d is added as an edge.
Next, the next state is updated and transferred by b. In this way, 8 is added to the states to become {3, 5, 8}, and d is added as an edge.
[0081]
Next, the next state is updated and changed by d. In this way, as shown in the lower diagram of FIG. 13, 5,8,9 is added to the states to become {5,8,9}. The state varIds in these updated DFAs are all incremented to 3.
[0082]
14 is the same as FIG. The state inside the automaton management unit at the time of is illustrated. In FIG. 14, one edge d is added to the DFA with respect to FIG. 13 showing the previous state.
[0083]
In the XPath processing method described above, when an XPath is added, it is converted to generate an NFA, and an epsilon edge is set to the root node from the root node of the existing NFA. Then, by sequentially inputting all start tags from the XML root tag held in advance to the tag currently being processed to the DFA, the state of the DFA is sequentially updated. That is, the difference of the added XPath information is added to the existing DFA. Therefore, by updating one DFA, it becomes possible to use the memory space more efficiently than in the existing technology in which a plurality of DFAs are generated. By the way, in the past, taking Fig. 12 as an example, if XPath is added, a new DFA corresponding to the added XPath "/ a // d" is generated separately from the existing DFA and compresses the memory space. However, in the present invention, such a duplicate DFA is not generated.
[0084]
At this time, in each state in the DFA, processing is performed using the state flag varId that represents how many times the XPath has been updated, so that the XPath addition processing (for the existing DFA) The addition of the difference of the XPath information to be added) can be performed reliably and at high speed.
[0085]
Also, as shown in FIGS. 6, 7, 13, 14, and the like, when performing state transition in the DFA, the state flag varId of each state in the current DFA is checked, and the state is based on the latest XPath. If the XPath added after the state is updated using the state flag varId and the DFA is updated using the state of the NFA corresponding to the specified XPath, the memory space Can be used effectively, and XPath addition processing can be performed reliably and at high speed.
[0086]
Also, in the present embodiment, labelStack, which is an element name list that has not been completed by the currently input SAX event (startElement has been input but endElement has not been input), is held. For this reason, the XPath addition process can be performed reliably and at high speed.
[0087]
The present invention is not limited to the above-described embodiment, and can be widely modified. For example, NewsML is an example, and XML data is not limited to NewsML. For example, the XML data may be NITF (News Industry Text Format) data. The filter engine 10 is installed by, for example, an ASP (Application Service Provider) for a company or an individual user, or a company, an organization, or the like is installed for an employee or a member of the company. Further, the means / method for adding the difference of the XPath information for the DFA shown in the above embodiment is an example, and the present invention is not limited to the means / method for adding the difference shown in the above embodiment. The above-described flow or the like is transmitted as an XPath processing program over a network, or stored and distributed in a storage medium such as a CD-ROM.
[0088]
【The invention's effect】
  According to the present invention described above, there are excellent effects as exemplified below.
  That is,The present inventionSince the existing DFA is used, the memory space of the computer can be used efficiently. Also, SureIn fact, the difference of the XPath information with respect to the DFA can be added, and the memory space can be used more efficiently. Also, AddIt is possible to specify a portion to be added (updated) and reliably add a difference without waste. Therefore, the memory space can be used more efficiently. Also, YoThe difference can be added more reliably. Therefore, the memory space can be used more efficiently. Also, AddIt is possible to reliably add a difference to a portion to be added (a portion to be updated) without further waste. Therefore, the memory space can be used more efficiently.
[0089]
  Also,The present inventionAccording to the above, since only the difference is added to the information of the additional XPath in the existing DFA, it is not necessary to generate a plurality of DFAs. Therefore, it is possible to effectively use the memory space of the computer. Also,BookAccording to the invention, the difference addition can be more reliably performed. Therefore, the memory space can be utilized more efficiently.
[0090]
  Also,The present inventionThe XPath processing program and the storage medium storing the program cause the computer in which the program is installed to execute each step based on the program to add the difference of the XPath information. Therefore, it is possible to effectively use the memory space of the computer.
[Brief description of the drawings]
FIG. 1 is a diagram showing an outline of a filter engine to which an XPath processing method according to an embodiment of the present invention is applied.
2 is a block diagram showing an internal configuration of the filter engine of FIG. 1. FIG.
3 is a diagram showing a data configuration on a memory of the automaton management unit in FIG. 2; FIG.
4 is a diagram showing a data structure on the specific program of FIG. 3; FIG.
FIG. 5 is a diagram showing a data configuration on the memory of the DFA of FIG. 4;
FIG. 6 is an overall processing flow of an XPath processing method.
7 is a processing flow of subroutine DFA update 1 in FIG. 6;
FIG. 8 is a processing flow of subroutine DFA update 2 in FIG. 6;
FIG. 9 is a flow showing processing of a function “transit” used in FIGS. 7 and 8;
FIG. 10 is a diagram illustrating a time point of operation of the XPath processing method according to the embodiment of the present invention.
FIG. It is the figure which illustrated the mode inside the automaton management part in the time of.
12 is a diagram of FIG. It is the figure which illustrated the mode inside the automaton management part in the time of.
13 is a diagram of FIG. It is the figure which illustrated the mode inside the automaton management part in the time of.
14 is the same as FIG. It is the figure which showed the mode inside the automaton management part in the time of.
[Explanation of symbols]
10. Filter engine (XPath processing device)
11 ... XML parsing module
12 ... Inquiry parsing module
13 ... Data extraction module
14 ... Storage device
15 ... Automaton Management Department
16 ... Data conversion module

Claims (6)

An XPath processing method in an XPath processing apparatus that processes XPath using an automaton,
The XPath processing apparatus is
Generating a non-deterministic automaton from individual XPaths;
Integrating the generated non-deterministic automaton to generate a combined non-deterministic automaton and registering it in a storage device ;
Generating SAX events from the input XML data,
In response to the generated SAX event, generating a deterministic automaton using the combined non-deterministic automaton and registering it in a storage device ,
When XPath is added, the added XPath is converted into a non-deterministic automaton, the non-deterministic automaton is updated by adding the XPath, and the current processing is performed from the XML root tag held in advance. Adding the difference of XPath information by inputting all start tags up to the inside tag in order to the deterministic automaton,
An XPath processing method characterized by the above. In each state in the deterministic automaton, adding the difference of the added XPath information based on a state flag indicating that the state has been updated based on information up to what number XPath,
The XPath processing method according to claim 1 . When performing state transition in the deterministic automaton, check the state flag of each state in the current deterministic automaton,
If the state is not updated based on the latest XPath, the state flag is used to identify the XPath added after the state is updated, and the state of the non-deterministic automaton corresponding to the identified XPath Updating deterministic automata using
XPath processing method according to claim 1 or claim 2, characterized in. Means for generating SAX events from the input XML data,
Means for converting individual XPaths based on a user's search condition into non-deterministic automata, integrating the generated non-deterministic automata to generate a combined non-deterministic automaton and registering it in a storage device;
Means for generating a deterministic automaton using the registered non-deterministic automaton registered in response to the SAX event and registering it in a storage device;
When there is an XPath addition request, a non-deterministic automaton is generated from the Xpath to be added, and after updating the non-deterministic automaton by adding the XPath, currently processing from the XML route tag held in advance Means for sequentially adding all of the start tags up to the tag to the deterministic automaton, thereby adding a difference in the XPath information;
An XPath processing apparatus comprising: An XPath processing program that causes an XPath processing apparatus , which is a computer , to execute an XPath processing method according to any one of claims 1 to 3 in order to process XPath using an automaton. A storage medium storing the XPath processing program according to claim 5 .

Images