JP4796970B2 - Tree data search / aggregation / sorting method and program - Google Patents

Description

  The present invention relates to a method for handling a tree-type data structure, and more particularly to a method for searching / aggregating / sorting data having a tree-type data structure. The present invention also relates to an information processing apparatus that implements such a method. Furthermore, the present invention relates to a program for executing such a method and a recording medium on which the program is recorded.

  Databases are used for various purposes, but in medium to large-scale systems, the use of relational databases (RDB) that can eliminate logical contradictions is the mainstream. For example, RDB is used in a system such as airplane seat reservation. In this case, by specifying a key item, it is possible to quickly search for a target (in many cases, one), or to confirm, cancel or change a reservation. In addition, since the number of seats for each flight is at most several hundred, it is possible to obtain the number of vacant seats for a specific flight.

  Such an RDB is known to be suitable for handling tabular data, but not suitable for handling tree data (see, for example, Non-Patent Document 1).

  Furthermore, there are some applications in which the representation in the tree format is more suitable than the representation in the table format. In particular, in recent years, XML that employs a tree-type data structure has become widespread as a data standard for intranet and Internet applications (see, for example, Non-Patent Document 2 for details of XML).

  However, handling of tree-type data structures, for example, retrieval of tree format data, is generally very inefficient. The first reason for this inefficiency is that it is difficult to immediately identify the location where the data should exist, because the data is distributed in various nodes. In the RDB, for example, the data “age” is stored only in the item “age” of a certain table. However, in the tree-type data structure, nodes holding data “age” are scattered in various places. Generally, if the entire tree-type data structure is not examined, the corresponding data can be searched. Can not.

  The second reason for the inefficiency is that it takes time to express the search results. If you try to express a node group that hits the search, you must also express a node that is a descendant of that node, but unlike RDBMS, the data structure is atypical, so it takes time to express the descendant nodes. Take it.

  Therefore, in order to take advantage of the RDB which is the mainstream of the database, conventionally, a method of converting the tree format data into an RDB when the tree data structure is converted into a database has been proposed (for example, see Patent Document 1). In the RDB, data is stored after being decomposed into tables. Therefore, in order to convert the actual tree format data into RDB, it is necessary to push the tree format data into the table. However, in order to handle various tree-type data structures, the system design must be performed by pushing data into the table individually for each structure. Therefore, system construction based on RDB is a very time-consuming work.

  On the other hand, a method of creating a database of tree format data, particularly XML data as it is, has been proposed. In the case of a tree-type data structure, descendant nodes can be hung from one node, and various expressions are possible, so that the time and effort for system design can be greatly reduced. Accordingly, there is an increasing need for processing tree format data with a technique capable of handling a tree structure such as XML as a core.

  An example of an approach for creating a database of XML data as it is is to take a copy of the data written in the tree structure. For example, if the item is “age”, search index data for “age” is used. It is held separately (see, for example, Patent Document 2). As a result, the advantage of XML data that attributes can be added to the data itself is fully utilized, and the relational structure of each item expressed using tags can be stored as it is.

Also, an object model interface called DOM for expanding an XML document on a memory in a tree structure is disclosed (for example, see Non-Patent Document 3).
JP2003-248615A JP 2001-195406 A SECK Co., Ltd., “Karearea White Paper”, [online], [Search February 19, 2004], Internet <URL: http://www.sec.co.jp/products/karearea/> W3C, "Extensible Markup Language (XML) 1.0 (ThirdEdition)", [online], February 4, 2004, [February 19, 2004 search], Internet <URL: http://www.w3.org / TR / 2004 / REC-xml-20040204 /> R. Alan Wyke, Brad Lupen, Sultan Luman, "Programming XML", Nikkei DP Soft Press, 2002, p. 59-84

  However, in the approach of separately holding the index data for search described above, at least the data is held twice, and the cost for creating the index and the data area for storing the index are required. Is disadvantageous in holding.

  Even if a search is actually performed and a node is specified by such a mechanism, it takes time to express the node. In addition, this mechanism is used for a search in which the relation between nodes is a problem (for example, extraction of a tree including “age” “60 years old” as an ancestor and “age” “1 year” as a descendant). Can not.

  The fundamental problem of such prior art is that the tree-type data structure is expressed by connecting the nodes that store the data with pointers, focusing only on the individual data. For example, the relationship between parent and child, ancestor, descendant, sibling (sibling), generation, etc. cannot be traced efficiently. In other words, since the value of the pointer is not constant, it can be used only for the purpose of indicating the data storage address, and the relationship between the nodes cannot be expressed directly. As a result, in the prior art, it has been difficult to search, aggregate, and sort data having a tree-type data structure. Further, the above DOM only defines an operation interface for editing the topology of the tree-type data structure, and does not define a specific method of operation.

  SUMMARY An advantage of some aspects of the invention is that it provides a method, an information processing apparatus, a program, and a recording medium on which a program is recorded, which can efficiently search, aggregate, and sort data having a tree-type data structure.

  To achieve the above object, according to the present invention, a parent-child relationship between nodes constituting a tree-type data structure is not a “parent → child” relationship in which a child node is associated with a parent node, but a “child” that associates a parent node with a child node. Based on the parent-child relationship expression expressed by the “parent” relationship, the data of the tree type data structure is searched, aggregated, and sorted.

Therefore, according to the present invention, a method for retrieving data of a tree-type data structure including a root node expanded in a storage device and a non-root node that is a node other than the root node is described in claim 1. As
A unique node identifier is assigned to all nodes including the root node, and the node identifier assigned to each parent node of the non-root node is associated with the node identifier assigned to each non-root node, thereby , The parent-child relationship between the nodes that make up the tree data structure is represented,
Each node is associated with at least one entity information representing data,
A condition specifying step for specifying a search condition for entity information;
For each node, it is determined whether the entity information associated with the node matches the search condition. If the information matches, the search hit information is associated with the node, and the parent-child relationship between the nodes is traced. A search step for associating search hit information with an ancestor node;
Have As a result, it is possible to specify the entity information, inspect the entire tree, and detect nodes that meet the conditions.

  When a parent-child relationship is expressed by a conventionally known “parent → child” relationship, a single parent node may correspond to a plurality of child nodes, so two elements of the parent node and the child node must be specified. A parent-child relationship cannot be defined. That is, even if a parent node is specified, a child node having a parent-child relationship with the parent node cannot be specified. On the other hand, when the parent-child relationship is expressed by the “child → parent” relationship as in the present invention, since only one parent node always corresponds to one child node, this child node can be specified by specifying the child node. The only parent node corresponding to the node can be immediately identified. As a result, data having a tree-type data structure can be retrieved at high speed.

  In particular, if node identifiers are defined by integers, an array that accommodates child node identifiers is not required when defining a parent-child relationship (that is, the topology of a tree-type data structure can be described by a single array). Memory usage is reduced and processing speed is increased. Preferably, the node identifier is an integer serial number.

The present invention also provides, as described in claim 2,
The partial tree is a group of nodes including a specific node of the tree-type data structure and descendant nodes of the specific node,
The condition specifying step includes a step of specifying at least one partial tree representing the search range,
After the search step, the method further includes a step of storing an identifier representing a partial tree including a node associated with the search hit information as a search result. Thereby, the search result is obtained as a list of identifiers representing the partial tree.

  In this way, when a specific node and descendant nodes of the specific node are handled together in the form of a partial tree, the search range can be specified and the search result can be expressed using the partial tree. So it is very convenient.

According to the present invention, there is provided a method for retrieving data of a tree-type data structure including a root node expanded in a storage device and a non-root node that is a node other than the root node. As
A unique node identifier is assigned to all nodes including the root node, and the node identifier assigned to each parent node of the non-root node is associated with the node identifier assigned to each non-root node, thereby , The parent-child relationship between the nodes that make up the tree data structure is represented,
Each node is associated with at least one entity information representing data,
The partial tree is a group of nodes including a specific node of the tree-type data structure and descendant nodes of the specific node,
Specifying a search condition for at least one entity information and specifying at least one subtree representing a search range;
For each partial tree, the parent-child relationship between the nodes is traced to determine whether at least one entity information associated with a node group belonging to the partial tree matches the search condition, and search hit information is sent to the matched node. A step of associating with
Have As a result, the specified partial tree is inspected, and the hit node can be obtained as a search result.

According to the present invention, there is provided a method for retrieving data of a tree-type data structure including a root node expanded in a storage device and a non-root node that is a node other than the root node. As
A unique node identifier is assigned to all nodes including the root node, and the node identifier assigned to each parent node of the non-root node is associated with the node identifier assigned to each non-root node, thereby , The parent-child relationship between the nodes that make up the tree data structure is represented,
Each node is associated with at least one entity information representing data,
The partial tree is a group of nodes including a specific node of the tree-type data structure and descendant nodes of the specific node,
Specifying a search condition for at least one entity information and specifying at least one subtree representing a search range;
For each partial tree, the parent-child relationship between the nodes is traced to determine whether at least one entity information associated with the node belonging to the partial tree matches the search condition. Storing an identifier representing the partial tree as a search result;
Have Thereby, entity information can be designated as a search condition, a partial tree can be inspected, and an identifier of the partial tree can be obtained as a search result.

According to the present invention, there is provided a method for retrieving data of a tree-type data structure including a root node expanded in a storage device and a non-root node that is a node other than the root node. As
A unique node identifier is assigned to all nodes including the root node, and the node identifier assigned to each parent node of the non-root node is associated with the node identifier assigned to each non-root node, thereby , The parent-child relationship between the nodes that make up the tree data structure is represented,
Each node is associated with at least one entity information representing data,
The partial tree is a group of nodes including a specific node of the tree-type data structure and descendant nodes of the specific node,
Specifying a search condition for at least one entity information and specifying at least one subtree representing a search range;
For each partial tree, an ancestor node of the partial tree is identified by tracing the parent-child relationship between the nodes, and at least one entity information associated with the specific node and / or ancestor node of the partial tree is the search condition. Determining whether they match and associating search hit information with the matched nodes;
Have Thereby, entity information is designated as a search condition, an ancestor node is inspected, and a node that matches the search condition can be obtained as a search result.

According to the present invention, there is provided a method for retrieving data of a tree-type data structure including a root node expanded in a storage device and a non-root node that is a node other than the root node. As
A unique node identifier is assigned to all nodes including the root node, and the node identifier assigned to each parent node of the non-root node is associated with the node identifier assigned to each non-root node, thereby , The parent-child relationship between the nodes that make up the tree data structure is represented,
Each node is associated with at least one entity information representing data,
The partial tree is a group of nodes including a specific node of the tree-type data structure and descendant nodes of the specific node,
Specifying a search condition for at least one entity information and specifying at least one subtree representing a search range;
For each partial tree, an ancestor node of the partial tree is identified by tracing the parent-child relationship between the nodes, and at least one entity information associated with the specific node and / or ancestor node of the partial tree is the search condition. Determining whether they match, and if there is a matching node, storing an identifier representing the partial tree as a search result;
Have Thereby, entity information can be designated as a search condition, an ancestor node can be inspected, and an identifier of a partial tree having an ancestor node hit in the search can be obtained as a search result.

Further, according to the present invention, the first search condition and the second search condition are used for the data of the tree type data structure including the root node developed in the storage device and the non-root node which is a node other than the root node. As described in claim 7, a method of searching by logically combining
A unique node identifier is assigned to all nodes including the root node, and the node identifier assigned to each parent node of the non-root node is associated with the node identifier assigned to each non-root node, thereby , The parent-child relationship between the nodes that make up the tree data structure is represented,
Each node is associated with at least one entity information representing data,
The partial tree is a group of nodes including a specific node of the tree-type data structure and descendant nodes of the specific node,
At least one subtree representing the search scope is specified,
In accordance with a first search condition that specifies at least one entity information, the parent-child relationship between the nodes is traced, and an identifier representing a partial tree to which a node that matches the first search condition belongs is stored as a first search result. Steps,
According to a second search condition designating at least one entity information, the parent-child relationship between the nodes is traced, and an identifier representing a partial tree to which a node that matches the first search condition belongs is stored as a second search result. Steps,
By executing a logical operation corresponding to the logical relationship between the first search condition and the second search condition on the first search result and the second search result, the first search condition and the second search condition Generating search results that are logically combined, and
Have Thereby, the search combining the search conditions is realized as a logical operation of the search by the individual search conditions and the search result of the individual search.

According to the present invention, there is provided a method for aggregating data of a tree type data structure including a root node expanded in a storage device and a non-root node which is a node other than the root node. As
A unique node identifier is assigned to all nodes including the root node, and the node identifier assigned to each parent node of the non-root node is associated with the node identifier assigned to each non-root node, thereby , The parent-child relationship between the nodes that make up the tree data structure is represented,
Each node is associated with at least one entity information representing data,
The partial tree is a group of nodes including a specific node of the tree-type data structure and descendant nodes of the specific node,
Specifying entity information representing a target of aggregation and specifying at least one partial tree representing a range of aggregation;
For each partial tree, the node group belonging to the partial tree is identified by tracing the parent-child relationship between the nodes, and it is determined whether there is a node associated with entity information representing the target of aggregation in the node group. And, if present, counting the entity information associated with the node;
Have This method realizes tabulation without specifying a dimension, that is, tabulation of measures in the subtree by explicitly specifying each subtree.

According to the present invention, a method for aggregating data of a tree-type data structure including a root node expanded in a storage device and a non-root node that is a node other than the root node is described in claim 9. As
A unique node identifier is assigned to all nodes including the root node, and the node identifier assigned to each parent node of the non-root node is associated with the node identifier assigned to each non-root node, thereby , The parent-child relationship between the nodes that make up the tree data structure is represented,
Each node is associated with at least one entity information representing data,
The partial tree is a group of nodes including a specific node of the tree-type data structure and descendant nodes of the specific node,
Specifying entity information representing a classification target for aggregation, specifying entity information representing an aggregation target, and specifying at least one partial tree representing a range of aggregation;
For each partial tree, the node group belonging to the partial tree is identified by tracing the parent-child relationship between the nodes, and it is determined whether there is a node associated with entity information representing the target of aggregation in the node group. And, when present, summing up entity information associated with the node for each entity information representing a classification target of aggregation related to a node group belonging to the partial tree;
Have This method can aggregate the measures in the partial tree by specifying the aggregation target = measure, the aggregation range = category, and the classification target = dimension.

Further, according to the present invention, there is provided a method for ordering at least two node groups of data of a tree type data structure including a root node expanded in a storage device and a non-root node that is a node other than the root node. As described in claim 10,
A unique node identifier is assigned to all nodes including the root node, and the node identifier assigned to each parent node of the non-root node is associated with the node identifier assigned to each non-root node, thereby , The parent-child relationship between the nodes that make up the tree data structure is represented,
Each node is associated with at least one entity information representing data,
The partial tree is a group of nodes including a specific node of data of a tree-type data structure and descendant nodes of the specific node,
Designating entity information representing a target of aggregation, specifying at least two partial trees representing a range of aggregation;
For each partial tree, the node group belonging to the partial tree is identified by tracing the parent-child relationship between the nodes, and it is determined whether there is a node associated with entity information representing the target of aggregation in the node group. And, if present, counting the entity information associated with the node;
Ordering the at least two partial trees according to the order relation of the item value information aggregated for each partial tree;
Have In this method, the partial tree can be sorted using the aggregation result.

Further, according to the present invention, there is provided a method for ordering at least two node groups of data of a tree type data structure including a root node expanded in a storage device and a non-root node that is a node other than the root node. ,
A unique node identifier is assigned to all nodes including the root node, and the node identifier assigned to each parent node of the non-root node is associated with the node identifier assigned to each non-root node, thereby , The parent-child relationship between the nodes that make up the tree data structure is represented,
Each node is associated with at least one entity information representing data,
The partial tree is a group of nodes including a specific node of data of a tree-type data structure and descendant nodes of the specific node,
Specifying at least two partial trees to be ordered, and specifying entity information to be an index of ordering;
For each partial tree, the parent-child relationship between the nodes is traced to identify a node group belonging to the partial tree, and the entity information associated with the node associated with the entity information serving as an index for ordering in the node group Step to get the
Ordering the at least two partial trees according to the order relation of the entity information acquired for each partial tree;
Have This method can sort partial trees using entity information.

  According to a preferred embodiment of the present invention, as described in claim 12, each entity information is item name information representing a data item or item value information representing a data item value.

  According to a preferred embodiment of the present invention, as described in claim 13, a partial tree including a specific node and descendant nodes of the specific node is represented by a node identifier of the specific node. . Thereby, a partial tree can be represented by one vertex node. It becomes possible to describe the result of the search and the target range of the search and aggregation by this vertex node.

  Also, in some preferred embodiments of the present invention, as described in claim 14, the unique node identifier given to all nodes including the root node gives priority to child nodes over nodes of the same generation. To be granted. By using such a depth-priority parent-child expression, it is possible to obtain an excellent property that a descendant node of a certain node appears in a continuous region of the parent-child expression, and it is possible to speed up the search, aggregation, and sort processing. is there.

  In another embodiment of the present invention, as described in claim 15, the data of the tree-type data structure includes a plurality of tree data to which a tree identifier is assigned. This makes it possible to process a plurality of tree data as search, aggregation, and sort targets.

An information processing apparatus that performs the method according to claims 1 to 15 is described in claims 16 to 30. An information processing apparatus according to the present invention includes a storage device that stores data of a tree-type data structure including a root node and a non-root node that is a node other than the root node. An information processing device for retrieving data stored in a storage device,
Assign a unique node identifier to all nodes including the root node and associate the node identifier assigned to each non-root node with the node identifier assigned to each parent node of the non-root node, thereby Data expansion means for expressing a parent-child relationship between nodes constituting a tree-type data structure, associating each node with at least one entity information representing data, and building a tree-type data structure on a storage device;
A condition specifying means for specifying a search condition for at least one entity information;
For each node, it is determined whether or not at least one entity information associated with the node matches the search condition. If the information matches, the search hit information is associated with the node, and the parent-child relationship between the nodes is traced. Search means for associating search hit information with an ancestor node of the node;
Have

In this information processing apparatus, as described in claim 17,
The partial tree is a group of nodes including a specific node of the tree-type data structure and descendant nodes of the specific node,
The condition specifying means includes means for specifying at least one partial tree representing a search range,
The search means includes means for storing an identifier representing a partial tree including a node associated with the search hit information as a search result.

An information processing apparatus according to claim 18 includes a storage device that stores data of a tree-type data structure including a root node and a non-root node that is a node other than the root node. An information processing device for retrieving stored data,
All nodes including the root node are given a unique node identifier in preference to the child node over the same generation node, and each parent node of the non-root node is assigned to the node identifier assigned to each non-root node As a result, the parent-child relationship between the nodes constituting the tree type data structure is expressed, and at least one entity information representing the data is associated with each node, and the tree type data structure is stored on the storage device. Data development means to build on,
A partial tree is a node group including a specific node of a tree-type data structure and descendant nodes of the specific node, specifies a search condition for at least one entity information, and specifies at least one partial tree representing a search range. Condition specifying means;
For each partial tree, trace a parent-child relationship between the nodes to identify a node group belonging to the partial tree, determine whether at least one entity information associated with the node group matches the search condition, A search means for associating search hit information with a matched node;
Have

The information processing apparatus according to claim 19 includes a storage device that stores data of a tree-type data structure including a root node and a non-root node that is a node other than the root node, and is stored in the storage device. An information processing device for retrieving stored data,
All nodes including the root node are given a unique node identifier in preference to the child node over the same generation node, and each parent node of the non-root node is assigned to the node identifier assigned to each non-root node As a result, the parent-child relationship between the nodes constituting the tree type data structure is expressed, and at least one entity information representing the data is associated with each node, and the tree type data structure is stored on the storage device. Data development means to build on,
A partial tree is a node group including a specific node of a tree-type data structure and descendant nodes of the specific node, specifies a search condition for at least one entity information, and specifies at least one partial tree representing a search range. Condition specifying means;
For each partial tree, trace a parent-child relationship between the nodes to identify a node group belonging to the partial tree, determine whether at least one entity information associated with the node group matches the search condition, Search means for storing an identifier representing the partial tree as a search result when a matching node exists;
Have

The information processing apparatus according to claim 20 includes a storage device that stores data of a tree-type data structure including a root node and a non-root node that is a node other than the root node, and is stored in the storage device. An information processing device for retrieving stored data,
Assign a unique node identifier to all nodes including the root node and associate the node identifier assigned to each non-root node with the node identifier assigned to each parent node of the non-root node, thereby Data expansion means for expressing a parent-child relationship between nodes constituting a tree-type data structure, associating at least one entity information representing data with each node, and constructing the tree-type data structure on a storage device;
A partial tree is a node group including a specific node of a tree-type data structure and descendant nodes of the specific node, specifies a search condition for at least one entity information, and specifies at least one partial tree representing a search range. Condition specifying means;
For each partial tree, an ancestor node of the partial tree is identified by tracing the parent-child relationship between the nodes, and at least one entity information associated with the specific node and / or ancestor node of the partial tree is the search condition. A search means for determining whether or not to match, and associating search hit information with the matched node;
Have

The information processing apparatus according to claim 21 includes a storage device that stores data of a tree-type data structure including a root node and a non-root node that is a node other than the root node, and is stored in the storage device. An information processing device for retrieving stored data,
Assign a unique node identifier to all nodes including the root node and associate the node identifier assigned to each non-root node with the node identifier assigned to each parent node of the non-root node, thereby Data expansion means for expressing a parent-child relationship between nodes constituting a tree-type data structure, associating at least one entity information representing data with each node, and constructing the tree-type data structure on a storage device;
A partial tree is a node group including a specific node of a tree-type data structure and descendant nodes of the specific node, specifies a search condition for at least one entity information, and specifies at least one partial tree representing a search range. Condition specifying means;
For each partial tree, an ancestor node of the partial tree is identified by tracing the parent-child relationship between the nodes, and at least one entity information associated with the specific node and / or ancestor node of the partial tree is the search condition. A search unit that determines whether or not a match is found, and stores a identifier representing the partial tree as a search result when a matching node exists;
Have

An information processing apparatus according to claim 22 includes a storage device that stores data of a tree-type data structure including a root node and a non-root node that is a node other than the root node, and the first search condition And an information processing apparatus that performs a logical combination of the second search condition and
Assign a unique node identifier to all nodes including the root node and associate the node identifier assigned to each non-root node with the node identifier assigned to each parent node of the non-root node, thereby Data expansion means for expressing a parent-child relationship between nodes constituting a tree-type data structure, associating at least one entity information representing data with each node, and constructing the tree-type data structure on a storage device;
The partial tree is a node group including a specific node of the tree-type data structure and descendant nodes of the specific node, and condition specifying means for specifying at least one partial tree representing a search range;
According to a first search condition that specifies at least one entity information, the parent-child relationship between the nodes is traced, and an identifier representing a partial tree to which a node that matches the first search condition belongs is stored as a first search result. In accordance with a second search condition designating at least one entity information, the parent-child relationship between the nodes is traced, and an identifier in which a node matching the first search condition represents a partial tree is stored as a second search result. Search means;
By executing a logical operation corresponding to the logical relationship between the first search condition and the second search condition on the first search result and the second search result, the first search condition and the second search condition A combination means for generating a search result that logically combines
Have

The information processing apparatus according to claim 23 includes a storage device that stores data of a tree-type data structure including a root node and a non-root node that is a node other than the root node, and is stored in the storage device. An information processing device for collecting collected data,
All nodes including the root node are given a unique node identifier in preference to the child node over the same generation node, and each parent node of the non-root node is assigned to the node identifier assigned to each non-root node As a result, the parent-child relationship between the nodes constituting the tree type data structure is expressed, and at least one entity information representing the data is associated with each node, and the tree type data structure is stored on the storage device. Data expansion means to expand to,
A partial tree is a node group including a specific node of a tree-type data structure and descendant nodes of the specific node, specifies entity information indicating a target of aggregation, and specifies at least one partial tree indicating a range of aggregation. Condition specifying means;
For each partial tree, the node group belonging to the partial tree is identified by tracing the parent-child relationship between the nodes, and it is determined whether entity information representing the aggregation target is associated with the node group. And a counting means for counting the entity information associated with the node,
Have

An information processing apparatus according to claim 24 includes a storage device that stores data of a tree-type data structure including a root node and a non-root node that is a node other than the root node, and is stored in the storage device. An information processing device for collecting collected data,
All nodes including the root node are given a unique node identifier in preference to the child node over the same generation node, and each parent node of the non-root node is assigned to the node identifier assigned to each non-root node As a result, the parent-child relationship between the nodes constituting the tree type data structure is expressed, and at least one entity information representing the data is associated with each node, and the tree type data structure is stored on the storage device. Data expansion means to expand to,
A partial tree is a node group that includes a specific node of a tree-type data structure and descendant nodes of the specific node, specifies entity information that represents the classification target of aggregation, specifies entity information that represents the aggregation target, and totals A condition specifying means for specifying at least one partial tree representing a range of
For each partial tree, the node group belonging to the partial tree is identified by tracing the parent-child relationship between the nodes, and it is determined whether there is a node associated with entity information representing the target of aggregation in the node group. And, if present, a totaling means for counting the entity information associated with the node for each entity information representing a classification target of aggregation related to the node group belonging to the partial tree;
Have

An information processing apparatus according to claim 25 includes a storage device that stores data of a tree-type data structure including a root node and a non-root node that is a node other than the root node, and is stored in the storage device. An information processing apparatus for ordering at least two nodes of the data,
All nodes including the root node are given a unique node identifier in preference to the child node over the same generation node, and each parent node of the non-root node is assigned to the node identifier assigned to each non-root node As a result, the parent-child relationship between the nodes constituting the tree type data structure is expressed, and at least one entity information representing the data is associated with each node, and the tree type data structure is stored on the storage device. Data expansion means to expand to,
A partial tree is a node group that includes a specific node of data in a tree-type data structure and descendants of the specific node, specifies entity information that represents the target of aggregation, and specifies at least two partial trees that represent the range of aggregation A condition designating means,
For each partial tree, the node group belonging to the partial tree is identified by tracing the parent-child relationship between the nodes, and it is determined whether there is a node associated with entity information representing the target of aggregation in the node group. And, if present, a counting means for counting the entity information associated with the node,
Ordering means for ordering the at least two partial trees according to the order relation of the item value information aggregated for each partial tree;
Have

An information processing apparatus according to claim 26 includes a storage device that stores data of a tree-type data structure including a root node and a non-root node that is a node other than the root node, and is stored in the storage device. An information processing apparatus for ordering at least two nodes of the data,
All nodes including the root node are given a unique node identifier in preference to the child node over the same generation node, and each parent node of the non-root node is assigned to the node identifier assigned to each non-root node As a result, the parent-child relationship between the nodes constituting the tree-type data structure is expressed, and at least one entity information representing the data is associated with each node, and the data of the tree-type data structure is stored. Data expansion means for expanding on the device;
The partial tree is a group of nodes including a specific node of data having a tree-type data structure and descendant nodes of the specific node, and specifies at least two partial trees to be ordered, and includes entity information serving as an index for ordering. A condition specifying means to be specified;
For each partial tree belonging to each tree data, the node group belonging to the partial tree is identified by tracing the parent-child relationship between the nodes, and the node information associated with the entity information serving as an index for ordering is specified in the node group. Index acquisition means for acquiring associated entity information;
Ordering means for ordering the at least two partial trees according to the order relation of the item value information acquired for each partial tree;
Have

  Further, according to the present invention, as described in claims 31 to 45, a program for executing the method according to claims 1 to 15 is provided.

  Furthermore, according to the present invention, there is provided a recording medium on which the program according to claims 31 to 45 is recorded.

  According to the present invention, since the parent-child relationship between the nodes of the tree-type data structure is expressed based on the “child → parent” expression, the amount of memory accessed when manipulating the tree-type data structure is reduced. As a result, search, tabulation, and sorting can be realized at high speed.

  Hereinafter, embodiments of the present invention will be described with reference to the accompanying drawings.

[Computer system configuration]
FIG. 1 is a block diagram showing a hardware configuration of a computer system that searches, aggregates, and sorts data having a tree-type data structure according to an embodiment of the present invention. As shown in FIG. 1, this computer system 10 has the same configuration as a normal one. A CPU 12 that controls the entire system and individual components by executing a program, a RAM (Random) that stores work data, and the like. (Access Memory) 14, a ROM (Read Only Memory) 16 for storing programs, a fixed storage medium 18 such as a hard disk, a CD-ROM driver 20 for accessing the CD-ROM 19, a CD-ROM driver 20 and an external network (FIG. An interface (I / F) 22 provided between an external terminal and a connected external terminal, an input device 24 including a keyboard and a mouse, and a CRT display device 26. The CPU 12, RAM 14, ROM 16, external storage medium 18, I / F 22, input device 24, and display device 26 are connected to each other via a bus 28.

  A program for searching, summing up, and sorting data having a tree-type data structure and a program for converting the tree-type data structure on a storage device according to the present embodiment are accommodated in a CD-ROM 19 and a CD-ROM driver 20 Or may be stored in the ROM 16 in advance. Further, what is once read from the CD-ROM 19 may be stored in a predetermined area of the external storage medium 18. Alternatively, the program may be supplied from the outside via a network (not shown), an external terminal, and the I / F 22.

  In addition, the information processing apparatus according to the embodiment of the present invention is realized by causing the computer system 10 to execute a program that searches, aggregates, and sorts data having a tree-type data structure.

[Tree type data structure]
2A and 2B are explanatory diagrams of POS data, which is an example of tree format data. FIG. 2A is an example of a visual representation of the data structure (ie, topology) and data values of this tree format data. FIG. 2B is an example in which the same tree format data is expressed in XML format. As shown in the figure, the tree-type data structure is represented by a combination of an arc starting from a root node (POS data in this example) and branching at each node to a leaf node (end point). . Each node is associated with item name information, that is, the type of the node, and item value information, that is, the value of the node. In the examples of FIGS.
<shopName> France store </ shopName>
Is associated with a node type of “shopName (= store name)” and a node value of “France store”. This association can be realized, for example, by associating a node identifier with a pointer to a node information storage area in which information describing the node type and node value is stored. However, it should be noted that the present invention is not limited by how the substantial values of the tree-type data structure are handled.

  On the other hand, in order to efficiently search, aggregate, and sort data with a tree-type data structure, a technique that expresses the topology of the tree-type data structure, that is, a technique that expands to a storage device is very important. Play an important role. Therefore, in the following, the topology of the tree data structure will be mainly described.

  Conventionally, such a tree-type data structure is expressed by connecting nodes storing data with pointers. However, the pointer expression has a drawback that the pointer value is not necessarily required. That is, in some cases, a specific node A is stored at a certain address (for example, address 100), and in other cases, the same node A is stored at another address (for example, address 200). Instead of being constant, the pointer value essentially represents the storage address of the node. Therefore, for example, when nodes are connected with a pointer according to a depth priority rule, it is difficult to reconnect these nodes with a pointer according to a width priority rule.

  On the other hand, the present inventor noticed that the topology of the tree-type data structure can be described by an arc list. The arc list is a list of arcs representing a parent-child relationship between nodes. 3A to 3C are explanatory diagrams of examples of the expression format of the tree-type data structure using the arc list. In the example of the figure, a tree-type data structure consisting of 12 nodes to which node identifiers (IDs) of 0, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100, and 110 are assigned. It is shown. FIG. 3A shows the entire tree-type data structure. In FIG. 3A, a number written in the center of a figure such as a round shape or a heart shape (representing a node type) represents a node ID, such as <0,10> written on the arrow and arrow sides. A pair of numbers represents an arc. The node ID is not limited to a character string, and may be a numerical value, particularly an integer. FIG. 3B shows an arc list from a parent node (From-ID) to a child node (To-ID), and FIG. 3C shows a node list including a list of pairs of node IDs and node types. Note that the node list may be omitted for the purpose of merely representing the tree-type data structure. In principle, by using such an arc list, it is possible to directly describe the relationship between nodes without using a pointer.

[Expression based on “child → parent” relationship]
3A to 3C, the arc list is described based on a “parent → child” relationship in which a child node is associated with a parent node. Therefore, since one child node, for example, root node 0, has three child nodes 10, 60, and 80, the same node ID 0 appears three times in the From-ID of the arc list. ing. In other words, since the child node cannot be specified even if the parent node is specified, the arc list is configured by an element From-ID array and an element To-ID array. When using an arc list, a node appears in both the From-ID array and the To-ID array.

  On the other hand, the parent-child relationship can also be expressed by a “child → parent” relationship. In this case, the parent-child relationship between the nodes is expressed by an array of pairs of each non-root node that is a node other than the root node and the associated parent node. When the parent-child relationship is expressed by this “child → parent” relationship, there is an important property that cannot be obtained in the case of the “parent → child” relationship. That is, since only one parent node always corresponds to one child node, it is possible to immediately specify the only parent node corresponding to this child node by specifying the child node. That is, in the arc list, it is actually only necessary to prepare an array of element To-IDs. As a result, the storage capacity for storing the arc list is reduced. This reduction in storage capacity has the effect of reducing the number of accesses to the memory, and as a result, processing speed can be increased.

  4A to 4D are explanatory diagrams of a method for expressing a tree-type data structure based on the “child → parent” relationship. FIG. 4A is an explanatory diagram of the entire tree, and FIG. 4B is an arc list based on a “child → parent” relationship. Since the arc list of FIG. 4B includes a storage area of a parent node for the root node, “-” is set as the parent node of the root node for convenience. However, since there is no parent node corresponding to the root node, as shown in FIG. 4C, the storage area of the parent node for the root node may be excluded from the arc list based on the “child → parent” relationship. In this way, the parent-child relationship between the nodes is expressed by associating the parent node of the non-root node with each of the non-root nodes that are nodes other than the root node. Then, the topology of the tree can be expressed by tracing the list of parent nodes from the child nodes expressed as “child → parent”.

  According to one embodiment of the present invention, a tree-type data structure based on such a “child → parent” relationship has a root node added to the computer system 10 shown in FIG. 1 as shown in FIG. A node definition step 501 for assigning a unique node identifier to the included node, a node identifier assigned to each of the non-root nodes other than the root node, and a parent node of each of the non-root nodes It is constructed on the RAM 14 by executing a parent-child relationship definition step 502 for associating the given node identifier. Thus, by first assigning a node identifier to a node by arbitrary identification information such as a character string, a float, an integer, etc., and then defining a parent-child relationship based on the expression “child → parent”, the child The topology of the tree can be expressed by subtracting (looking up) the node identifier of the parent node from the node identifier of the node.

[Node identifier]
Preferably, the node definition step uses a numerical value as the node identifier, more preferably uses a continuous integer, and more preferably uses an integer sequence number from 0 or 1. This makes it easy to obtain the address where the node identifier of the parent node corresponding to the node is stored from the node identifier, thus speeding up the process of subtracting the node identifier of the parent node from the node identifier of the child node. can do.

  When expressing a parent-child relationship between nodes by assigning an ordered number as a node identifier to a node of the tree type data structure, it is easy to handle the tree type data structure thereafter by defining rules in the order of number assignment There is an advantage of becoming. As a rule of the numbering order, a depth priority mode that prioritizes child nodes over the same generation node and a width priority mode that prioritizes nodes of the same generation over child nodes are used.

  6A to 6C are explanatory diagrams of processing for converting the tree structure type data in the ID format into the tree structure type data in the integer serial number format. FIG. 6A shows tree structure type data in which an ID number is assigned to each node. FIG. 6B shows conversion rules, and FIG. 6C shows tree structure type data in which integer sequential numbers are assigned to the respective nodes. The conversion rule of this example is a rule that assigns serial numbers with depth priority. Specifically, when there are multiple child nodes, the minimum number is assigned to the first child (top brother) node, A large number is assigned to the youngest child (bottom brother) node, and the child node is given priority over the sibling node. In this example, numbering is performed in ascending order, but numbering may be performed in descending order.

  7A to 7C are explanatory diagrams of processing for converting the tree structure type data in the ID format into the tree structure type data in the integer serial number format. FIG. 7A shows tree structure type data in which an ID number is assigned to each node. FIG. 7B shows conversion rules, and FIG. 7C shows tree structure type data in which integer sequential numbers are assigned to each node. The conversion rule of this example is a rule that assigns a sequential number with width priority. Specifically, when there are a plurality of child nodes, a minimum number is assigned to the first child (top brother) node, and the last child ( A lower number is assigned to a node, and a sibling node is given priority over a child node. In this example, numbering is performed in ascending order, but numbering may be performed in descending order.

  When a number is used as a node identifier in this way, the address at which the stored value for the node is stored can be subtracted immediately from the node number, that is, in the order of O (1). Further, by expressing the parent-child relationship as “child → parent”, the parent node can be immediately drawn from the child node, that is, in the order of O (1).

[Depth priority mode]
A tree-type data structure based on depth priority as shown in FIG. 6C is stored in the computer system 10 shown in FIG.
A node definition step for giving a unique continuous integer to a node including a root node in preference to a child node over a node of the same generation;
An array formed by arranging the integers assigned to the parent nodes of the non-root nodes in the order of the integers assigned to the non-root nodes that are nodes other than the root node is stored in the storage device. A parent-child relationship definition step,
Is built on the storage device. Thereby, a continuous integer is given to the nodes with depth priority, and the parent-child relationship between the nodes is expressed by an array of “child → parent” relationship.

FIG. 8 is a flowchart of node definition processing based on depth priority. This node definition process includes the step 801 of first assigning a number to the root node to the computer system 10;
If there is only one child node in a node that has already been assigned a number, step 802 for assigning the child node a number next to the number assigned to that node;
When there are multiple child nodes in a node that has already been assigned a number, the brother node is assigned a number to all descendant nodes of the immediately above brother node according to the sibling relationship between the multiple child nodes. Step 803 for assigning numbers from the top brother node to the bottom brother node so that the next number is given later;
Is executed. Thereby, a sibling relationship is defined between a plurality of child nodes derived from the same parent node in the depth priority mode.

  FIG. 9 is an explanatory diagram of an array of parent-child relationships based on the “child → parent” expression created from the depth-first tree-type data structure shown in FIG. 6C. As shown as subtree 1 or subtree 2 in the figure, when the parent-child relationship of nodes assigned consecutive numbers with depth priority is arranged based on the “child → parent” relationship, An excellent property of appearing in a continuous region is obtained.

  As an example, by using a superior property of the depth priority mode, by extracting a continuous area in which a value greater than or equal to an integer assigned to a node is stored from the array, all the nodes of the certain node are extracted. Descendant nodes can be specified. Thereby, a node group representing a descendant node of a certain node can be acquired as a continuous block in the array. For example, if the size of the continuous block is m, the processing speed for specifying all descendant nodes of a certain node is on the order of O (m).

  As already described, the parent-child relationship between nodes can be expressed not only by the array of “child → parent” but also by the array of “parent → child”. FIG. 10 is an explanatory diagram of an array of parent-child relationships based on the “parent → child” expression created from the depth-first tree-type data structure shown in FIG. 6C. Since a plurality of child nodes can exist for one parent node, the parent-child relationship array stores an array Aggr for indicating an area in which the child node number for each node is stored, and the child node number. It is composed of two arrays P → C. For example, the value of the second element Aggr [1] from the top of the array Aggr is “3”. This is because the child node number for the node [1] is the element P → C [3] of the array P → C. It indicates that it is stored after that. As a result, the node [0], that is, the child node for the root node has three elements from the top of the array P → C, P → C [0] 1, P → C [1] 6, and P → It can be seen that C [2] is 8.

A method for obtaining an array of parent-child relationships based on the expression “parent → child” will be described.
(1) When the node number matches the maximum index (= 11) of the array P → C, there is no child node belonging to this node. Therefore, the process is not continued.
(2) An Aggr value is obtained from the parent node number shown in bold in the figure. This Aggr value represents the starting point of the array P → C.
(3) An Aggr value corresponding to the parent node number +1 represented in bold is obtained. This Aggr value −1 is the end point of the array P → C.

  For example, the start point of the child node of node 0 is Aggr [0], that is, 0, and the end point is Aggr [1] -1, that is, 3-1 = 2. Therefore, the child nodes of the node 0 are the 0th to 2nd elements of the array P → C, that is, 1, 6 and 8.

  Alternatively, the parent-child relationship based on the expression “parent → child” can be expressed more simply by two arrays: an array of parent node numbers and an array of corresponding child node numbers. However, in order to find the parent-child relationship using this array, the number of the parent node must be searched, that is, the access time of log (n) is required, so the efficiency is poor.

[Width priority mode]
Furthermore, a tree-type data structure based on breadth-first as shown in FIG. 7C is added to the computer system 10 shown in FIG.
A node definition step of giving priority to a node of the same generation over a child node, and giving a unique continuous integer to a node including a root node;
An array formed by arranging the integers assigned to the parent nodes of the non-root nodes in the order of the integers assigned to the non-root nodes that are nodes other than the root node; A parent-child relationship definition step stored in
Is built on the storage device. As a result, the nodes are given a continuous integer in the width priority mode, and the parent-child relationship between the nodes is represented by an array of “child → parent” relationship.

FIG. 11 is a flowchart of node definition processing based on width priority. This node definition process is performed by the computer system 10.
Step 1101 for calculating the number of generations of each node from the root node and the number of nodes included in each generation;
First assigning a number to the root node 1102;
If numbers are assigned to all nodes included in a generation, the parent node is different for all nodes included in the next generation until there is no node in the next generation of the generation. In this case, numbers are assigned to the nodes in the order in which the numbers are assigned to the parent nodes. When the parent nodes are the same, a sibling relationship is established between a plurality of child nodes derived from the parent node. Step 1013 for defining and sequentially assigning unique integers that sequentially change from the number next to the number assigned immediately before from the top brother node to the bottom brother node;
Is executed. Thereby, a sibling relationship is defined between a plurality of child nodes derived from the same parent node in the width priority mode.

  FIG. 12 is an explanatory diagram of an array of parent-child relationships based on the “child → parent” expression created from the breadth-first tree-type data structure shown in FIG. 7C. As shown in the figure, when the parent-child relationship of nodes assigned consecutive numbers with breadth priority is arranged based on the “child → parent” relationship, the child nodes of a certain node appear in a continuous region. Properties are obtained. This is because when the parent-child relationship of nodes assigned consecutive numbers in the breadth-first mode is expressed as an array based on the “child → parent” relationship, the numbers assigned to the parent nodes are ordered (ascending or descending) in the array. By appearing.

  Therefore, by using the superior property of the breadth-first mode, by extracting a continuous region in which the same value as the integer assigned to a certain node is stored from the array, all the child nodes of the certain node are extracted. Identify. As a result, it is possible to search a child node of a certain node using a technique such as binary search, for example, in the order of O (log (n)).

  As already described, the parent-child relationship between nodes can be expressed not only by the array of “child → parent” but also by the array of “parent → child”. FIG. 13 is an explanatory diagram of an array of parent-child relationships based on the “parent → child” expression created from the breadth-first tree-type data structure shown in FIG. 7C. Since there can be a plurality of child nodes for one parent node, the parent-child relationship array includes an array Aggr for indicating an area in which child node numbers for each node are stored, and child node numbers. Is composed of two arrays P → C. For example, the value of the second element Aggr [1] from the top of the array Aggr is “3”. This is because the child node number for the node [1] is the element P → C [3] of the array P → C. It indicates that it is stored after that. Thus, the node [0], that is, the child node for the root node, has three elements from the top of the array P → C, 1 of P → C [0], 2 of P → C [1], and It can be seen that P → C [2] is 3.

A method for obtaining an array of parent-child relationships based on the expression “parent → child” will be described.
(1) When the node number matches the maximum index (= 11) of the array P → C, there is no child node belonging to this node. Therefore, the process is not continued.
(2) An Aggr value is obtained from the parent node number shown in bold in the figure. This Aggr value represents the starting point of the array P → C.
(3) An Aggr value corresponding to the parent node number +1 represented in bold is obtained. This Aggr value −1 is the end point of the array P → C.

  For example, the start point of the child node of node 0 is Aggr [0], that is, 0, and the end point is Aggr [1] -1, that is, 3-1 = 2. Therefore, the child nodes of the node 0 are the 0th to 2nd elements of the array P → C, that is, 1, 2, and 3.

[Converting tree data structure representation]
As described above, each of the depth priority mode and the width priority mode for assigning serial numbers to nodes has unique and excellent properties. In addition, one tree type data structure can be expressed in any of the “child → parent” representation format based on depth priority, the “child → parent” representation format based on width priority, and the “parent → child” representation format. Is possible. Therefore, it is necessary to note that the “child → parent” representation format based on depth priority, the “child → parent” representation format based on width priority, and the “parent → child” representation format can be appropriately converted to each other. is there.

[Vertex nodes and subtrees]
When data having a tree-type data structure is searched, aggregated, and sorted, a specific portion of the entire tree data may be set as a processing target, for example, a search target range. The present inventor has proposed a method for improving the efficiency of various processes by introducing one node representing a specific part including a plurality of nodes. Next, this method will be described in detail.

  In tree data having a tree-type data structure, it is assumed that the value of the node closest to the root node is used to represent the node and all the nodes that branch from the node and reach the leaf node (end point). Here, a node and a node group from the node to the leaf node are referred to as a partial tree. A node closest to the node (root node) is referred to as a vertex node.

  FIG. 14A is a diagram illustrating a tree-type data structure based on the above-described breadth-first mode, and FIG. 14B is a diagram illustrating an array of a parent-child relationship based on the tree-type data structure based on a “child → parent” expression. For example, the vertex node [4] includes a node identifier {4, 8, 9}, the vertex node [6] includes a node identifier {6}, and the vertex node [3] includes a node identifier {3, 7, 10, 11}. Such an array composed of a plurality of vertex nodes is referred to as a vertex node list. A plurality of partial trees can be designated by the vertex node list, and the plurality of designated partial trees are referred to as a partial tree group.

  Hereinafter, the vertex node list is represented as [a, b,...]. Here, “a”, “b”,... Are node identifiers corresponding to the vertex nodes. Suppose that each of the vertex nodes constituting the vertex node list is expanded and node identifiers of all nodes included in the partial tree having the vertex node as a vertex are obtained. If there is only one node identifier in the obtained list of node identifiers, that is, if node identifiers do not appear in duplicate, such a partial tree group is referred to as a “regular partial tree group”. Such a partial tree group is referred to as a “non-normal partial tree group”.

  The partial tree group can be converted into a normal partial tree group, and this process is referred to as “normalization”. Normalization is important for efficient execution of set operations. In the normalized partial tree group, since every node belongs to at most one vertex node, the list of vertex nodes to which each node belongs can be described by an array having a size equal to the number of vertex nodes at most. it can. For this reason, in the normalized state, a set operation represented by logical product or logical sum can be efficiently performed.

  Whether it is a normal partial tree group or a non-normal partial tree group, a partial tree group including a vertex node and its descendant nodes can be specified by the vertex node list. For example, as shown in FIG. 15A, by using the vertex node list [4, 6, 3], a partial tree group (partial trees {4, 8, 9}, {6}, {3, 7, 10,11}) is specified.

  The partial tree group specified by the vertex node list can be a target of search, aggregation, sorting, and set operation.

  For example, in the example of FIGS. 15A and 15B, when a partial tree including a “heart-shaped” node is searched, a partial tree group as shown in FIG. 16B is obtained. FIG. 16A is a vertex node list representing this partial tree group.

  Further, the total number of nodes belonging to each partial tree is as shown in FIG. 17B. In FIG. 17A, an array 1701 is a vertex node list, and an array 1702 is an array indicating the number of nodes belonging to the partial tree specified by each vertex node.

  For example, sorting by the number of nodes belonging to each partial tree can be considered as sorting. In FIG. 18A, an array 1801 is a sorted vertex node list, and an array 1802 is an array indicating the number of nodes belonging to the partial tree specified by the vertex node list. FIG. 18B shows a state where the partial tree is sorted according to the number of nodes.

  Further, a logical product will be described as a set operation between a plurality of partial tree groups. In the trees shown in FIGS. 14A and B, the partial tree group shown in FIG. 19B (corresponding vertex node list is shown in FIG. 19A) and the partial tree group shown in FIG. 19D (corresponding vertex node list is shown in FIG. 19C) Consider the logical product of.

  When comparing the partial tree 1901 specified by the vertex node of the node identifier “4” in FIG. 19B with the partial tree 1911 specified by the vertex node identifier of the node identifier “1” in FIG. 19D, the partial tree 1901 is included in the partial tree 1902. A partial tree having an inclusion relationship with the partial tree 1902 in FIG. 19B does not exist in the partial tree group shown in FIG. 19D. Further, when the partial tree 1903 specified by the vertex node of the node identifier “3” in FIG. 19B is compared with the partial tree 1913 specified by the node identifier “7” in FIG. It is included in the partial tree 1903. As a result, the vertex node list indicating the result of the AND operation is [4, 7] as shown in FIG. 20A. FIG. 20B shows a partial tree group corresponding to the result of the logical product operation.

  As can be understood from FIGS. 16A and B to FIGS. 20A and 20B, according to the vertex node list (in addition to this, an array having the same size as the vertex node list and storing the aggregation result (number of nodes)), respectively. It is possible to represent the results of the processes and operations.

[Set operations]
Between the normal partial tree groups according to the present embodiment, logical product (AND), logical ring (OR), negation (NOT), subtraction (SUB), and exclusive OR (XOR) can be defined. The result of such an operation is also represented by a normal partial tree group. Hereinafter, these calculations will be described. Hereinafter, each calculation will be described in the example shown in FIGS.
(1) OR (OR)
For example, consider the logical sum of normal subtree groups [2] and [3].

Regular subtree group [2]: {2, 6}
Regular subtree group [3]: {3, 7, 10, 11}
OR of these [2] OR [3] = [2, 3]
([2,3]: {2,6}, {3, 7, 10, 11})
It becomes.

  Similarly, consider the logical sum of the regular subtree groups [3] and “7”.

Regular subtree group [3]: {3, 7, 10, 11}
Regular subtree group [7]: {7, 10, 11}
Therefore, these logical sums [3] OR [7] = [3].
(2) Logical product (AND)
Consider a logical product of normal subtree groups [2, 3] and [7].

Regular subtree group [2, 3]: {2, 6, 3, 7, 10, 11}
Regular subtree group [7]: [7, 10, 11]
Therefore, the logical product [2, 3] AND [7] = [7] is obtained.

  Of the calculations, processes executed in these calculations will be described below.

[AND operation]
First, the principle of the logical product operation will be described. Consider two normal subtree groups 2201 and 2202 as shown in FIG. 22A. The two normal subtree groups have a relationship as described below.

  For example, when the normal partial tree group 2201 includes the normal partial tree group 2202 (see FIG. 22B), the logical product of the two normal partial tree groups becomes the normal partial tree group 2202. On the other hand, when the normal partial tree group 2202 includes the normal partial tree group 2201 (see FIG. 22C), the logical product of the two normal partial tree groups becomes the normal partial tree group 2201. Furthermore, although not shown, when both normal partial tree groups do not have an inclusion relationship, the logical product between them becomes an empty set.

  FIG. 23 is a flowchart showing processing executed by the system during the logical product operation. As shown in FIG. 23, a marking array is generated for each of the normal partial tree groups to be subjected to the AND operation (step 2301). The marking array is equivalent to the flag array and the affiliated node array generated by the normalization operation. That is, the marking array can be acquired by performing the same processing as the first method and the second method of normalization calculation.

  The system 10 then compares the corresponding values of both marking sequences (step 2302). More specifically, the system 10 initializes pointers for identifying corresponding values in the two marking arrays (step 2311), and retrieves both values of the marking array indicated by the pointers (step 2312). If both values or one value is the initial value “−1” (No in step 2313), the system 10 does not point to the end of the array (No in step 2315). (No)), the pointer is moved (step 2316), and the process returns to step 2312.

  If both values of the marking array are values other than the initial value “−1” (Yes in step 2312), the larger value of the marking array values is the storage address, that is, the corresponding value. It is determined whether it is equal to the node identifier to be executed (step 2313). If it is determined as Yes in step 2313, the system 10 stores the matching value in the vertex node array as the value of the vertex node array indicating the result of the logical product operation (step 2314). . Thereafter, if the pointer does not point to the end of the array (No in step 2315), the pointer is moved (step 2316), and the process returns to step 2312.

  If NO in step 2312, if the pointer does not point to the end of the array (NO in step 2315), the pointer is moved (step 2316), and the process returns to step 2312.

  Hereinafter, an example of an AND operation of the normal partial tree group [3, 6] and the normal partial tree group [2, 7] will be described. FIG. 24 shows a state where the marking arrays of the normal partial tree group [3, 6] and the normal partial tree group [2, 7] are generated. In FIG. 24, reference numeral 2401 indicates a marking array (first marking array) of the normal partial tree group [3, 6], and reference numeral 2402 indicates a marking array (second second) of the normal partial tree group [2, 7]. Marking arrangement).

  As shown in FIG. 25, when the pointer indicates the node identifier “6” (see reference numeral 2501), the value of the first marking array is “6” and the value of the second marking array is “2”. Is. The larger value is “6”, which matches the node identifier. Therefore, the value “6” is stored in the vertex node list for storing the result of the logical product operation.

  When the pointer indicates the node identifier “7” (see reference numeral 2502), the value of the first marking array is “3” and the value of the second marking array is “7”. The larger value is “7”, which matches the node identifier. Therefore, the value “7” is stored in the vertex node list for storing the result of the logical product operation. As a result of such processing, [3, 6] AND [2, 7] = [6, 7] can be obtained.

[OR operation]
The logical OR operation can be described as follows.

[A1, a2, ..., an] OR [b1, b2, ..., bn]
= NORM [a1, a2, ..., an, b1, b2, ..., bn]
That is, if the normalization method described above is used, a vertex node list indicating the result of the logical sum operation can be obtained.

  For example, in the example shown in FIG. 24, [3, 6] OR [2, 7] = NORM [3, 6, 2, 7] = [2, 3].

[Subtraction]
The subtraction of the normal partial tree group can be defined as follows using the above-described logical sum operation and logical product operation. In the following, subtraction is represented by “− (minus)”.

  Let A, B, C, and D be normal partial tree groups.

(AB) AND (CD) = (A AND C)-(BORD) (Formula 1)
(AB) OR (CD) = (A OR C) AND (B AND D) (Formula 2)
A-B-C = A- (BORC) (Formula 3)
In other words, the same calculation rules as for Boolean algebra hold.

  As described in the normalization operation or the like, the normal partial tree group can be represented by a vertex node list.

  In this example, for example, (Equation 1) includes two vertex node lists (a vertex node list indicating a logical product operation result of A and C, and a vertex node list indicating a logical sum operation result of B and D) and , And an operator called “subtraction” between them. That is, originally, it should be represented by each of the four vertex node lists of the normal partial tree groups A to C and an operator between them, but can be represented by two vertex lists and an operator between them. That is, it can be expressed by a reduced vertex node list and a reduced vertex node list (excluded vertex node list).

  The same applies to (Expression 2) and (Expression 3).

[Negation, exclusive OR, etc.]
Also, negation (NOT) of the normal partial tree group can be expressed as an excluded vertex node list. That is, in “NOT A” (A is a normal partial tree group), all the nodes except for the vertex node and its descendant nodes listed in the excluded vertex node list are negative of the normal partial tree group A.

  Similarly, exclusive OR can also be represented by a vertex node list and an excluded vertex node list.

[Overview of tree data search]
Tree data search has two aspects: path search and node stored value search. The path search is to extract nodes satisfying the path condition of “/ shop / shopName” in FIGS. 2A and 2B, for example. Further, the retrieval of the node stored value is to extract a node having “shopName = France store” in FIGS. 2A and 2B.

  A general tree data search is a combination of a path search and a node stored value search. In the above example, it corresponds to extracting a node satisfying “/ shop / shopName = France store”. That is, a general tree data search is a search based on an AND condition that satisfies the path condition and the node stored value condition at the same time. Whether a certain vertex node satisfies the AND condition can be determined by examining the path condition and examining the condition of the node storage value of the node that satisfies the path condition. The search by specifying the AND condition can be realized by performing an AND (logical product) operation of the search result set by the path condition and the search result set by the node storage value condition.

  Further, the tree data search is not limited to the search by specifying the AND condition of the above path condition and node stored value condition. For example, there is a search by specifying an OR condition for extracting a node that satisfies either the path condition or the node stored value condition. The search by specifying the OR condition can be realized by performing an OR (logical sum) operation on the search result set by the path condition and the search result set by the node storage value condition.

[How to handle substantive values of nodes]
In tree data search, entity information such as node item name information (for example, node type) for representing a path and node item value information (for example, node value) for representing a node stored value is used as a search condition. Is used. For example, as shown in FIG. 26, these entity information can be specified by following a node identifier with a pointer to a node information storage area in which information describing the node type and the node value is stored. .

  If all nodes have the same node type, it is possible to store only the node value in the node information storage area.

[Search by descendant path condition]
Next, a search method based on a descendant path condition according to the embodiment of the present invention will be described. The search based on the descendant path condition is a process of extracting a vertex node including a node having a specified node type as a descendant node. FIGS. 27A and 27B are explanatory diagrams of a tree-type data structure to be searched according to a descendant path condition and a “child → parent” expression of a parent-child relationship of nodes according to an embodiment of the present invention. In this example, the node type, which is item name information of each node, is represented by a symbol number. In FIG. 27A, the node identifier (for example, node number) of each node is displayed together with a graphic corresponding to the symbol number of that node. Has been. For example, the root node is a round symbol. The vertex node is indicated by a black star (★). FIG. 27B is a diagram illustrating the correspondence between symbol numbers, display figures, and symbol names.

  In this example, node extraction is performed using a condition of a descendant node of a vertex node as a search condition. More specifically, a vertex node including a button type node as a descendant node is extracted.

  In the search based on the path condition of the descendant, there are two methods, a method 1 for checking in the order from the child node to the parent node and a method 2 for checking in the order from the parent node to the child node. Method 1 is a method of checking in order from the head of the expression “child → parent”, and is effective when the number of vertex nodes is large. On the other hand, method 2 is effective when the number of vertex nodes is small because the check is performed in order from the parent to the child starting from the vertex node. Depending on the application, method 1 and method 2 may be selectively performed.

[Descendant path condition search method 1: Checking from child to parent]
The RAM 14 of the computer system 10 that executes the path condition search method 1 according to the embodiment of the present invention includes a root node and a non-root node that is a node other than the root node, as shown in FIG. 27A. Tree-type data structure data is expanded. More specifically, a node number that is a unique node identifier is assigned to all nodes including the root node, and the node identifier assigned to each non-root node is assigned to each parent node of the non-root node. Thus, a parent-child relationship between nodes constituting the tree-type data structure, that is, a parent-child relationship by depth-first “child → parent” is expressed. However, it should be noted that the path condition search method 1 can be similarly applied to the expression format of “child → parent” with breadth priority. For example, as shown in FIG. 26, each node is associated with a node type (or symbol number) that is item name information and a node value that is item value information.

  The computer system 10 sets a condition that the node symbol number = 1 (symbol number 1 represents a button type) as a search condition. This condition may be input by the user via the input device 24 of the computer system 10, read from the external storage medium 18, or set externally via the I / F 22, for example. Good.

  Next, the computer system 10 determines, for each node, whether or not the node type associated with the node matches the button type. If the node type matches, the search hit information is associated with the node, and “child → parent” The search hit information is associated with the ancestor node of the node by tracing the parent-child relationship of the expression format. The search hit information can be associated with the node identifier by preparing a flag information area corresponding to each node identifier and setting the flag information when the search hits, for example.

  FIG. 28 is a flowchart of a tree search method based on descendant path conditions according to an embodiment of the present invention. FIGS. 29A to 33C are diagrams illustrating operation states of the tree search method based on the descendant path conditions according to an embodiment of the present invention.

First, as shown in FIG. 29A, the system 10 initializes a flag area Flag and initializes a symbol number read address (Step 2801). In this example, the flag area is initialized with the value 0, the symbol number read address is initialized with the leading address 0, and the symbol number (Symbol
No.) is stored in the form of an array, but is not limited to this example. Next, the system 10 reads the symbol number (Symbol) corresponding to this symbol number reading address.
No.) is read (step 2802), and it is checked whether or not this symbol number is 1 (step 2803). In the figure, the pointer indicating the check location is indicated by a thick arrow. Since the symbol number corresponding to the start address 0 is 2, the check result in Step 2803 is No, and if the next address is checked (Step 2808), the next address 1 exists (Yes). The symbol number read address is moved to the next address 1 (step 2805), and the process returns to step 2802. As shown in FIG. 29B, steps 2802, 2803, 2804, and 2805 are repeated until the read symbol number matches 1 or there is no next symbol number read address. In this example, the symbol numbers do not match 1 from address 0 to address 6. As shown in FIG. 29C, when the symbol number read address advances to 7, the symbol number matches 1 (step 2803).

  When the system 10 finds a symbol number that matches 1 in Step 2803 (Yes), as shown in FIG. 30A, it marks the flag of the node at the found address 7 (Step 2806), and the parent-child relationship expression C → P is used to find the address of the parent node of address 7, that is, address 6, and the target node is moved to the parent node (step 2807). In the following, for simplicity, the node at address 7 is referred to as node 7 and the node at address n is generally referred to as node n. Next, as shown in FIG. 30B, the system 10 checks whether or not the destination parent node 6 is marked (step 2808). Since the flag of the node 6 is not marked (No), Mark the flag of node 6 (step 2809) and return to step 2807 to check if there is a parent node. As shown in FIG. 30C, since the parent node of node 6 is node 0 and the flag of node 0 is not marked (step 2808, No), the flag of node 0 is marked (step 2809), If it is checked whether there is a parent node (step 2807), since the parent node does not exist (No), the system 10 proceeds to step 2804.

  The system 10 moves the symbol number read address to the next address 8 as shown in FIG. 31A (step 2805), and if the read symbol number matches 1 as shown in FIG. 31B, Alternatively, steps 2802, 2803, 2804, and 2805 are repeated until there is no next symbol number read address. As shown in FIG. 31C, when the symbol number reading address 11 is reached, the symbol number matches 1 (step 2803).

  Since the system 10 finds a symbol number matching 1 in step 2803 (Yes), it marks the flag of the found node 11 (step 2806), as shown in FIG. 32A, and displays the parent-child relationship expression C → P. Is used to move to node 9 which is the parent node of node 11 (step 2807). Next, as shown in FIG. 32B, when the system 10 checks whether or not the parent node 9 to be moved is marked (step 2808), since the flag of the node 9 is not marked (No), the node 10 9 is marked (step 2809), and the process returns to step 2807 to check whether there is a parent node. As shown in FIG. 32C, since the parent node of the node 9 is the node 8 and the flag of the node 8 is not marked (No), the flag of the node 8 is marked (step 2809). The process returns to step 2807 to check whether there is any. The parent node of the node 8 is the node 0. As shown in FIG. 32D, when it is checked whether or not the node 0 is already marked (step 2808), since it is already marked (Yes), the process proceeds to step 2804. . When it is checked whether there is an address next to the current symbol number read address 11 (step 2804), since there are no more addresses (No), marking ends.

  The result of the flag area can be used as it is as a result of the exhaustive search of nodes.

  Furthermore, as shown in FIG. 33A, when the vertex node list before the search is designated as the search range, the system 10 determines whether the flag of each vertex node in the vertex node list is marked after the marking is completed. Check whether or not the marked vertex nodes are stored in the vertex node list after the search as a search result. As shown in FIG. 33A, vertex node 1 has a corresponding flag of 0, so the partial tree having node 1 as a vertex does not include a button-type node, but vertex node 6 is shown in FIG. 33B. In addition, since the corresponding flag is 1 (that is, marked), the partial tree having the node 6 as a vertex includes a button type node. Similarly, it is understood that the vertex node 8 is a vertex node of the partial tree including the button type node. Therefore, as shown in FIG. 33C, a vertex node list including the vertex nodes 6 and 8 is generated as a search result.

  In the above example, when a node whose symbol number matches 1 is detected, the parent node is marked by tracing all the parent nodes of the node, but the number of descendant stages is specified as the search range. For example, when a condition such as a child node immediately below or a grandchild node is specified, the number of stages of tracing the parent-child relationship by the expression “child → parent” is restricted.

Furthermore, since the time required for initializing the flag area increases when the number of nodes becomes enormous, a technique for shortening the initialization time is proposed. At initialization such as immediately after system startup, all flag arrays consisting of integer elements are initialized to zero. During system operation, initialization is not performed until the element of the flag array overflows and returns to zero. For example, if the area for storing the flag array is a 32-bit integer, it is not necessary to initialize again within the range of the number of searches up to 2 ³² −1. At this time, the hit node is marked with an unused minimum integer. That is, the first time is 1, and thereafter increases like 2, 3, and 4. Therefore, whether the vertex node list matches the search condition may be checked by checking whether it matches the value used for marking.

  In the above example, the initial value is 0, but a value other than 0 may be used. Moreover, the integer used for marking is not limited to the smallest integer as long as it is unused.

[Descendant path condition search method 2: Check from parent to child]
Next, a description will be given of the path condition search method 2 according to the embodiment of the present invention in which checks are performed in order of parent → child. In the RAM 14 of the computer system 10 that executes the path condition search method 2, as shown in FIG. 27A, data of a tree type data structure including a root node and a non-root node that is a node other than the root node is expanded. Has been. The parent-child relationship between the nodes constituting the tree-type data structure is constructed in an expression format by depth-first “child → parent”. In the path condition search method 2, when the parent-child relationship of nodes assigned serial numbers with depth priority is arranged based on the “child → parent” relationship, descendant nodes of a certain node appear in a continuous region. Take advantage of For example, as shown in FIG. 26, each node is associated with a node type (or symbol number) that is item name information and a node value that is item value information.

  The computer system 10 sets a condition that the node symbol number = 1 (symbol number 1 represents a button type) as a search condition. Furthermore, the system 10 sets at least one partial tree representing the search range. In this example, the vertex node list [1, 6, 8] including the vertex nodes 1, 6, and 8 is designated. The search condition and search range may be input by the user via the input device 24 of the computer system 10, read from the external storage medium 18, or externally via the I / F 22. It may be set. The vertex node is a node representing a node group including a specific node of the tree-type data structure and descendant nodes of the specific node.

  Next, for each vertex node, the computer system 10 identifies the descendant node of the vertex node by tracing the parent-child relationship between the nodes, and the node type associated with the vertex node and / or the descendant node of the vertex node Is matched with the button type, and when there is a matching node, the node identifier assigned to the vertex node is stored as a search result.

  FIG. 34 is a flowchart of a tree search method based on descendant path conditions according to an embodiment of the present invention. FIGS. 35A to 37C are diagrams for explaining the operation state of the tree search method based on the path conditions of descendants according to an embodiment of the present invention.

  First, as shown in FIG. 35A, the system 10 initializes a pointer indicating an address for reading a vertex node from the vertex node list with the top address of the vertex node list (step 3401). The vertex node 1 is extracted (step 3402). Next, the system 10 specifies the descendant node of the vertex node 1 with reference to the expression of the parent-child relationship by “child → parent” with depth priority (step 3403). In general, since the expression of the parent-child relationship by depth-first “child → parent” has the above-mentioned excellent properties, the descendant node of the specific node is the position where the node identifier assigned to this specific node is stored Can be specified by extracting a continuous area in which a value equal to or greater than the value of the node identifier assigned to the specific node is extracted from the next position. In this example, in C → P, a continuous area from the next position where the node identifier 0 assigned to the node 1 is stored to the position where the value of the node identifier 1 of the node 1 is stored, that is, The area in which the node identifiers 1, 2, 2, 1 are stored is the range of the descendant nodes of the node 1. Since this area is an area for storing the node identifiers assigned to the node 2, the node 3, the node 4 and the node 5, the descendant nodes of the node 1 are the node 2, the node 3, the node 4 and the node 5. I understand.

  Next, the system 10 checks whether there is a node that matches the search condition among the identified descendant nodes, that is, a node whose node type is a button type (step 3404). In the case of this example, as shown in FIG. 35B, there is no button type node in the range of the descendant node of the vertex node 1, so as shown in FIG. 35C, nothing is registered in the vertex node list of the search result. Instead, the system 10 proceeds to step 3405. In this example, since the next vertex node 6 exists in the vertex node list (Yes in step 3405), the system 10 moves the pointer to the vertex node 6 (step 3406) and returns to step 3402.

  Next, as shown in FIG. 36A, the system 10 extracts the vertex node 6 from the vertex node list (step 3402), and sets the node 7 as the descendant node of the vertex node 6 by using the method for identifying the descendant node already described. Specify (step 3403). Subsequently, as shown in FIG. 36B, the system 10 checks whether or not the node type of the descendant node 7 is a button type (step 3404), and determines that the descendant node 7 satisfies the search condition (step 3404). Yes). Therefore, as shown in FIG. 36C, the system 10 registers the vertex node 6 in the post-search vertex node list that is the search result (step 3407), and proceeds to step 3405.

  In this example, since the next vertex node 8 exists in the vertex node list (Yes in step 3405), the system 10 moves the pointer to the vertex node 6 (step 3406) and returns to step 3402.

  Next, as shown in FIG. 37A, the system 10 extracts the vertex node 8 from the vertex node list (step 3402), and uses the above-described method for identifying a descendant node as a descendant node of the vertex node 8, Node 10 and node 11 are specified (step 3403). Subsequently, as shown in FIG. 37B, the system 10 checks whether or not the node type is a button type among the descendant nodes (step 3404), and determines that the descendant node 11 matches the search condition. (Yes). Therefore, as shown in FIG. 37C, the system 10 registers the vertex node 8 in the post-search vertex node list that is the search result (step 3407), and proceeds to step 3405. In this example, since the next vertex node does not exist in the vertex node list, the system 10 ends the search process.

  Through the above search processing, the post-search vertex node list [6, 8] is obtained.

  In the above description, when specifying the descendant nodes of the vertex node, all the descendant nodes are specified. For example, the number of generations of the descendants is limited to, for example, the child nodes and the grandchild nodes. It is also possible to limit the search range.

  In the above example, the vertex node list is generated as a search result. For example, a flag area as described with reference to FIGS. 29A to 29C is prepared, and all descendant nodes that hit the search condition are prepared. It is also possible to generate a node identifier as a search result.

[Search by ancestor path condition]
Next, a search method based on an ancestor path condition according to an embodiment of the present invention will be described. The search by the ancestor path condition is a process of extracting a vertex node having a node having a specified node type as an ancestor node. 38A to 38C are explanatory diagrams of a tree-type data structure to be searched based on a path condition and a “child → parent” expression of a parent-child relationship of nodes. In this example, the vertex nodes are node 2, node 7, and node 9, and the vertex nodes are indicated by black stars (★). The correspondence between the symbol number, the display figure, and the symbol name is as described with reference to FIG. 27B. In this example, node extraction is performed using the condition of the ancestor node of the vertex node as a search condition. More specifically, a vertex node including a heart-type node as an ancestor node is extracted.

  In this example, the parent-child relationship is expressed in the expression format of “child → parent” with depth priority, but may be expressed with the expression of “child → parent” with priority in width. For example, as shown in FIG. 26, each node is associated with a node type (or symbol number) that is item name information and a node value that is item value information.

  The computer system 10 sets a condition of node symbol number = 3 (symbol number 3 represents a heart shape) as a search condition. Furthermore, the system 10 sets at least one partial tree representing the search range. In this example, the vertex node list [2, 7, 9] including the vertex nodes 2, 7, 9 is designated. The search condition and search range may be input by the user via the input device 24 of the computer system 10, read from the external storage medium 18, or externally via the I / F 22. It may be set. The vertex node is a node representing a node group including a specific node of the tree-type data structure and descendant nodes of the specific node.

  For each vertex node, the computer system 10 traces the parent-child relationship between the nodes to identify an ancestor node of the vertex node, and at least one entity information associated with the vertex node or the ancestor node of the vertex node is the It is determined whether or not the search condition is matched, and when there is a matched node, the node identifier assigned to the vertex node is stored as a search result.

  FIG. 39 is a flowchart of a tree search method based on ancestor path conditions according to an embodiment of the present invention. FIGS. 40A to 42C are diagrams for explaining the operation state of the tree search method based on the ancestor path condition according to the embodiment of the present invention.

  First, as shown in FIG. 40A, the system 10 initializes a pointer indicating an address for reading a vertex node from the vertex node list with the top address of the vertex node list (step 3901). The vertex node 2 is extracted (step 3902). Next, the system 10 reads the symbol number (Symbol No.) corresponding to this vertex node 2 (step 3903) and checks whether or not this symbol number is 3 (step 3904). Since the symbol number of the vertex node 2 is not 3 (No), the system 10 proceeds to Step 3905, and the parent node of the vertex node 2 exists with reference to the expression of the parent-child relationship by depth-first “child → parent”. In this case, as shown in FIG. 40B, since the parent node 1 exists (Yes), the system 10 reads the symbol number corresponding to the parent node 1 (step 3906). Since the symbol number associated with node 1 is 5 and does not match the search condition (step 3907, No), the system 10 returns to step 3905 and checks whether the parent node of node 1 exists. In this case, as shown in FIG. 40C, the parent node 0 of the node 1 exists (Yes), and the system 10 reads the symbol number corresponding to the node 0 (step 3906). Since the symbol number associated with node 0 is 2 and does not match the search condition (step 3907, No), the system 10 returns to step 3905 and checks whether the parent node of node 0 exists. Since node 0 is the root node and there is no parent node (No), system 10 proceeds to step 3909.

  Since the next vertex node 7 exists in the vertex node list, the system 10 sets a pointer indicating an address for reading the vertex node from the vertex node list to the next address in the vertex node list as shown in FIG. 41A. Move (step 3910) and take out the second vertex node 7 from the vertex node list (step 3902). Next, the system 10 reads the symbol number corresponding to this vertex node 7 (step 3903), and checks whether this symbol number is 3 (step 3904). Since the symbol number of the vertex node 7 is not 3 (No), the system 10 proceeds to Step 3905, and the parent node of the vertex node 7 exists with reference to the expression of the parent-child relationship by depth-first “child → parent”. In this case, as shown in FIG. 41B, since the parent node 6 exists (Yes), the system 10 reads the symbol number corresponding to the parent node 6 (step 3906). Since the symbol number associated with node 6 is 3 and matches the search condition (step 3907, Yes), the system 10 proceeds to step 3908 and, as shown in FIG. 41C, the vertex node pointed to by the current pointer 7 is registered in the vertex node list after the search as a search result. Since the vertex node 7 has been registered, there is no need to follow the parent node any more, so the system 10 proceeds to step 3909.

  Since the next vertex node 9 exists in the vertex node list, the system 10 sets a pointer indicating an address for reading the vertex node from the vertex node list to the next address in the vertex node list, as shown in FIG. 42A. Move (step 3910) and take out the third vertex node 9 from the vertex node list (step 3902). Next, the system 10 reads the symbol number corresponding to this vertex node 9 (step 3903), and checks whether this symbol number is 3 (step 3904). Since the symbol number of the vertex node 9 is not 3 (No), the system 10 proceeds to step 3905, and the parent node of the vertex node 9 exists with reference to the expression of the parent-child relationship by depth-first “child → parent”. In this case, as shown in FIG. 42B, since the parent node 8 exists (Yes), the system 10 reads the symbol number corresponding to the parent node 8 (step 3906). Since the symbol number associated with node 8 is 3 and matches the search condition (step 3907, Yes), the system 10 proceeds to step 3908 and, as shown in FIG. 42C, the vertex node pointed to by the current pointer 9 is registered in the vertex node list after the search as a search result. Since the vertex node 9 has been registered, there is no need to follow the parent node any more, so the system 10 proceeds to step 3909. Since the next vertex node does not exist in the vertex node list (step 3909, No), the system 10 ends the search process.

  By the above search processing, the vertex node list [7, 9] after the search is obtained.

  In the above description, all ancestor nodes are searched when tracing the ancestor nodes of the vertex nodes. However, the search range can be limited by limiting the number of ancestor generations.

  In the above example, the vertex node list is generated as a search result. For example, a flag area as described with reference to FIGS. 29A to 29C is prepared, and all descendant nodes that hit the search condition are prepared. It is also possible to generate a node identifier as a search result.

[Search by value condition]
So far, the search based on the path condition has been described, but the present invention can perform the search based on the value condition. The search based on the value condition is a process of extracting a node associated with specified item value information (for example, a node value). For example, as shown in FIG. 26, the item name information (for example, node type) and the item value information (for example, node value) are similarly associated with the node. It is apparent that the search algorithm using the node type as a condition can be applied to a search using a value condition, that is, a search using a node value as a condition.

  Further, depending on the application, all nodes may be associated with the same node type. In such a case, since it is not necessary to associate a node type with each node, only a node value is associated with the node, and only a search based on a value condition is performed. For example, when the tree-type data structure of the present invention is applied to parsing of a programming language, since the actual value of a node is only a separated token string, the node has only this string. Associated, node type is not used.

[Combination search]
As already described, the nodes hit by the search can be represented by the vertex nodes, and the result of the search can be expressed by this vertex node list, that is, the vertex node list. For example, when the results of searching for data of a certain tree-type data structure under two independent search conditions, the first search condition and the second search condition, are represented by the first vertex node list and the second vertex node list, respectively. think of. At this time, when the logical product (AND) set operation is executed between the first vertex node list and the second vertex node list, a search result that satisfies both the first search condition and the second search condition is obtained. A vertex node list representing is obtained.

  More specifically, for the data of the tree-type data structure of FIG. 27A, the search condition 1 = “nodes with descendant button type (symbol number = 1)”, with the vertex node list [1, 6, 8] as the search range Let us consider an example in which a search is executed using a search condition of “vertex node in which a node exists” and search condition 2 = “vertex node in which a deformed quadrangle (symbol number = 4) node exists” as a search condition.

  As a result of the search based on the search condition 1, the vertex node list 1 = [6, 8] as described with reference to FIGS. Further, when the same search as the search condition 1 is executed for the search condition 2, it can be seen that the result of the search is the vertex node list 2 = [1, 8]. Further, the search condition 3 = (search condition 1) AND (search condition 2) is used as the search condition, that is, the search condition 3 = “vertex node in which a button type node and a deformed square type node exist in descendants”. When the search is executed in the same manner, the result of the search is the vertex node list 3 = [8].

  On the other hand, when the AND operation of the vertex node list 1 = [6, 8] and the vertex node list 2 = [1, 8] is executed, both the vertex node list 1 and the vertex node list 2 are normal subtree groups. (Vertex node list 1) AND (vertex node list 2) = [8] = vertex node list 3

  As described above, according to the present invention, a search result using a logical product of a plurality of search conditions as a search condition is obtained by a logical product operation of the vertex node list of the search result based on each search condition. Further, even when logical sum is used instead of logical product, the search result using the logical sum of a plurality of search conditions as the search condition is obtained by the logical sum operation of the vertex node list of the search result by each search condition. It is done.

[Overview of tree data aggregation]
In general, tree data is aggregated by classifying item value information associated with a range of nodes in the tree for each item name information. Aggregation includes various processes such as counting the number of item value information, which is a measure of aggregation, or calculating a total value, average value, maximum value, minimum value, and the like. The measure that is a target of aggregation is, for example, a node value corresponding to a specific node type associated with the node. The range of aggregation is, for example, a partial tree group, and can be specified by a vertex node list of the partial tree, that is, a vertex node list. The dimension that is the classification target for aggregation is, for example, a node value corresponding to a specific node type associated with the node.

  43A and 43B are diagrams for explaining aggregation according to an embodiment of the present invention, and FIG. 43A is a description of a “child → parent” expression of a parent-child relationship between a tree-type data structure and nodes to be aggregated. FIG. 43B is a diagram showing the correspondence between symbol numbers, display figures, and symbol names. Two types of tree data aggregation will be described with reference to examples shown in FIGS. 43A and 43B.

  The first tree data aggregation is, for example, calculating the number of weights (measures) and the total for each manufacturer name (dimension). In this example, the vertex node list = [1, 6, 8] is used to specify the range of aggregation. Of course, the total range may be the whole tree.

  In the above example, the dimension is specified, but in the tree data aggregation, the aggregation without specifying the dimension, that is, the second tree data aggregation is also conceivable. For example, a vertex node list can be specified and measures can be aggregated for each vertex node. The second tree data aggregation is a type of aggregation that explicitly specifies this vertex node, that is, a partial tree. In the example of FIGS. 43A and 43B, the second tree data totalization is designated by the vertex node list = [1, 6, 8], and each of the vertex node 1, the vertex node 6, and the vertex node 8 is represented by the vertex node. The number of weights (measures) associated with the nodes included in the specified partial tree and the total are calculated.

[First tree data aggregation]
Next, the first tree data aggregation will be described in detail. This aggregation is performed by specifying the aggregation target = measure, the aggregation range = category, and the aggregation classification target = dimension.

  As shown in FIG. 43A, the tree-type data structure data includes a root node and a non-root node that is a node other than the root node, and is expanded in a storage device of the computer system 10 that performs aggregation, for example, the RAM 14 Has been. In the parent-child relationship between nodes, all nodes including the root node are given a unique node identifier in preference to the child node over the same generation node, and the non-root node identifier is assigned to each non-root node. Defined by associating a node identifier assigned to each parent node of the node. Each node is associated with at least one entity information representing data. The vertex node is a node representing a node group including a specific node of the tree-type data structure and descendant nodes of the specific node.

  The computer system 10 specifies item name information representing a classification target for aggregation, specifies item name information representing an aggregation target, and specifies at least one partial tree representing a range of aggregation. The total classification target, the total target, and the total range may be input by the user via the input device 24 of the computer system 10, or may be read from the external storage medium 18, or You may set from the outside via I / F22.

  Next, the computer system 10 identifies the descendant node of the vertex node by tracing the parent-child relationship between the nodes for each vertex node, and the item name information associated with the vertex node or the descendant node of the vertex node is Item name information that represents whether or not the item name information that represents the aggregation target matches, and the item value information associated with the matched node represents the classification target related to the node group represented by the vertex node Aggregate for each item value information associated with.

  In one embodiment of the first tree data aggregation, a vertex node list, a dimension, and a measure are designated, and dimension values and measures existing in nodes in a range designated by the vertex node list are aggregated. In this case, when there are a plurality of nodes associated with dimension values of the same dimension in a range (that is, a partial tree) specified by a certain vertex node, it is necessary to separately specify which dimension value the measure belongs to. . Therefore, in the following example, for the sake of simplicity, a rule that “a total is not performed when there are a plurality of nodes associated with dimension values of the same dimension in the partial tree” is applied.

  With reference to the example shown in FIG. 43A, the relationship between the dimension and the feasibility of aggregation will be described in detail. 44A to 44D are explanatory diagrams of partial trees represented by the vertex nodes in FIG. 43A. Here, it is considered to perform aggregation for calculating the number of weights (measures) and the total for each manufacturer name (dimension).

  FIG. 44A shows a partial tree 1 represented by the vertex node 1, and since the manufacturer name which is a dimension is associated with the two nodes, the node 2 and the node 5, the weight associated with the node 1 and the node 3 is The manufacturer name cannot be specified. Therefore, aggregation for the partial tree 1 is not performed.

  FIG. 44B represents the partial tree 2 represented by the vertex node 6. In this partial tree 2, there is no node associated with the manufacturer name as a dimension, but there is a node 7 associated with a weight as a measure. As described above, when there is no dimension, aggregation is performed assuming that the dimension value is a NULL value.

  FIG. 44C represents the partial tree 3 represented by the vertex node 8. The partial tree 3 includes a node 10 associated with a manufacturer name as a dimension, and a node 9 and a node 11 associated with a weight as a measure. Thus, in the case of a partial tree with only one dimension and one or more measures, it is possible to specify which dimension value each measure belongs to, so for one dimension value one or more measures Are counted.

  If the number of weights (measures) and the total are totaled for each manufacturer name (dimension) according to the above rules, a totaling result as shown in FIG. 44D is obtained. That is, the weight corresponding to the manufacturer name = “NULL” is one weight associated with the node 7, and the total of the weights = “the node value associated with the node 7”. The weight corresponding to the manufacturer name = “the node value associated with the node 10” is two weights associated with the node 9 and the node 11, and the total of the weights = “the node value associated with the node 9”. + Node value associated with node 11 ”.

  FIG. 45 is a flowchart of the first tree data totaling method according to an embodiment of the present invention. FIGS. 46 to 48 are diagrams for explaining the operation state of the first tree data totaling method according to the embodiment of the present invention.

  First, as shown in FIG. 46, the system 10 initializes a pointer indicating an address for reading a vertex node from the vertex node list with the top address of the vertex node list (step 4501). The vertex node 1 is extracted (step 4502). Next, the system 10 specifies the partial tree of the vertex node 1 with reference to the expression of the parent-child relationship by depth-first “child → parent” (step 4504). In general, the expression of the parent-child relationship by depth-first “child → parent” has the above-mentioned excellent properties. Therefore, the partial tree is the position next to the position where the node identifier assigned to the vertex node is stored. From this, it is possible to specify by extracting a continuous area in which a value equal to or greater than the value of the node identifier assigned to this vertex node is stored. In this example, in C → P, a continuous region from the position where the node identifier 0 assigned to the node 1 is stored to the position where the value of the node identifier 1 of the node 1 is stored, that is, the node A region in which identifiers 0, 1, 2, 2, 1 are stored is a partial tree represented by vertex node 1. Since this area is an area for storing the node identifiers assigned to the node 1, the node 2, the node 3, the node 4, and the node 5, the partial tree includes the node 1, the node 2, the node 3, the node 4, and the node 5 (* 1 in FIG. 46).

  Next, the system 10 identifies a node associated with a measure (= weight) and a dimension (= manufacturer name) in the identified partial tree (step 4504). In this example, the node type of node 1 is weight, the node type of node 2 is a manufacturer name, the node type of node 3 is weight, the node type of node 4 is price, and the node type of node 5 Is the manufacturer name (* 2 in FIG. 46). Therefore, in this example, there are two measures and two dimensions. When the system 10 determines whether the number of measures is zero (step 4505), it is found that the number of measures is not zero (No), and then whether the number of dimensions is two or more. It is determined whether or not (step 4506). Since the number of dimensions is two or more (Yes) and this partial tree is not subject to aggregation, the system 10 determines whether or not the next vertex node exists (step 4511). In this example, since the next vertex node 6 exists in the vertex node list (Yes), the system 10 moves the pointer to the vertex node 6 (step 4512) and returns to step 4502.

  Next, as shown in FIG. 47, the system 10 extracts the vertex node 6 from the vertex node list (step 4502), and specifies the partial tree represented by the vertex node 6 in the same manner as already described (step 450). 4503), it can be seen that node 6 and node 7 belong to this partial tree (* 1 in FIG. 47).

  Next, the system 10 identifies a node associated with a measure (= weight) and a dimension (= manufacturer name) in the identified partial tree (step 4504). In this example, the node type of the node 6 is a price, and the node type of the node 7 is a weight (* 2 in FIG. 47). Therefore, in this example, there is one measure and the dimension is zero. When the system 10 determines whether the number of measures is zero (step 4505), it is found that the number of measures is not zero (No), and then whether the number of dimensions is two or more. It is determined whether or not (step 4506). If the number of dimensions is not two or more (No) and it is determined whether or not the number of dimensions is one (step 4507), the number of dimensions is not one (No), so the dimension value is set to a NULL value. Deemed (step 4508), the measures are tabulated (step 4510). In this example, the number of weights of the partial tree represented by the vertex node 6 is one, and the total weight is the value of the node value associated with the node 7 (not shown). Furthermore, the system 10 determines whether there is a next vertex node (step 4511). In this example, since the next vertex node 8 exists in the vertex node list (Yes), the system 10 moves the pointer to the vertex node 8 (step 4512) and returns to step 4502.

  Next, as shown in FIG. 48, the system 10 extracts the vertex node 8 from the vertex node list (step 4502), and identifies the partial tree represented by the vertex node 8 in the same manner as described above (step 450). 4503), it can be seen that node 8, node 9, node 10, and node 11 belong to this partial tree (* 1 in FIG. 48).

  Next, the system 10 identifies a node associated with a measure (= weight) and a dimension (= manufacturer name) in the identified partial tree (step 4504). In this example, the node type of the node 8 is a price, the node type of the node 9 is a weight, the node type of the node 10 is a manufacturer name, and the node type of the node 11 is a weight (* 2 in FIG. 48). ). Therefore, in this example, there are two measures and one dimension. When the system 10 determines whether the number of measures is zero (step 4505), it is found that the number of measures is not zero (No), and then whether the number of dimensions is two or more. It is determined whether or not (step 4506). The number of dimensions is not two or more (No), and if it is determined whether the number of dimensions is 1 (step 4507), since the number of dimensions is 1 (Yes), it is associated with the node 10 The node values are used as dimension values (step 4509), and the measures are totaled (step 4510). In this example, the number of weights of the partial tree represented by the vertex node 8 is two, and the total weight is the value of the node value associated with the node 9 and the value of the node value assigned to the node 11. (Not shown).

  Furthermore, the system 10 determines whether there is a next vertex node (step 4511). In this example, since there are no more vertex nodes in the vertex node list (No), the system 10 integrates the aggregation results obtained for each partial tree (step 4513). In this example, the total dimension value is the NULL value and the manufacturer name assigned to the node 10 (the node value associated with the node 10), the number of weights corresponding to the NULL value is one, and the weight Is the weight assigned to the node 7 (the node value associated with the node 7), the number of weights corresponding to the manufacturer name assigned to the node 10 is two, and the total weight is the node 9 is the sum of the value of the node value associated with 9 and the value of the node value assigned to node 11. With the above processing, the first tree data totaling method according to the embodiment of the present invention is completed.

  In the above description, when the partial tree represented by the vertex node is specified, all the descendant nodes are specified. For example, the generation number of the descendants is set up to, for example, the child node and the grandchild node. It is also possible to limit the total range by limiting.

  In the above example, the parent-child relationship between the nodes is expressed in the depth priority mode. However, the partial tree may be specified from the depth priority mode.

[Second tree data aggregation]
Next, the second tree data totaling method without specifying a dimension will be described in more detail.

  As shown in FIG. 43A, the tree-type data structure data includes a root node and a non-root node that is a node other than the root node, and is expanded in a storage device of the computer system 10 that performs aggregation, for example, the RAM 14 Has been. In the parent-child relationship between nodes, all nodes including the root node are given a unique node identifier in preference to the child node over the same generation node, and the non-root node identifier is assigned to each non-root node. Defined by associating a node identifier assigned to each parent node of the node. Each node is associated with at least one entity information representing data. The vertex node is a node representing a node group including a specific node of the tree-type data structure and descendant nodes of the specific node.

  The computer system 10 designates item name information that represents a classification target for aggregation, and specifies at least one partial tree that represents the range of aggregation. The total classification target and the total range may be input by the user via the input device 24 of the computer system 10, or may be read from the external storage medium 18, or the I / F 22 may be stored. You may set from the outside via.

  Next, the computer system 10 identifies the descendant node of the vertex node by tracing the parent-child relationship between the nodes for each vertex node, and the item name associated with the vertex node and / or the descendant node of the vertex node It is determined whether the information matches the target of aggregation, and the item value information associated with the matched node is aggregated.

  In the examples of FIGS. 43A and 43B, the second tree data tabulation method specifies the vertex node list = [1, 6, 8], and for each of the vertex node 1, the vertex node 6, and the vertex node 8, Calculate the number and total of weights (measures) associated with the nodes contained in the represented partial tree. FIG. 49 is a flowchart of a second tree data totaling method according to an embodiment of the present invention, and FIGS. 50A to 50D are explanatory diagrams of operation states of the second tree data totaling method.

  As shown in FIG. 49, the second tree data tabulation method performs an operation similar to that of the first tree data tabulation method shown in FIG. 45, but does not define a dimension. Omitted, and the process of integrating the total results for each partial tree is also omitted.

  The system 10 extracts the vertex node from the vertex node list and specifies the partial tree (step 4902 and step 4903 in FIG. 49), thereby the partial tree 1 and the partial tree 2 as shown in FIGS. 50A, B, and C. The partial tree 3 is specified, and the number of weights and the total weight are calculated for each partial tree (step 4906). FIG. 50D shows the total result for each vertex node.

  In the above description, when the partial tree represented by the vertex node is specified, all the descendant nodes are specified. For example, the generation number of the descendants is set up to, for example, the child node and the grandchild node. It is also possible to limit the total range by limiting.

  In the above example, the parent-child relationship between the nodes is expressed in the depth priority mode. However, the partial tree may be specified from the depth priority mode.

[Overview of tree data sorting]
The tree data sorting process according to the present invention includes a root node developed in a storage device and at least two node groups of tree-type data structure data including a non-root node that is a node other than the root node (nodes of nodes). This is a process of ordering a collection (for example, a partial tree). Hereinafter, for the sake of simplicity, the case where the node group is a partial tree will be described.

  The sorting process of the tree data of the present invention collects a certain index (comparison reference value) associated with each partial tree, and then orders the partial tree itself by assigning an order relation to this index. It is realized by.

  Sort processing can be roughly divided into two types according to the way of collecting indicators. The first tree data sorting method is a method of using the result of aggregation. For example, in the second tree data tabulation method, the tabulation results are collected for each partial tree. Therefore, for example, in the example of FIGS. 50A to 50D, when it is requested to arrange the partial trees 1 to 3 in the descending order of the “number of weights”, the “number of weights” shown in FIG. 50D is used as an index. Depending on the magnitude relation of the index, the order relation can be defined in the partial trees 1 to 3, that is, the partial trees 1 to 3 can be sorted.

  On the other hand, in the second tree data sorting method, the order relation is defined in the partial tree by using the information associated with the nodes of the partial tree as it is as an index instead of using the aggregation result. In the second tree data sorting method, for example, in the example of FIGS. 50A to 50D, node values of nodes whose node type is “price” in the partial tree, that is, the partial tree in the order of “price value”. Sort.

[First tree data sort]
The first tree data sorting method according to an embodiment of the present invention is, for example, portions represented by vertex node 1, vertex node 6 and vertex node 8 of data having a tree-type data structure as shown in FIG. 43A. Tree 1 (FIG. 50A), partial tree 2 (FIG. 50B) and partial tree 3 (FIG. 50C) are sorted using the number of weights as an index.

  In a storage device of the computer system 10, for example, the RAM 14, data of a tree type data structure including a root node and a non-root node that is a node other than the root node is expanded. As shown in FIG. 43A, a parent-child relationship between nodes gives a unique node identifier to all nodes including a root node in preference to a child node over a node of the same generation. This is expressed by associating the node identifier assigned to each parent node of the non-root node with the assigned node identifier. Each node is associated with item name information (for example, node type) representing the data item and item value information (for example, node value) representing the data item value, and each node group (for example, partial tree 1, partial tree) 2 and the partial tree 3) include a vertex node representing the node group (for example, the vertex node 1, the vertex node 6, and the vertex node 8) and descendant nodes of the vertex node.

  The computer system 10 designates item name information (for example, node type = “weight”) that represents an aggregation target, and at least two vertex nodes (for example, vertex node 1, vertex node 6, and vertex node) that represent the aggregation range A vertex node list including 8 is specified, for example, the target of aggregation and the range of aggregation may be input by the user via the input device 24 of the computer system 10 or read from the external storage medium 18. Alternatively, it may be set from the outside via the I / F 22.

  Next, the computer system 10 identifies the descendant node of the vertex node by tracing the parent-child relationship between the nodes for each vertex node, and the item name information associated with the vertex node or the descendant node of the vertex node is It is determined whether or not it matches the target of tabulation, and item value information associated with the matching node is tabulated. This aggregation is performed by, for example, the second tree data aggregation method described above with reference to FIGS. 49 and 50A to 50D. 51A to 51C are explanatory diagrams of a first tree data sorting method according to an embodiment of the present invention. FIG. 51A shows a comparison reference value obtained by executing the second tree data totaling method. The collection results are shown. In this example, the number of weights per vertex node is the result of collecting comparison reference values.

  Next, the computer system 10 orders the node groups represented by the vertex nodes by ordering the at least two vertex nodes according to the order relation of the item value information collected for each vertex node. In this example, 2 which is the number of weights corresponding to the vertex node 1, 1 which is the number of weights corresponding to the vertex node 6, and 2 which is the number of weights corresponding to the vertex node 8 are rearranged in ascending order. As a result, the vertex nodes are ordered. By this ordering, the vertex nodes are arranged in the order of vertex node 6, vertex node 1, and vertex node 8. For example, when the comparison reference values match, the order of the vertex nodes is performed by storing the order of the original vertex nodes. FIG. 51B shows the sorting result of the comparison reference values obtained in this way. By ordering the vertex nodes, the partial tree represented by these vertex nodes can be ordered as shown in FIG. 51C.

  In the above description, when the partial tree represented by the vertex node is specified, all the descendant nodes are specified. For example, the generation number of the descendants is set up to, for example, the child node and the grandchild node. It is also possible to limit the total range by limiting.

  In the above example, the parent-child relationship between the nodes is expressed in the depth priority mode. However, the partial tree may be specified from the depth priority mode.

[Second tree data sort]
Next, a second tree data sorting method according to an embodiment of the present invention will be described. FIGS. 52A to 52C show a “child-to-parent” representation (FIG. 52A) of a tree-type data structure and a parent-child relationship of nodes to be processed by the second tree data sorting method according to an embodiment of the present invention, and nodes FIG. 52 is a diagram for describing a list of node values for each type (FIG. 52B), and node types and node values (FIG. 52C) associated with the nodes. The vertex node is indicated by a black star (★). In this example, the node type which is item name information of each node is represented by a symbol number (= Symbol No.). The correspondence between the figure and the symbol number is shown in FIG. 43B.

  In this example, the node value that is item value information of each node is represented by a combination of a symbol number and a value number (= VNo). For each symbol number, that is, for each node type, a value list (= VL) is provided in which values of items represented by the node type are arranged in ascending order (or descending order). The value number is a pointer to the value list. For example, when the symbol number i and the value number j are associated with the node x, the node value of the node x is the j-th value in the value list unique to the symbol number i. It can be obtained by referring to the element (for example, the first element is the 0th element). A method for designating an actual value by such a combination of a value number and a value list has been proposed by the present inventor (see, for example, International Publication No. WO00 / 10103 pamphlet).

  For example, in the tree data shown in FIGS. 52A to 52C, the partial trees represented by the vertex node 1, the vertex node 6, and the vertex node 8 are the partial tree 1, the partial tree 2, and the partial tree 3, respectively. In order to refer to the value of the price belonging to each partial tree, first, among the nodes belonging to each partial tree, the node associated with the node type = “price” is identified, and then the identified node It is necessary to refer to the node value associated with. Node 1, node 2, node 3, node 4, and node 5 belong to the partial tree 1. Among these nodes, the symbol number = “2” is associated with the node whose node type is “price”. In the example shown in the figure, the node 4 is associated with symbol number = “2”. Therefore, node 4 has node type = “price”. Next, in order to refer to the value of the price of the node 4, first, referring to the value number associated with the node 4, the value number = “3”. Therefore, the node value associated with the node 4 is a value list corresponding to the symbol number = “2”, that is, an element corresponding to the value number 3 of the (price) VL (that is, the fourth element from the top). . In this example, the element corresponding to the value number 3 of (price) VL is “200”. In this way, the node value associated with the node 4 is acquired.

  As shown in FIGS. 52A to 52C, a storage device of the computer system 10, for example, the RAM 14 is expanded with data having a tree type data structure including a root node and a non-root node that is a node other than the root node. ing. In the parent-child relationship between nodes, all nodes including the root node are given a unique node identifier in preference to the child node over the same generation node, and the non-root node identifier is assigned to each non-root node. Defined by associating a node identifier assigned to each parent node of the node. Each node is associated with at least one entity information representing data, and each node group includes a specific node that is a vertex node representing the node group and descendant nodes of the specific node.

  Next, the computer system 10 designates vertex nodes representing at least two node groups to be ordered, and designates ordering targets (for example, a vertex node list) for specifying item name information serving as an index for ordering, and The ordering index (eg, node type) may be input by the user via the input device 24 of the computer system 10, or read from the external storage medium 18, or via the I / F 22, for example. May be set externally.

  Next, for each vertex node, the computer system 10 traces the parent-child relationship between the nodes to identify the descendant node of the vertex node, and within the vertex node or the descendant node of the vertex node, The item value information associated with the node associated with the item name information is acquired. In the example of FIGS. 52A to 52C, the node value may be acquired by the above method.

  Furthermore, the computer system 10 assigns an order to the at least two vertex nodes according to the order relationship of the item value information acquired for each vertex node (for example, the magnitude relationship of the acquired node values), thereby An order is given to a representative node group (for example, a partial tree).

  Next, node value acquisition and partial tree ordering will be described in more detail. FIG. 53 is a flowchart of the second tree data sorting method according to an embodiment of the present invention. The computer system 10 designates the vertex node list and the index (step 5301), and initializes the work area (step 5302). Subsequently, the computer system 10 acquires a value number corresponding to the index value (= price value) for ordering for each vertex node in the vertex node list (= [1, 6, 8]) (step 5303). Subsequently, the computer system 10 counts the number of appearances of the value number acquired for each vertex node (step 5304), and further accumulates the number of appearances counted for each value number (step 5305). Finally, the computer system 10 sorts the vertex nodes in the vertex node list in the order of the value numbers corresponding to the vertex nodes based on the cumulative number (step 5306). The order of value numbers (ascending order or descending order) corresponds to the order of sorting.

  54 to 62 are diagrams for explaining an operation state when the second tree data sorting method according to the embodiment of the present invention is applied to the data having the tree-type data structure shown in FIGS.

  As shown in FIG. 54, the computer system 10 designates the pre-sort vertex node list = [1, 6, 8] (step 5301), and the temporary value number storage area having the same size as this pre-sort vertex node list. A Tmp-VNo and a sorted vertex node list storage area are prepared, and a count area Count having the same size as the price value list VL is prepared (step 5302).

  Next, as shown in FIG. 55, the computer system 10 takes out the first vertex node 1 from the vertex node list and specifies the partial tree corresponding to the vertex node 1 (* 1 in FIG. 55). Next, the computer system 10 identifies the node having the symbol number = 2 in the partial tree (that is, the node whose node type is “price”), and the value number VNo associated with the identified node. Is stored in the first area of Tmp-VNo (* 2 in FIG. 55). Next, as shown in FIG. 56, the computer system 10 takes out the second vertex node 6 from the vertex node list and specifies the partial tree corresponding to the vertex node 6 (* 1 in FIG. 56). Next, the computer system 10 identifies the node having the symbol number = 2 in the partial tree (that is, the node whose node type is “price”), and the value number VNo associated with the identified node. Is stored in the second area of Tmp-VNo (* 2 in FIG. 56). Next, as shown in FIG. 57, the computer system 10 extracts the third vertex node 8 from the vertex node list, and specifies a partial tree corresponding to the vertex node 8 (* 1 in FIG. 57). Next, the computer system 10 identifies the node having the symbol number = 2 in the partial tree (that is, the node whose node type is “price”), and the value number VNo associated with the identified node. Is stored in the third area of Tmp-VNo (* 2 in FIG. 57). Thereby, the computer system 10 can acquire the value number associated with the vertex node (step 5303).

  Next, the computer system 10 counts the number of occurrences (existence number) of the value number stored in Tmp-VNo corresponding to the vertex node list (step 5304). As shown in FIG. 58, since the element Tmp-VNo [0] of Tmp-VNo corresponding to the top element = vertex node 1 of the vertex node list is “3”, the count area corresponding to value number = 3 Similarly, since Tmp-VNo [1] = 2, Tcount- [2] is incremented because Tmp-VNo [1] = 2, and since Tmp-VNo [2] = 1, Count [1] is changed. Increment. Thereby, the completed Count of FIG. 58 is obtained.

Next, the computer system 10 accumulates the count elements and converts the count array Count into the accumulated number array Aggr (step 5305). As shown in FIG. 59, the count array Count is
Count [0] = 0
Count [1] = 1
Count [2] = 1
Count [3] = 1
Therefore, the elements of the cumulative number array Aggr are
Aggr [0] = 0
Aggr [1] = Count [0] = 0
Aggr [2] = Count [0] + Count [1] = 1
Aggr [3] = Count [0] + Count [1] + Count [2] = 2
It becomes. For convenience of explanation, the count array Count and the cumulative number array Aggr are distinguished from each other. However, physically, the count array count and the cumulative number array Aggr may be the same region. The cumulative number array Aggr obtained in this way is arranged when the value numbers acquired in step 5303 are arranged in ascending order (when there are two or more same value numbers, the number is duplicated) , Indicates the start position of each value number. In this example, value number = 3, value number = 2, and value number = 1 appear once, so if these value numbers are arranged in ascending order,
Value number = 1
Value number = 2
Value number = 3
It becomes the order. At this time, since value number = 0 does not exist, the leading position of value number = 0 in the ascending order array of value numbers is address 0 (= Aggr [0]), and the leading position of value number = 1 is address 0. (= Aggr [1]), the leading position of value number 2 is address 1 (= Aggr [2]), and the leading position of value number 3 is address 2 (= Aggr [3]). In this way, as shown in FIG. 59, a cumulative number array Aggr is obtained. This cumulative number array Aggr can be regarded as an array of pointers indicating the storage position of the sorted vertex node list.

  Finally, the computer system 10 uses the cumulative number array Aggr to rearrange the vertex nodes in the vertex node list in the order of the value numbers associated with the vertex nodes (step 5306).

  As illustrated in FIG. 60, the computer system 10 extracts the pre-sort vertex node list [0] = vertex node 1 which is the first element from the vertex node list, and Tmp-VNo [0] corresponding to the vertex node 1. = 3 indicates an element of the sorted vertex node list indicated by Aggr [3] = 2, which is an element of the cumulative number array Aggr, that is, the sorted vertex node list [2] includes the pre-sorted vertex node list [0] = Set 1 Then, Aggr [3] is incremented. By this increment, the pointer indicating the storage position of the sorted vertex node list is moved to the next position, so that even when the value numbers are duplicated, the vertex node list can be correctly sorted.

  As shown in FIG. 61, the computer system 10 similarly applies Tmp-VNo [1 corresponding to the vertex node 6 to the vertex node list before sorting [1] = 6 which is an element of the vertex node list before sorting. ] = 2 indicates an element of the sorted vertex node list indicated by Aggr [2] = 1, which is an element of the cumulative number array Aggr indicated by [2], that is, the sorted vertex node list [1] includes the pre-sorted vertex node list [1]. = 6 is set. Then, Aggr [2] is incremented.

  Further, as shown in FIG. 62A, the computer system 10 similarly applies Tmp-VNo corresponding to the vertex node 8 to the pre-sort vertex node list [3] = 8 which is an element of the pre-sort vertex node list. [2] = 1 The element of the sorted vertex node list indicated by Aggr [1] = 0, which is an element of the cumulative number array Aggr indicated by 1, that is, the sorted vertex node list [0] is added to the sorted vertex node list [0]. 2] = 8 is set. Then, Aggr [1] is incremented.

  Through the above processing, the computer system 10 can convert the pre-sort vertex node list into the post-sort vertex node list by sorting the pre-sort vertex node list in ascending order by price as shown in FIG. 62B.

  In the above description, when the value of a certain item name information (for example, a certain node type) is designated as a sorting index, one partial tree has one node associated with the item name information. Although the second tree data sort is described with respect to an example that is one, there may be two or more nodes that hit as an index in one partial tree. In this case, one node is selected according to the sort purpose and application. In addition, when there is no node that hits as an index in one partial tree, the partial tree is handled as being excluded from sorting or giving the lowest order according to the application. be able to.

  Furthermore, in the above description, when the partial tree represented by the vertex node is specified, all the descendant nodes are specified. For example, the generation of the descendant, such as the child node and the grandchild node, is specified. It is also possible to limit the counting range by limiting the number.

  In the above example, the parent-child relationship between the nodes is expressed in the depth priority mode. However, the partial tree may be specified from the depth priority mode.

[Extension to tree group]
In the description so far, retrieval, aggregation, and sorting of data having a tree-type data structure are targeted for processing one tree data including a root node and a non-root node that is a node other than the root node. However, in a practical application, data having a tree-type data structure may be composed of a plurality of tree data. In such a case, each tree data is given a tree identifier and is distinguished by this tree identifier. The present invention is also applied to data of a tree type data structure including a plurality of tree data by performing the above-described tree type data structure data search, aggregation and sorting method for each tree data. Is possible.

  63A to 63E are diagrams showing an example of data having a tree-type data structure including a plurality of tree data, that is, tree groups. In the example shown in the drawing, information (partner, manufacturer, product number, weight, price, etc.) related to purchasing parts necessary for producing a certain product is represented as data of a tree-type data structure. Furthermore, since there are a plurality of substitutes and a plurality of suppliers for the parts, separate tree data is prepared for each acquisition route. Each node is represented in the form of (node type, node value) using item name information (ie, node type) and item value information (ie, node value) associated with the node.

  In the data of FIG. 63A, the tree identifier is tree data 1, the root node is (part number, 1), and the child nodes of the root node are node (manufacturer, A), node (weight, 10), node (Price, 5000) and node (supplier, α) exist. As shown in FIGS. 63A to 63E, the tree data may have different structures. Also, the tree data 5 shown in FIG. 63E does not include a node corresponding to node type = maker.

  Search, aggregation, and sorting can be performed on data having such a tree-type data structure. Search, aggregation, and sorting are performed individually for each tree data, and then the results of search, aggregation, and sorting are integrated. The integrated result is associated with each tree data via a tree data identifier. In this example, the root node of each tree data is a vertex node.

  For example, when a search is performed based on a path condition in which item name information = “maker”, a vertex node of tree data 1, a vertex node of tree data 2, a vertex node of tree data 3, and a vertex node of tree data 4 are searched. To hit. However, the vertex node of the tree data 5 does not hit the search. This is because the tree data 5 has no node associated with item name information = “maker”. The search result is expressed by a set of a set of a tree data identifier of the tree data and a node identifier of the vertex node. Similarly, when a search result is a node that has been hit, the search result is expressed by a set of a set of a tree data identifier and a node identifier.

  Further, it is possible to perform an item value search for searching for a node having item name information = “price” and item value information ≦ 4200. When a vertex node is returned as a search result, the vertex nodes that satisfy this search condition are the vertex node of the tree data 3, the vertex node of the tree data 4, and the vertex node of the tree data 5. Similarly, when an item value search for searching for a node having item name information = “weight” and item value information ≦ 12 is executed, the vertex nodes that hit this search are the vertex node of tree data 1 and tree data 2. Of the tree data 3.

  Next, when searching for a vertex node satisfying search condition 1 = “item name information =“ price ”, item value information ≦ 4200” and search condition 2 = “item name information =“ weight ”, item value information ≦ 12”, It can be seen that a vertex node including both nodes having a price value of 4200 or less and a weight value of 12 or less as descendant nodes is a vertex node of the tree data 3. On the other hand, the AND search results are as follows: search result of search condition 1 = “vertex node of tree data 3, vertex node of tree data 4, vertex node of tree data 5” and search result of search condition 2 = “tree data 1 coincides with the result of the logical AND operation between the vertex node 1, the vertex node of the tree data 2, and the vertex node of the tree data 3.

  Furthermore, it is possible to perform tabulation such as “number of cases per supplier” and “price average per weight”. Such tabulation is realized by expanding the elements of the vertex node list representing the tabulation range to be specified by the combination of the tree data identifier and the node identifier in the first node data tabulation method of the present invention described above. it can.

  Finally, the sort such as “low price order” is also performed in the first tree data sorting method or the second tree data sorting method of the present invention described above, where the vertex node list element is a set of a tree data identifier and a node identifier. It can be realized by extending as specified by.

  As described above, the present invention identifies a node by a set of a tree data identifier and a node identifier, and performs a method of searching, totaling, and sorting data of a tree-type data structure for each tree data. The data can be extended to a tree-type data structure including a plurality of tree data.

[Information processing device]
FIG. 64 is a block diagram of an information processing apparatus 6400 that processes data having a tree-type data structure according to an embodiment of the present invention. The information processing apparatus 6400 includes a storage unit 6401 that stores data representing a tree-type data structure, a data expansion unit 6402 that expands data of the tree-type data structure on the storage unit 6401, and conditions for tree data processing. A condition specifying unit 6403 to be set, and a tree data processing unit 6404 for processing the data expanded on the storage unit 6401 in accordance with the conditions set by the condition specifying unit 6403 are included.

  The tree data processing unit 6404 includes a search unit 6405 that executes tree data search, a total unit 6406 that executes tree data totaling, an index acquisition unit 6408 that acquires an index for sorting tree data, and a totaling unit 6406. An ordering unit 6407 that receives the aggregation result or the index from the index acquisition unit 6408 and executes tree data sorting.

  The storage unit 6401 stores data having a tree-type data structure including a root node and a non-root node that is a node other than the root node. The data expansion unit 6402 assigns a unique node identifier to all nodes including the root node, and a node identifier assigned to each parent node of the non-root node to a node identifier assigned to each of the non-root nodes. Thus, a parent-child relationship between nodes constituting the tree-type data structure is expressed, and at least one entity information representing data is associated with each node, and the tree-type data structure is constructed on the storage device. The data expansion unit 6402 may give a unique node identifier to all nodes including the root node in preference to the child nodes over the same generation nodes.

  The condition designation unit 6403 sets various conditions according to the purpose of search, aggregation, and sorting. These conditions are designated by a user via a user interface device (not shown) or are acquired from an external device. The various conditions include a search condition for at least one entity information, at least one partial tree that represents a search range, item name information that represents an aggregation target, at least one partial tree that represents an aggregation range, and an ordering target. Vertex nodes representing at least two node groups, or item name information serving as an index for ordering are included.

  The search unit 6405 determines, for each node, whether or not at least one entity information associated with the node matches the search condition, and if it matches, the search hit information is associated with the node, The search hit information is associated with the ancestor node of the node by tracing the parent-child relationship. In addition, the search unit 6405 may store a node identifier assigned to a vertex node associated with search hit information among at least one vertex node as a search result. Alternatively, the search unit 6405 identifies the ancestor node of the vertex node by tracing the parent-child relationship between the nodes for each vertex node, and at least one associated with the vertex node and / or the ancestor node of the vertex node. It is determined whether the entity information matches the search condition, and the search hit information is associated with the matched node.

  In another embodiment, the search unit 6405 follows a parent-child relationship between the nodes according to a first search condition that specifies at least one entity information, and a group of nodes to which nodes that match the first search condition belong. Is stored as a first search result, and the first search is performed by tracing the parent-child relationship between the nodes according to a second search condition designating at least one entity information. The node identifier assigned to the vertex node representing the node group to which the node matching the condition belongs is stored as the second search result, and the logic corresponding to the logical relationship between the first search condition and the second search condition By executing an operation on the first search result and the second search result, a search result that logically combines the first search condition and the second search condition is generated.

  The totaling unit 6406 traces the parent-child relationship between the nodes for each vertex node, identifies the descendant node of the vertex node, and totals the item name information associated with the vertex node and / or the descendant node of the vertex node. It is determined whether or not the object matches, and the item value information associated with the matched node is aggregated. In another embodiment, the aggregation unit 6406 identifies, for each vertex node, a descendant node of the vertex node by tracing a parent-child relationship between the nodes, and is associated with the vertex node or a descendant node of the vertex node. Determine whether the item name information matches the item name information that represents the aggregation target, and determine the item value information associated with the matched node as the aggregation target related to the node group represented by the vertex node. Aggregate for each item value information associated with the item name information to be represented.

  The ordering unit 6407 orders the node groups represented by the vertex nodes by ordering the at least two vertex nodes according to the order relation of the item value information aggregated for each vertex node.

  In another embodiment, the index acquisition unit 6408 traces the parent-child relationship between the nodes for each vertex node belonging to each tree data, identifies the descendant node of the vertex node, and determines the vertex node or the vertex node Among the descendant nodes, item value information associated with a node associated with item name information serving as an index for ordering is acquired. The ordering unit 6407 orders the node group represented by the vertex node by ordering the at least two vertex nodes according to the order relation of the item value information acquired for each vertex node.

  The present invention is not limited to the above embodiments, and various modifications can be made within the scope of the invention described in the claims, and these are also included in the scope of the present invention. Needless to say.

FIG. 1 is a block diagram of a computer system that handles a tree-type data structure according to an embodiment of the present invention. 2A and 2B are explanatory diagrams of POS data, which is an example of tree format data. FIG. 2A is an example in which the data structure (ie, topology) and data values of the tree format data are visually expressed. FIG. 2B is an example in which the same tree format data is expressed in XML format. 3A to 3C are explanatory diagrams of examples of the expression format of the tree-type data structure using the arc list. 4A to 4C are explanatory diagrams of a method for expressing a tree-type data structure based on the “child → parent” relationship. FIG. 5 is a flowchart of a method for constructing a tree-type data structure on a storage device. 6A to 6C are explanatory diagrams of processing for converting the tree structure type data in the ID format into the tree structure type data in the integer serial number format. FIGS. 7A to 7C are explanatory diagrams of processing for converting the tree structure type data in the ID format into the tree structure type data in the integer serial number format. FIG. 8 is a flowchart of node definition processing based on depth priority. FIG. 9 is an explanatory diagram of an array of parent-child relationships based on the expression “child → parent”. FIG. 10 is an explanatory diagram of an array of parent-child relationships based on the “parent → child” expression created from the depth-first tree-type data structure shown in FIG. 6C. FIG. 11 is a flowchart of node definition processing based on width priority. FIG. 12 is an explanatory diagram of an array of parent-child relationships based on the expression “child → parent”. FIG. 13 is an explanatory diagram of an array of parent-child relationships based on a “parent → child” expression created from the depth-first tree-type data structure shown in FIG. 7C. FIG. 14A is a diagram illustrating a tree-type data structure based on the breadth-first mode, and FIG. 14B is a diagram illustrating an array of a parent-child relationship based on the tree-type data structure based on a “child → parent” expression. FIG. 15A is an example of a vertex node list, and FIG. 15B is a diagram illustrating an example of a partial tree group specified by the vertex node list. FIG. 16A is an example of a vertex node list obtained by the search process, and FIG. 16B is a diagram illustrating an example of a partial tree group specified by the vertex node list. FIG. 17A is an example of an array showing the vertex node list and the aggregation result obtained by the aggregation process, and FIG. 17B is a diagram showing an example of a partial tree group specified by the vertex node list. FIG. 18A is a diagram illustrating an example of a vertex node list sorted by the number of nodes and an array indicating the number of corresponding nodes, and FIG. 18B is a diagram illustrating an example of a partial tree specified by the vertex node list. FIGS. 19A and 19C are examples of vertex node lists to be subjected to AND operations, and FIGS. 19B and 19D are examples of partial tree groups specified by the vertex node list. FIG. 20A is an example of a vertex node list showing the result of the logical product operation, and FIG. 20B is a diagram showing a partial tree group specified by the vertex node list. FIG. 21A is a diagram illustrating a tree-type data structure based on the breadth-first mode, and FIG. 21B is a diagram illustrating an array of a parent-child relationship based on the tree-type data structure based on a “child → parent” expression. 22A and 22B are diagrams illustrating the logical product operation. FIG. 23 is a flowchart showing a logical product operation process. FIG. 24 is a diagram illustrating a processing example of a logical product operation. FIG. 25 is a diagram illustrating a processing example of a logical product operation. FIG. 26 is a diagram illustrating an example of how to handle substantial values. FIG. 27A is an explanatory diagram of a “child-to-parent” representation of a parent-child relationship between a tree-type data structure and a node to be searched according to a descendant path condition according to an embodiment of the present invention, and FIG. It is a figure showing the correspondence of a display figure and a symbol name. FIG. 28 is a flowchart of a tree search method based on descendant path conditions according to an embodiment of the present invention. FIGS. 29A to 29C are diagrams for explaining the operation states of the tree search method based on the descendant path conditions according to an embodiment of the present invention. FIGS. 30A to 30C are diagrams illustrating operation states of the tree search method based on the descendant path condition according to an embodiment of the present invention. FIGS. 31A to 31C are diagrams for explaining operation states of the tree search method based on the descendant path conditions according to an embodiment of the present invention. FIGS. 32A to 32D are diagrams for explaining the operation states of the tree search method based on the descendant path conditions according to an embodiment of the present invention. FIGS. 33A to 33C are diagrams for explaining the operation states of the tree search method based on the descendant path conditions according to an embodiment of the present invention. FIG. 34 is a flowchart of a tree search method based on descendant path conditions according to an embodiment of the present invention. FIGS. 35A to 35C are diagrams illustrating operation states of the tree search method based on the descendant path conditions according to an embodiment of the present invention. 36A to 36C are diagrams for explaining the operation states of the tree search method based on the path conditions of descendants according to an embodiment of the present invention. FIGS. 37A to 37C are diagrams for explaining operation states of the tree search method based on the descendant path conditions according to the embodiment of the present invention. FIGS. 38A to 38C are explanatory diagrams of a “child → parent” expression of a parent-child relationship between a tree-type data structure and a node to be searched according to an ancestor path condition according to an embodiment of the present invention. FIG. 39 is a flowchart of a tree search method based on ancestor path conditions according to an embodiment of the present invention. 40A to 40C are diagrams for explaining the operation states of the tree search method based on the ancestor path conditions according to an embodiment of the present invention. 41A to 41C are diagrams for explaining the operation states of the tree search method based on the ancestor path conditions according to the embodiment of the present invention. 42A to 42C are diagrams for explaining the operation states of the tree search method based on the ancestor path conditions according to the embodiment of the present invention. 43A is an explanatory diagram of a “child-to-parent” representation of a parent-child relationship between a tree-type data structure and nodes that are subject to aggregation according to an embodiment of the present invention, and FIG. 43B illustrates a symbol number, a display figure, and a symbol name. It is a figure showing the correspondence of these. 44A to 44D are explanatory diagrams of partial trees represented by the vertex nodes in FIG. 43A. FIG. 45 is a flowchart of the first tree data totaling method according to an embodiment of the present invention. FIG. 46 is a diagram for explaining the operation state of the first tree data totaling method according to the embodiment of the present invention. FIG. 47 is a diagram for explaining the operation state of the first tree data totaling method according to the embodiment of the present invention. FIG. 48 is a diagram for explaining the operation state of the first tree data totaling method according to the embodiment of the present invention. FIG. 49 is a flowchart of a second tree data totaling method according to an embodiment of the present invention. 50A to 50D are diagrams for explaining the operation state of the second tree data totaling method according to the embodiment of the present invention. 51A to 51C are explanatory diagrams of a first tree data sorting method according to an embodiment of the present invention. FIG. 52A shows a tree-type data structure to be processed by the second tree data sorting method according to an embodiment of the present invention and a “child → parent” expression of the parent-child relationship of the nodes, and FIG. FIG. 52C is a diagram showing a node type and a node value associated with the node. FIG. 53 is a flowchart of a second tree data totaling method according to an embodiment of the present invention. FIG. 54 is an explanatory diagram of an operation state when the second tree data sorting method according to an embodiment of the present invention is applied to the data having the tree-type data structure shown in FIGS. FIG. 55 is an explanatory diagram of an operation state when the second tree data sorting method according to an embodiment of the present invention is applied to the data having the tree-type data structure shown in FIGS. FIG. 56 is an explanatory diagram of an operation state when the second tree data sorting method according to one embodiment of the present invention is applied to the data having the tree-type data structure shown in FIGS. FIG. 57 is an explanatory diagram of an operation state when the second tree data sorting method according to an embodiment of the present invention is applied to data having the tree-type data structure shown in FIGS. FIG. 58 is an explanatory diagram of an operation state when the second tree data sorting method according to one embodiment of the present invention is applied to the data having the tree-type data structure shown in FIGS. FIG. 59 is an explanatory diagram of an operation state when the second tree data sorting method according to one embodiment of the present invention is applied to data having the tree-type data structure shown in FIGS. FIG. 60 is an explanatory diagram of an operation state when the second tree data sorting method according to one embodiment of the present invention is applied to the data having the tree-type data structure shown in FIGS. FIG. 61 is an explanatory diagram of an operation state when the second tree data sorting method according to one embodiment of the present invention is applied to the data having the tree-type data structure shown in FIGS. 62A and 62B are explanatory diagrams of operation states when the second tree data sorting method according to one embodiment of the present invention is applied to the data having the tree-type data structure shown in FIGS. 63A to 63E are diagrams illustrating an example of data having a tree-type data structure including a plurality of tree data. FIG. 64 is a block diagram of an information processing apparatus according to an embodiment of the present invention.

Explanation of symbols

10 Computer system 12 CPU
14 RAM
16 ROM
18 Fixed storage device 20 CD-ROM driver 22 I / F
24 input device 26 display device 6400 information processing device 6401 storage unit 6402 data development unit 6403 condition designation unit 6404 tree data processing unit 6405 search unit 6406 aggregation unit 6407 ordering unit 6408 index acquisition unit

Claims (28)

A method for retrieving data of a tree-type data structure including a root node expanded in a storage device and a non-root node that is a node other than the root node,
All nodes including the root node are given a unique node identifier that is an integer sequence number starting from 0 or 1. The node identifier assigned to each non-root node is assigned to each parent node of the non-root node. The given node identifier is associated, thereby expressing the parent-child relationship between the nodes that make up the tree-type data structure,
Each node is associated with entity information representing the path of the node and the stored value of the node,
A partial tree that is a node group including a vertex node that is a specific node of a tree-type data structure and descendant nodes of the vertex node is represented by a node identifier assigned to the vertex node,
A condition designating step for designating a search condition regarding a path and / or a node storage value, and designating a search range using a vertex node list which is an array of node identifiers of vertex nodes representing the partial tree;
For each node included in the search range, it is determined whether the entity information associated with the node matches the search condition. If the information matches, the search hit information is associated with the node, and the parent-child relationship between the nodes is A search step for tracing and associating search hit information with an ancestor node of the node;
Storing a vertex node list representing the partial tree including the node associated with the search hit information as a search result;
Having a method. In the search step, the parent-child relationship between the nodes is traced in order from the parent node to the child node or from the child node to the parent node according to the number of vertex nodes.
The method of claim 1. A method for retrieving data of a tree-type data structure including a root node expanded in a storage device and a non-root node that is a node other than the root node,
All nodes including the root node are given a unique node identifier that is an integer sequence number starting from 0 or 1. The node identifier assigned to each non-root node is assigned to each parent node of the non-root node. The given node identifier is associated, thereby expressing the parent-child relationship between the nodes that make up the tree-type data structure,
Each node is associated with entity information representing the path of the node and the stored value of the node,
A partial tree that is a node group including a vertex node that is a specific node of a tree-type data structure and descendant nodes of the vertex node is represented by a node identifier assigned to the vertex node,
Designating search conditions for paths and / or node storage values, and specifying a search range using a vertex node list that is an array of node identifiers of vertex nodes representing a partial tree;
For each partial tree included in the search range, the parent-child relationship between the nodes is traced to determine whether the entity information associated with the node having a specific relationship with the partial tree matches the search condition. When a node exists, storing a vertex node list including vertex nodes representing the partial tree as a search result;
Having a method.   The method according to claim 3, wherein, in the storing step, a node having a specific relationship with the partial tree is a node belonging to the partial tree.   The method according to claim 3, wherein in the storing step, nodes having a specific relationship with the partial tree are ancestor nodes of the partial tree and / or vertex nodes of the partial tree. Search for data having a tree-type data structure including a root node expanded in a storage device and a non-root node that is a node other than the root node by logically combining the first search condition and the second search condition. A method,
All nodes including the root node are given a unique node identifier that is an integer sequence number starting from 0 or 1. The node identifier assigned to each non-root node is assigned to each parent node of the non-root node. The given node identifier is associated, thereby expressing the parent-child relationship between the nodes that make up the tree-type data structure,
Each node is associated with entity information representing the path of the node and the stored value of the node,
A partial tree that is a node group including a vertex node that is a specific node of a tree-type data structure and descendant nodes of the vertex node is represented by a node identifier assigned to the vertex node,
Designating a search range using a vertex node list which is an array of node identifiers of vertex nodes representing the partial tree;
Designating the first search condition for a path and / or node stored value ;
A step of tracing a parent-child relationship between the nodes within a search range and storing a first vertex node list including a vertex node representing a partial tree to which a node matching the first search condition belongs as a first search result. When,
Designating the second search condition for entity information;
Tracing a parent-child relationship between the nodes within a search range, and storing a second vertex node including a vertex node representing a partial tree to which a node matching the second search condition belongs as a second search result; ,
By executing a logical operation corresponding to a logical combination of the first search condition and the second search condition on the first vertex node list and the second vertex node list, the first search condition Generating a vertex node list representing a search result that logically combines the second search condition and
Having a method. A method of aggregating data of a tree-type data structure including a root node expanded in a storage device and a non-root node which is a node other than the root node,
All nodes including the root node are given a unique node identifier that is an integer sequence number starting from 0 or 1. The node identifier assigned to each non-root node is assigned to each parent node of the non-root node. The given node identifier is associated, thereby expressing the parent-child relationship between the nodes that make up the tree-type data structure,
Each node is associated with entity information representing the node type and node stored value of the node,
A partial tree that is a node group including a vertex node that is a specific node of a tree-type data structure and descendant nodes of the vertex node is represented by a node identifier assigned to the vertex node,
Using a vertex node list that is an array of node identifiers of vertex nodes that represent a partial tree, specifying a first node type that represents a classification target for aggregation, a second node type that represents a target for aggregation A step for specifying the range of aggregation;
For each partial tree included in the aggregation range, the node group belonging to the partial tree is identified by tracing the parent-child relationship between the nodes, and the second node type representing the aggregation target is associated with the node group. The node storage value associated with the node is determined for each first node type representing the classification target of aggregation related to the node group belonging to the partial tree. A step of counting,
Having a method. A method of ordering at least two nodes of data of a tree-type data structure including a root node expanded in a storage device and a non-root node that is a node other than the root node,
All nodes including the root node are given a unique node identifier that is an integer sequence number starting from 0 or 1. The node identifier assigned to each non-root node is assigned to each parent node of the non-root node. The given node identifier is associated, thereby expressing the parent-child relationship between the nodes that make up the tree-type data structure,
Each node is associated with entity information representing the node type and node stored value of the node,
A partial tree that is a node group including a vertex node that is a specific node of a tree-type data structure and descendant nodes of the vertex node is represented by a node identifier assigned to the vertex node,
Specifying a node type representing a target of aggregation, and specifying a range of aggregation using a vertex node list that is an array of node identifiers of vertex nodes representing at least two partial trees;
For each partial tree included in the range of aggregation, a node group belonging to the partial tree is identified by tracing the parent-child relationship between the nodes, and a node associated with a node type representing an aggregation target is included in the node group. Determining whether it exists, and, if present, aggregating node stored values associated with the node;
Ordering the at least two partial trees according to the order relation of the node stored values aggregated for each partial tree;
Having a method. A method of ordering at least two nodes of data of a tree-type data structure including a root node expanded in a storage device and a non-root node that is a node other than the root node,
All nodes including the root node are given a unique node identifier that is an integer sequence number starting from 0 or 1. The node identifier assigned to each non-root node is assigned to each parent node of the non-root node. The given node identifier is associated, thereby expressing the parent-child relationship between the nodes that make up the tree-type data structure,
Each node is associated with entity information representing the node type and node stored value of the node,
A partial tree that is a node group including a vertex node that is a specific node of a tree-type data structure and descendant nodes of the vertex node is represented by a node identifier assigned to the vertex node,
Specifying an ordering target using a vertex node list that is an array of node identifiers of vertex nodes representing at least two partial trees, and specifying a node type as an index of ordering;
For each partial tree included in the ordering target, a node group belonging to the partial tree is identified by tracing the parent-child relationship between the nodes, and a node type associated with the node type serving as an index for ordering is associated with the node group Obtaining a node stored value associated with, and
Ordering the at least two partial trees according to the order relation of the node stored values obtained for each partial tree;
Having a method. An information processing apparatus having a storage device that stores data of a tree-type data structure including a root node and a non-root node that is a node other than the root node, and that searches for data stored in the storage device,
All nodes including the root node are assigned a unique node identifier that is an integer sequence number starting from 0 or 1, and the node identifier assigned to each non-root node is assigned to each parent node of the non-root node. Associating the given node identifier, thereby expressing the parent-child relationship between the nodes constituting the tree-type data structure, associating each node with entity information indicating the path and node storage value of the node, Data expansion means constructed on a storage device;
A search condition related to a path and / or node storage value is specified, and a partial tree that is a node group including a vertex node that is a specific node of a tree-type data structure and descendant nodes of the vertex node is assigned to the vertex node A condition specifying means for specifying a search range using a vertex node list that is an array of node identifiers of vertex nodes representing a partial tree by being represented by an identifier;
For each node included in the search range, it is determined whether the entity information associated with the node matches the search condition. If the information matches, the search hit information is associated with the node, and the parent-child relationship between the nodes is determined. A search means for tracing and associating search hit information with an ancestor node of the node;
Means for storing, as a search result, a vertex node list representing a partial tree including nodes associated with search hit information;
An information processing apparatus. The search means traces a parent-child relationship between the nodes in order from a parent node to a child node or from a child node to a parent node according to the number of vertex nodes.
The information processing apparatus according to claim 10. An information processing apparatus having a storage device that stores data of a tree-type data structure including a root node and a non-root node that is a node other than the root node, and that searches for data stored in the storage device,
All nodes including the root node are assigned a unique node identifier that is an integer sequence number starting from 0 or 1, and the node identifier assigned to each non-root node is assigned to each parent node of the non-root node. By associating the given node identifiers, the parent-child relationship between the nodes constituting the tree-type data structure is expressed, and the entity information representing the path and the stored value of the node is associated with each node, and the tree-type data structure is Data expansion means constructed on a storage device;
A search condition related to a path and / or node storage value is specified, and a partial tree that is a node group including a vertex node that is a specific node of a tree-type data structure and descendant nodes of the vertex node is assigned to the vertex node A condition specifying means for specifying a search range using a vertex node list that is an array of node identifiers of vertex nodes representing a partial tree by being represented by an identifier;
For each partial tree included in the search range, the parent-child relationship between the nodes is traced to determine whether the entity information associated with the node having a specific relationship with the partial tree matches the search condition. Search means for storing, as a search result, a vertex node list including vertex nodes representing the partial tree when a node exists;
An information processing apparatus.   The information processing apparatus according to claim 12, wherein, in the search means, a node having a specific relationship with the partial tree is a node belonging to the partial tree.   13. The information processing apparatus according to claim 12, wherein, in the search means, a node having a specific relationship with the partial tree is an ancestor node of the partial tree and / or a vertex node of the partial tree. A storage device that stores data of a tree-type data structure including a root node and a non-root node that is a node other than the root node, and logically combines the first search condition and the second search condition An information processing apparatus for searching,
All nodes including the root node are assigned a unique node identifier that is an integer sequence number starting from 0 or 1, and the node identifier assigned to each non-root node is assigned to each parent node of the non-root node. By associating the given node identifiers, the parent-child relationship between the nodes constituting the tree-type data structure is expressed, and the entity information representing the path and the stored value of the node is associated with each node, and the tree-type data structure is Data expansion means constructed on a storage device;
A node group that specifies the first search condition and the second search condition related to a path and / or a node storage value and includes a vertex node that is a specific node of a tree-type data structure and descendant nodes of the vertex node Condition designation means for designating a search range using a vertex node list that is an array of node identifiers of vertex nodes representing the partial tree by representing a partial tree by an identifier assigned to the vertex node;
In accordance with the first search condition, a first vertex node list including a vertex node representing a partial tree to which a node matching the first search condition belongs by tracing a parent-child relationship between the nodes within the search range. A vertex node representing a partial tree to which a node that is stored as a first search result and traces the parent-child relationship between the nodes within the search range and matches the second search condition according to the second search condition Search means for storing a node list of the second vertex including the second search result,
By executing a logical operation corresponding to a logical combination of the first search condition and the second search condition on the first vertex node list and the second vertex node list, the first search condition And a combination means for generating a search result that logically combines the second search condition and
An information processing apparatus. An information processing apparatus that has a storage device that stores data of a tree-type data structure including a root node and a non-root node that is a node other than the root node, and that aggregates data stored in the storage device,
All nodes including the root node are assigned a unique node identifier that is an integer sequence number starting from 0 or 1, and the node identifier assigned to each non-root node is assigned to each parent node of the non-root node. By associating the given node identifiers, the parent-child relationship between the nodes constituting the tree-type data structure is expressed, and each node is associated with the entity information indicating the node type and the stored value of the node, and the tree-type data structure Data expansion means for expanding the data on the storage device;
Specify the first node type that represents the classification target of aggregation, specify the second node type that represents the aggregation target, and specify the vertex node that is a specific node of the tree-type data structure and the descendant nodes of the vertex node A condition that specifies the range of aggregation using a vertex node list that is an array of node identifiers of the vertex nodes that represent the partial tree, by representing the partial tree that is the node group that is included by the identifier assigned to the vertex node. Designation means;
For each partial tree included in the aggregation range, the node group belonging to the partial tree is identified by tracing the parent-child relationship between the nodes, and the second node type representing the aggregation target is associated with the node group. The node storage value associated with the node is determined for each first node type representing the classification target of aggregation related to the node group belonging to the partial tree. A counting means for counting,
An information processing apparatus. A storage device that stores data of a tree-type data structure including a root node and a non-root node that is a node other than the root node, and orders at least two nodes of the data stored in the storage device An information processing apparatus,
All nodes including the root node are assigned a unique node identifier that is an integer sequence number starting from 0 or 1, and the node identifier assigned to each non-root node is assigned to each parent node of the non-root node. By associating the given node identifiers, the parent-child relationship between the nodes constituting the tree-type data structure is expressed, and each node is associated with the entity information indicating the node type and the stored value of the node, and the tree-type data structure Data expansion means for expanding the data on the storage device;
Specify a node type that represents the target of aggregation, and represent a partial tree that is a node group that includes a vertex node that is a specific node of the tree-type data structure and descendant nodes of the vertex node by an identifier assigned to the vertex node. By specifying a range of aggregation using a vertex node list that is an array of node identifiers of vertex nodes representing at least two partial trees,
For each partial tree included in the range of aggregation, a node group belonging to the partial tree is identified by tracing the parent-child relationship between the nodes, and a node associated with a node type representing an aggregation target is included in the node group. An aggregation means for determining whether or not the node exists and, if present, a node storage value associated with the node;
Ordering means for ordering the at least two partial trees according to the order relation of the node stored values aggregated for each partial tree;
An information processing apparatus. A storage device that stores data of a tree-type data structure including a root node and a non-root node that is a node other than the root node, and orders at least two nodes of the data stored in the storage device An information processing apparatus,
All nodes including the root node are assigned a unique node identifier that is an integer sequence number starting from 0 or 1, and the node identifier assigned to each non-root node is assigned to each parent node of the non-root node. By associating the given node identifiers, the parent-child relationship between the nodes constituting the tree-type data structure is expressed, and each node is associated with the entity information indicating the node type and the stored value of the node, and the tree-type data structure Data expansion means for expanding the data on the storage device;
Represent at least two partial trees by representing a partial tree that is a node group including a vertex node that is a specific node of the tree-type data structure and descendant nodes of the vertex node by an identifier assigned to the vertex node. A condition designating unit for designating an ordering target by using a vertex node list that is an array of node identifiers of the vertex nodes to be designated, and for designating a node type as an index for ordering;
For each partial tree included in the ordering target, a node group belonging to the partial tree is identified by tracing the parent-child relationship between the nodes, and a node type associated with the node type serving as an index for ordering is associated with the node group Index acquisition means for acquiring a node stored value associated with
Ordering means for ordering the at least two partial trees according to the order relation of the node stored values acquired for each partial tree;
An information processing apparatus. To realize a search function for retrieving data stored in a storage device in a computer having a storage device that stores data of a tree-type data structure including a root node and a non-root node that is a node other than the root node The program of
All nodes including the root node are given a unique node identifier that is an integer sequence number starting from 0 or 1. The node identifier assigned to each non-root node is assigned to each parent node of the non-root node. The given node identifier is associated, thereby expressing the parent-child relationship between the nodes that make up the tree-type data structure,
Each node is associated with entity information representing the path of the node and the stored value of the node,
A partial tree that is a node group including a vertex node that is a specific node of a tree-type data structure and descendant nodes of the vertex node is represented by a node identifier assigned to the vertex node,
The search function
A function for designating a search condition regarding a path and / or a node storage value and designating a search range using a vertex node list which is an array of node identifiers of vertex nodes representing a partial tree;
For each node included in the search range, it is determined whether the entity information associated with the node matches the search condition. If the information matches, the search hit information is associated with the node, and the parent-child relationship between the nodes is determined. A function of tracing and associating search hit information with an ancestor node of the node,
And a function of storing a vertex node list representing a partial tree including a node associated with search hit information as a search result.   The program according to claim 19, wherein in the function of associating the search hit information, the parent-child relationship between the nodes is traced from a parent node to a child node or from a child node to a parent node in accordance with the number of vertex nodes. To realize a search function for retrieving data stored in a storage device in a computer having a storage device that stores data of a tree-type data structure including a root node and a non-root node that is a node other than the root node The program of
All nodes including the root node are given a unique node identifier that is an integer sequence number starting from 0 or 1. The node identifier assigned to each non-root node is assigned to each parent node of the non-root node. The given node identifier is associated, thereby expressing the parent-child relationship between the nodes that make up the tree-type data structure,
Each node is associated with entity information representing the path of the node and the stored value of the node,
The search function
A search condition related to a path and / or node storage value is specified, and a partial tree that is a node group including a vertex node that is a specific node of a tree-type data structure and descendant nodes of the vertex node is assigned to the vertex node By representing by an identifier, a function for designating a search range using a vertex node list that is an array of node identifiers of vertex nodes representing a partial tree;
For each partial tree included in the search range, the parent-child relationship between the nodes is traced to determine whether the entity information associated with the node having a specific relationship with the partial tree matches the search condition. A function of saving a vertex node list including a vertex node representing the partial tree as a search result when a node exists;
Including the program.   The program according to claim 21, wherein, in the function of saving as the search result, a node having a specific relationship with the partial tree is a node belonging to the partial tree.   The program according to claim 21, wherein in the function of saving as the search result, a node having a specific relationship with the partial tree is an ancestor node of the partial tree and / or a vertex node of the partial tree. A logical combination of a first search condition and a second search condition in a computer having a storage device that stores data of a tree-type data structure including a root node and a non-root node that is a node other than the root node A program for realizing a search function to search for
All nodes including the root node are given a unique node identifier that is an integer sequence number starting from 0 or 1. The node identifier assigned to each non-root node is assigned to each parent node of the non-root node. The given node identifier is associated, thereby expressing the parent-child relationship between the nodes that make up the tree-type data structure,
Each node is associated with entity information representing the path of the node and the stored value of the node,
The search function
A node group that specifies the first search condition and the second search condition related to a path and / or a node storage value and includes a vertex node that is a specific node of a tree-type data structure and descendant nodes of the vertex node A function for designating a search range using a vertex node list that is an array of node identifiers of vertex nodes representing a partial tree by representing a partial tree by an identifier assigned to the vertex node;
In accordance with the first search condition, a first vertex node list including a vertex node representing a partial tree to which a node matching the first search condition belongs by tracing a parent-child relationship between the nodes within the search range. A vertex node representing a partial tree to which a node that is stored as a first search result and traces the parent-child relationship between the nodes within the search range according to the second search condition and that matches the first search condition belongs A function of saving a second vertex node list including the second search result as a second search result;
By executing a logical operation corresponding to a logical combination of the first search condition and the second search condition on the first vertex node list and the second vertex node list, the first search condition And a function for generating a search result logically combining the second search condition and
Including the program. A computer having a storage device for storing data having a tree-type data structure including a root node and a non-root node that is a node other than the root node is provided with a totaling function for summing up data stored in the storage device The program of
All nodes including the root node are given a unique node identifier that is an integer sequence number starting from 0 or 1. The node identifier assigned to each non-root node is assigned to each parent node of the non-root node. The given node identifier is associated, thereby expressing the parent-child relationship between the nodes that make up the tree-type data structure,
Each node is associated with entity information representing the node type and node stored value of the node,
The aggregation function is
Specify the first node type that represents the classification target of aggregation, specify the second node type that represents the aggregation target, and specify the vertex node that is a specific node of the tree-type data structure and the descendant nodes of the vertex node A function that designates a range of aggregation using a vertex node list that is an array of node identifiers of vertex nodes representing the partial tree by representing the partial tree that is a group of nodes represented by the identifier assigned to the vertex node. When,
For each partial tree included in the aggregation range, the node group belonging to the partial tree is identified by tracing the parent-child relationship between the nodes, and the second node type representing the aggregation target is associated with the node group. The node storage value associated with the node is determined for each first node type representing the classification target of aggregation related to the node group belonging to the partial tree. A function to aggregate,
Including the program. A computer having a storage device for storing data of a tree-type data structure including a root node and a non-root node which is a node other than the root node is arranged in a sequence for at least two nodes of data stored in the storage device. A program for realizing the ordering function to be attached,
All nodes including the root node are given a unique node identifier that is an integer sequence number starting from 0 or 1. The node identifier assigned to each non-root node is assigned to each parent node of the non-root node. The given node identifier is associated, thereby expressing the parent-child relationship between the nodes that make up the tree-type data structure,
Each node is associated with entity information representing the node type and node stored value of the node,
The ordering function is:
Specify a node type that represents the target of aggregation, and represent a partial tree that is a node group that includes a vertex node that is a specific node of the tree-type data structure and descendant nodes of the vertex node by an identifier assigned to the vertex node. A function for designating a range of aggregation using a vertex node list that is an array of node identifiers of vertex nodes representing at least two partial trees,
For each partial tree included in the range of aggregation, a node group belonging to the partial tree is identified by tracing the parent-child relationship between the nodes, and a node associated with a node type representing an aggregation target is included in the node group. A function for determining whether or not the node exists and, if it exists, a node storage value associated with the node;
A function of ordering the at least two partial trees according to the order relation of the node stored values aggregated for each partial tree;
Including the program. A computer having a storage device for storing data of a tree-type data structure including a root node and a non-root node which is a node other than the root node is arranged in a sequence for at least two nodes of data stored in the storage device. A program for realizing the ordering function to be attached,
All nodes including the root node are given a unique node identifier that is an integer sequence number starting from 0 or 1. The node identifier assigned to each non-root node is assigned to each parent node of the non-root node. The given node identifier is associated, thereby expressing the parent-child relationship between the nodes that make up the tree-type data structure,
Each node is associated with entity information representing the node type and node stored value of the node,
The ordering function is:
Represent at least two partial trees by representing a partial tree that is a node group including a vertex node that is a specific node of the tree-type data structure and descendant nodes of the vertex node by an identifier assigned to the vertex node. A function for designating an ordering target using a vertex node list that is an array of node identifiers of vertex nodes to be designated, and a node type that is an index for ordering;
For each partial tree included in the ordering target, a node group belonging to the partial tree is identified by tracing the parent-child relationship between the nodes, and a node type associated with the node type serving as an index for ordering is associated with the node group The ability to retrieve the stored value of the node associated with
A function for ordering the at least two partial trees according to the order relation of the node stored values acquired for each partial tree;
Including the program.   A computer-readable recording medium on which the program according to any one of claims 19 to 27 is recorded.

Images