JPWO2009095981A1 - Method and apparatus for building tree structure data from tables - Google Patents

Abstract

Tree structure data consisting of a plurality of nodes, each node being represented by an attribute name and attribute value, is identified by a record sequence number in which one record corresponds to one node and each record represents the order of the records. Represented by an array of virtual records. The record includes a parent-child relationship field that stores a record order number of a parent node of a node corresponding to the record, an attribute name field that stores an attribute name number that specifies an attribute name that belongs to the node, and an attribute value that belongs to the node And an attribute value field for storing an attribute value number for designating.

Description

  The present invention relates to a method and apparatus for constructing tree structure data from tabular data, and in particular, tree structure data composed of a plurality of nodes, each node being represented by an attribute name and attribute value, each record being an array of records. The present invention relates to a method and apparatus constructed on a storage device as an array of virtual records identified by record sequence numbers representing the order.

  The present invention provides a device that includes a memory that stores original data having a table structure, converts the original data into tree structure data including a plurality of nodes each represented by an attribute name and an attribute value, and stores the converted data in the memory. Also related.

  Furthermore, the present invention relates to a program for causing a computer to execute the above method, a program product, and a recording medium on which the program is recorded.

  Furthermore, the present invention provides a virtual record in which tree structure data composed of a plurality of nodes each represented by an attribute name and attribute value is identified by the record sequence number in which each record represents the order of the records. Related to the recording medium recorded as an array of

  The most popular database management system (DBMS) at present is the relational database (RDB). Since RDB is a tabular database, it is well known that it is not good at handling tree structure data.

In general, it is very troublesome to extract (or interpret) tree structure data from tabular data. For example, consider a case where a target table record is defined by a plurality of items from the highest item to the lowest item. At this time, in order to interpret the tree structure data from the tabular data,
(1) Group records with the same item value in the top item,
(2) Group records classified into the same group with respect to the upper item into records having the same item value with respect to the current item,
(3) Repeat (2) until the current item reaches the lowest item.
This operation is necessary. This operation requires O (n * m) comparison operations if the tabular data has n rows and m columns (number of records = n, number of items = m). Further, since the same item name appears many times and the same item value appears many times, a large amount of memory is required to store these pieces of information. Furthermore, since the same item value appears many times, many values must be rewritten when data is updated.

  Therefore, various methods for describing tree structure data with a plurality of hierarchical tabular data have been proposed.

  First, it is difficult to associate Extensible Markup Language (XML) data having a tree structure with an RDB in general, but XML data can be displayed without greatly impairing the flexibility and flexibility of XML data. A technique for expressing the data structure in a format has been proposed (Patent Document 1). In the technique described in Patent Document 1, XML data is stored in each table in order from the root element, and appearance order information is given to the stored data. In each table, a downgrip column including appearance order information and an upgrip column assigned with appearance order information of the downgrip column of the parent data having a parent-child relationship with the stored data are created. Further, a level column for storing a level value representing the depth of the hierarchy from the root element is created in each table. However, in this technique, one table is created for each element as a data unit based on the schema information of XML data, and data according to the schema information is stored in the table.

  Second, by combining multiple tabular data expressed as an array of records that contain item values belonging to the item, it is possible to sequentially identify the records from the shallow tabular data to the deep tabular data record. Thus, a technique for converting tree structure data into a plurality of tabular data by creating a tree description table including a depth and a value indicating a record has been proposed (Patent Document 2). Also in this example, one tabular data exists for each depth.

The tabular data handled in Patent Document 1 or Patent Document 2 is data intended to be converted into tree structure data. For example, in Patent Document 1, a down grip column and an up grip column are present in a table. On the other hand, BOM (Bill of Materials) used in production management systems and traceability systems in recent years is not originally planned to be converted into tree structure data, but the data is analyzed. When comprehending or understanding data, it is necessary to expand the BOM into a tree data structure (BOM expansion). For example, in the structure type parts table, a pair of a parent part drawing number and a child part drawing number is stored as one data. For example, when there are child parts B1, B2, and B3 in the parent part A, three pairs (A, B1), (A, B2), and (A, B3) are stored in the structure-type parts table. . Further, if the child part B1 includes child parts C1 and C2, two pairs (B1, C1) and (B1, C2) are also stored in the structure-type parts table.
JP 2004-178084 A International Publication No. 2004/038612 International Publication No. 2005/088479 International Publication No. 00/10103 International Publication No. 03/040960

  Storage destination in the prior art described in Patent Document 1, by a scan or pre what data structures are present, or, in the knowledge by definition, such as Document Type Definition (DTD), for storing data You need to create a table. Therefore, it is unsuitable in terms of performance for applications such as editors in which various data structures are generated on site.

  In addition, the conventional data representation format for describing tree structure data as a plurality of hierarchized tabular data as described in Patent Document 1 or Patent Document 2 is described as a single tabular data. Although the number of comparison operations is reduced and the memory usage is reduced by the method, it is difficult to add a tree having an arbitrary topology, and the degree of freedom of data editing is low.

  Therefore, it is preferable that the data expression format describing the tree structure data can cope with a dynamic change in the data structure and has a high degree of freedom in editing.

  Tree structure data reduces the number of comparison operations to interpret itself, reduces memory usage to store itself, reduces the amount of data to be rewritten when updating the tree structure, It is preferable to make the definition unnecessary.

According to an embodiment of the present invention, tree structure data consisting of a plurality of nodes each represented by an attribute name and attribute value is identified by a record sequence number in which each record represents the sequence of records. A device constructed on a storage device as an array of records,
Means for matching a plurality of tables having a hierarchical structure with a matching key for each hierarchy, and creating a row number correspondence table between row numbers having a parent-child relationship between the parent side table and the child side table;
Means for searching the row number in the parent table and the row number in the child table having a parent-child relationship from the row number correspondence table;
A record sequence number assigned to a row in the child table is determined in the order found by the searching means, and a parent-child relationship is determined at the position identified by the record sequence number in the virtual record array. Store the record order number of the parent node of the node corresponding to the row in the child table as a field value, store the item name belonging to the row in the child table as the attribute name field value of the node, Means for storing an item value belonging to a row in the child side table as an attribute value field value of the node;
An apparatus comprising:

  In one embodiment, one record may correspond to one node. A plurality of tables having a hierarchical structure is original data of a table structure to be expanded into tree structure data. The matching key may be a join key. Matching using a join key, i.e., join, generates a join table, i.e., intermediate data, from the original data. The join table is a table that represents the original data itself in the parent-child relationship and the connection relationship between the original data in the parent-child relationship.

  According to an embodiment of the present invention, the apparatus uniquely identifies the attribute names in the order of the record order numbers from an array in which the attribute name field values of the nodes are stored in the order of the record order numbers. An attribute name number array storing attribute name numbers, an attribute name array storing the attribute names uniquely specified by the attribute name numbers in the order of the elements of the attribute name number array, and the record sequence number An attribute value number array storing attribute value numbers that uniquely identify the attribute values in order, and the attribute values uniquely specified by the attribute value numbers are stored in the order of the elements of the attribute value number array. Means for creating the attribute value array.

  According to an embodiment of the present invention, the plurality of tables is a structure-type parts table that expresses a parent-child relationship of parts, and the means for creating the row number correspondence table includes the tree structure as a top-level table. The part corresponding to the root node of the data is selected, and the same structure type parts table is used as the data of the other hierarchy.

  According to an embodiment of the present invention, the means for creating the row number correspondence table includes, as the matching key, a sequence number assigned in the order of appearance of data in the parent table, and data in the child table. The pair with the sequence number assigned to the parent data corresponding to is used.

According to an embodiment of the present invention, a memory for storing a plurality of tables having a hierarchical structure is provided, and the plurality of tables are converted into tree structure data composed of a plurality of nodes each represented by an attribute name and an attribute value. A device for converting and storing in the memory,
A matching unit for matching the plurality of tables with a matching key for each hierarchy;
A correspondence table creation unit that creates a row number correspondence table between row numbers having a parent-child relationship between a parent table and a child table that are matched for each hierarchy of the plurality of tables;
A search unit for searching for a row number in the parent table and a row number in the child table having a parent-child relationship from the row number correspondence table;
A record sequence number assigned to a row in the child table is determined in the order found by the search unit, and a parent-child relationship field is located at a position identified by the record sequence number in the virtual record array. The record order number of the parent node of the node corresponding to the row in the child table is stored as a value, the item name belonging to the row in the child table is stored as the attribute name field value of the node, and A record generation unit for storing an item value belonging to the original data belonging to a row in the child table as an attribute value field value of the node;
With
An apparatus is provided in which the tree structure data is constructed in the memory as an array of virtual records in which each record is identified by the record order number representing the order of the records.

  According to an embodiment of the present invention, the apparatus uniquely identifies the attribute names in the order of the record order numbers from an array in which the attribute name field values of the nodes are stored in the order of the record order numbers. An attribute name number array storing attribute name numbers, an attribute name array storing the attribute names uniquely specified by the attribute name numbers in the order of the elements of the attribute name number array, and the record sequence number An attribute value number array storing attribute value numbers that uniquely identify the attribute values in order, and the attribute values uniquely specified by the attribute value numbers are stored in the order of the elements of the attribute value number array. And a value separator for creating the attribute value array.

  According to an embodiment of the present invention, the plurality of tables is a structure-type parts table that expresses a parent-child relationship of parts, and the correspondence table creation unit uses the tree structure as intermediate data of the table structure of the highest hierarchy. A part corresponding to the root node of the data is selected, and the same structure type parts table is used as intermediate data of other table structures.

  According to an embodiment of the present invention, the correspondence table creating unit uses the sequence number assigned in the order of appearance of data in the parent table as the matching key and the parent corresponding to the data in the child table. Use the pair with the sequence number assigned to the side data.

According to an embodiment of the present invention, tree structure data consisting of a plurality of nodes each represented by an attribute name and attribute value is identified by a record sequence number in which each record represents the sequence of records. A method of constructing an array of records on a storage device,
A step of matching a plurality of tables having a hierarchical structure with a matching key for each hierarchy, and creating a row number correspondence table between row numbers having a parent-child relationship between the parent side table and the child side table;
The row number in the parent table and the row number in the child table that have a parent-child relationship are searched from the row number correspondence table and assigned to the rows in the child table in the order found by the search. Record of the node corresponding to the row in the child side table as the parent-child relationship field value at the position identified by the record sequence number in the virtual record array. Stores the sequence number, stores the item name belonging to the row in the child table as the attribute name field value of the node, and the item value belonging to the row in the child table as the attribute value field value of the node A step of storing
A method comprising:

  According to an embodiment of the present invention, the method uniquely identifies the attribute names in the order of the record order numbers from an array in which the attribute name field values of the nodes are stored in the order of the record order numbers. An attribute name number array storing attribute name numbers, an attribute name array storing the attribute names uniquely specified by the attribute name numbers in the order of the elements of the attribute name number array, and the record sequence number An attribute value number array storing attribute value numbers that uniquely identify the attribute values in order, and the attribute values uniquely specified by the attribute value numbers are stored in the order of the elements of the attribute value number array. The method further includes the step of creating an attribute value array.

  According to an embodiment of the present invention, the plurality of tables is a structure-type parts table that expresses a parent-child relationship of parts, and in the step of creating the row number correspondence table, the tree structure is used as a top-level table. The part corresponding to the root node of the data is selected, and the same structure type parts table is used as the table of the other hierarchy.

  According to an embodiment of the present invention, in the step of creating the row number correspondence table, as the matching key, the sequence number assigned in the order of appearance of the data in the parent table and the data in the child table The pair with the sequence number assigned to the parent data corresponding to is used.

According to an embodiment of the present invention, a memory for storing a plurality of tables having a hierarchical structure is provided, and the plurality of tables are converted into tree structure data composed of a plurality of nodes each represented by an attribute name and an attribute value. To a computer that converts and stores it in the memory,
A function of matching the plurality of tables with a matching key for each hierarchy;
A function for creating a row number correspondence table between row numbers having a parent-child relationship between the matched parent table and child table for each of the plurality of table hierarchies;
A function for searching for a row number in the parent table and a row number in the child table having a parent-child relationship from the row number correspondence table;
A function for determining the record sequence numbers assigned to the rows in the child table in the order found in the search;
In the virtual record array, the tree structure data is constructed in the memory as a virtual record array, wherein each record is identified by the record sequence number representing the order of the records. In the position identified by the record sequence number, the record sequence number of the parent node of the node corresponding to the row in the child side table is stored as the parent-child relationship field value, and the child side attribute name field value is stored in the child side as the attribute name field value. A function for storing item names belonging to rows in the table and storing item values belonging to rows in the child table as attribute value field values of the nodes;
A program for realizing the above is provided.

  According to an embodiment of the present invention, the program uniquely identifies the attribute names in the order of the record order numbers from an array in which the attribute name field values of the nodes are stored in the order of the record order numbers. An attribute name number array storing attribute name numbers, an attribute name array storing the attribute names uniquely specified by the attribute name numbers in the order of the elements of the attribute name number array, and the record sequence number An attribute value number array storing attribute value numbers that uniquely identify the attribute values in order, and the attribute values uniquely specified by the attribute value numbers are stored in the order of the elements of the attribute value number array. The above-mentioned computer further realizes the function of creating the attribute value array.

  According to an embodiment of the present invention, the plurality of tables is a structure-type parts table that represents a parent-child relationship of parts, and the program corresponds to a root node of the tree structure data as a top-level table. A function of selecting a part and using the same structure-type parts table as a table of another hierarchy is further realized in the computer.

  According to an embodiment of the present invention, the program uses, as the matching key, a sequence number assigned in the order of appearance of data in the parent table and parent data corresponding to the data in the child table. The computer is further realized with a function of using a pair with the sequence number assigned to the computer.

  According to one embodiment of the present invention, a computer-readable recording medium on which the above program is recorded is provided.

According to an embodiment of the present invention, a memory for storing a plurality of tables having a hierarchical structure is provided, and the plurality of tables are converted into tree structure data composed of a plurality of nodes each represented by an attribute name and an attribute value. To a computer that converts and stores it in the memory,
A function of matching the plurality of tables with a matching key for each hierarchy;
A function for creating a row number correspondence table between row numbers having a parent-child relationship between the matched parent table and child table for each of the plurality of table hierarchies;
A function for searching for a row number in the parent table and a row number in the child table having a parent-child relationship from the row number correspondence table;
A function for determining a record sequence number assigned to a row in the child table in the order found in the search;
In the virtual record array, the tree structure data is constructed in the memory as a virtual record array, wherein each record is identified by the record sequence number representing the order of the records. In the position identified by the record sequence number, the record sequence number of the parent node of the node corresponding to the row in the child side table is stored as the parent-child relationship field value, and the child side attribute name field value is stored in the child side as the attribute name field value. A function for storing item names belonging to rows in the table and storing item values belonging to rows in the child table as attribute value field values of the nodes;
A program product for realizing the above is provided.

According to an embodiment of the present invention, there is provided a computer-readable recording medium on which tree structure data including a plurality of nodes each represented by an attribute name and an attribute value is recorded.
The tree structure data is represented by a virtual array of records, each record being identified by a record sequence number representing the order of the records.
The record includes a parent-child relationship field that stores a record sequence number of a parent node of a node corresponding to the record, an attribute name field that stores an attribute name number that specifies an attribute name that belongs to the node, and an attribute value that belongs to the node An attribute value field for storing an attribute value number for specifying
The parent node of the node is identified by the record sequence number stored in the parent-child relationship field included in the record corresponding to the node,
The attribute name belonging to the node is specified by the attribute name number included in the record corresponding to the node and the attribute name array in which the attribute name is stored in the order of the attribute name number,
The attribute value belonging to the node is specified by the attribute value number included in the record corresponding to the node and the attribute value array in which the attribute value is stored in the order of the attribute name number;
A computer readable recording medium is provided.

  According to an embodiment of the present invention, the record order number is assigned to the record corresponding to each of the plurality of nodes in the order of depth-first search or width-first search.

  According to at least one embodiment of the present invention, the comparison operation for interpreting the tree structure data is reduced, the memory usage is reduced, the amount of data to be rewritten when the tree structure is updated is reduced, and the prior data structure is reduced. It is possible to construct tree structure data that eliminates the need to define

FIG. 1 is a block diagram showing a hardware configuration of a computer system that processes tree structure data according to an embodiment of the present invention. FIG. 2 is a diagram illustrating the hierarchical relationship of nodes in an example of tree structure data. FIG. 3A is an explanatory diagram of a data representation format with depth priority describing tree structure data according to an embodiment of the present invention. FIG. 3B is an explanatory diagram of a data representation format with breadth priority describing tree structure data according to an embodiment of the present invention. FIG. 4A is an explanatory diagram of a data representation format in which values describing tree structure data according to an embodiment of the present invention are separated. FIG. 4B is an explanatory diagram of an information block type data representation format describing tree structure data according to an embodiment of the present invention. FIG. 5 is a diagram illustrating an example of tabular data for explaining a data management mechanism based on information blocks. FIG. 6 is an explanatory diagram of an information block type data representation format. FIG. 7 is an explanatory diagram of an example of a structure-type parts table. FIG. 8 is a diagram showing the hierarchical relationship embedded in the structure-type parts table. FIG. 9 is a diagram showing the correspondence between the intermediate data created from the structure-type parts table and the records between the intermediate data. FIG. 10A is an explanatory diagram of an example of tree structure data in a depth-first format generated from a structure-type parts table. FIG. 10B is an explanatory diagram of an example of tree structure data in a width-first format generated from the structure-type parts table. FIG. 11A is an explanatory diagram of an example of tree structure data (information block type) in a depth-first format generated from a structure-type parts table. FIG. 11B is an explanatory diagram of an example of tree structure data (information block type) in a width-first format generated from a structure-type parts table. FIG. 12A is an explanatory diagram of an example of a plurality of tables describing tree structure data. FIG. 12B is a diagram illustrating a hierarchical relationship of tree structure data described in a plurality of tables. FIG. 13A is an explanatory diagram of record number correspondence table creation processing according to an embodiment of the present invention. FIG. 13B is an explanatory diagram of record number correspondence table creation processing according to an embodiment of the present invention. FIG. 14A is an explanatory diagram of tree structure data generation processing based on the depth priority method according to an embodiment of the present invention. FIG. 14B is an explanatory diagram of tree structure data generation processing based on the depth priority scheme according to an embodiment of the present invention. FIG. 14C is an explanatory diagram of tree structure data generation processing based on the depth priority scheme according to an embodiment of the present invention. FIG. 15A is an explanatory diagram of tree structure data generation processing based on the depth priority method according to an embodiment of the present invention. FIG. 15B is an explanatory diagram of tree structure data generation processing based on the depth priority scheme according to an embodiment of the present invention. FIG. 15C is an explanatory diagram of tree structure data generation processing based on the depth priority scheme according to an embodiment of the present invention. FIG. 16A is an explanatory diagram of tree structure data generation processing based on the depth priority method according to an embodiment of the present invention. FIG. 16B is an explanatory diagram of tree structure data generation processing based on the depth priority scheme according to an embodiment of the present invention. FIG. 16C is an explanatory diagram of a tree structure data generation process based on the depth priority method according to an embodiment of the present invention. FIG. 17A is an explanatory diagram of tree structure data generation processing based on the depth priority scheme according to an embodiment of the present invention. FIG. 17B is an explanatory diagram of tree structure data generation processing based on the depth priority scheme according to an embodiment of the present invention. FIG. 17C is an explanatory diagram of a tree structure data generation process based on the depth priority method according to an embodiment of the present invention. FIG. 18A is an explanatory diagram of tree structure data generation processing based on the depth priority scheme according to an embodiment of the present invention. FIG. 18B is an explanatory diagram of tree structure data generation processing based on the depth priority method according to an embodiment of the present invention. FIG. 18C is an explanatory diagram of a tree structure data generation process based on the depth priority method according to an embodiment of the present invention. FIG. 19A is an explanatory diagram of tree structure data generation processing based on the depth priority method according to an embodiment of the present invention. FIG. 19B is an explanatory diagram of tree structure data generation processing based on the depth priority method according to an embodiment of the present invention. FIG. 19C is an explanatory diagram of tree structure data generation processing based on the depth priority method according to an embodiment of the present invention. FIG. 20A is an explanatory diagram of tree structure data generation processing based on the depth priority method according to an embodiment of the present invention. FIG. 20B is an explanatory diagram of tree structure data generation processing based on the depth priority method according to an embodiment of the present invention. FIG. 20C is an explanatory diagram of tree structure data generation processing based on the depth priority scheme according to an embodiment of the present invention. FIG. 21A is a diagram showing integrated tree structure data. FIG. 21B is a diagram showing tree structure data from which a value list is separated. FIG. 21C is a diagram showing information block type tree structure data. FIG. 22 is an explanatory diagram of a conversion process to a data format based on an information block according to an embodiment of the present invention. FIG. 23 is an explanatory diagram of a value list sharing process according to an embodiment of the present invention. FIG. 24 is an explanatory diagram of a process for separating a list of item values into a value number and a value list according to an embodiment of the present invention. FIG. 25A is an explanatory diagram of a process of creating a record number correspondence table using a join according to an embodiment of the present invention. FIG. 25B is an explanatory diagram of a process of creating a record number correspondence table using a join according to an embodiment of the present invention. FIG. 26A is an explanatory diagram of processing for creating a record number correspondence table using a join according to an embodiment of the present invention. FIG. 26B is an explanatory diagram of a process for creating a record number correspondence table using a join according to an embodiment of the present invention. FIG. 27 is an explanatory diagram of the result of applying the tree structure data generation processing according to an embodiment of the present invention. FIG. 28 is an explanatory diagram of the result of applying the tree structure data generation processing according to another embodiment of the present invention. FIG. 29 is an explanatory diagram of a tree structure data generation process of the width priority method according to an embodiment of the present invention. FIG. 30 is an explanatory diagram of the tree structure data generation processing of the width priority method according to an embodiment of the present invention. FIG. 31 is an explanatory diagram of a tree structure data generation process of the width priority method according to an embodiment of the present invention. FIG. 32 is an explanatory diagram of a tree structure data generation process of the width priority method according to an embodiment of the present invention. FIG. 33 is an explanatory diagram of a tree structure data generation process of the width priority method according to an embodiment of the present invention. FIG. 34 is an explanatory diagram of a tree structure data generation process of the width priority method according to an embodiment of the present invention. FIG. 35 is an explanatory diagram of information block type tree structure data generated using the tree structure data generation process of the breadth-first method according to an embodiment of the present invention. FIG. 36 is an explanatory diagram of a result of applying the tree structure data generation processing according to the embodiment of the present invention. FIG. 37 is an explanatory diagram of the result of applying the tree structure data generation processing according to another embodiment of the present invention.

Explanation of symbols

10 Computer system 12 CPU
14 RAM
16 ROM
18 Hard disk 19 CD-ROM
20 CD-ROM driver 22 Interface 24 Input device 26 Display device 28 Bus

  Hereinafter, various embodiments for carrying out the present invention will be described in detail with reference to the drawings.

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

  A program for processing tree structure data according to an embodiment of the present invention may be stored in the CD-ROM 19 and read by the 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 device 18. Alternatively, the program may be supplied from the outside via a network (not shown), an external terminal, and the I / F 22.

  An information processing apparatus according to an embodiment of the present invention is realized by causing the computer system 10 to execute a program for processing tree structure data.

  In the following description, unless otherwise specified, various embodiments of the present invention are implemented in the environment of a computer system, and the main operation is a processor such as a CPU that executes software such as program instructions, and dedicated hardware. Or firmware or a combination thereof.

[Data representation format of tree structure data]
First, a data representation format of tree structure data according to an embodiment of the present invention will be described. In the following description, as an example, in the XML format,
<Story> Harry Potter
<Family> Potter
<Name> James <// Name>
<Name> Lily <// Name>
<Name> Harry <// Name>
</ Family>
<Family> Black
<Name> Sirius <// Name>
</ Family>
</ Story>
Consider an example of tree structure data described as The first line of the XML text defines an attribute including attribute name = Story and attribute value = Harry Potter. The second line defines an attribute including attribute name = Family and attribute value = Potter.

  FIG. 2 is a diagram showing the hierarchical relationship of nodes in this tree structure data example. According to the figure, the root node is a node having an attribute name: attribute value = Story: Harry Potter, and the root node has a child node having an attribute of Family: Potter and a family: Black. It can be seen that there are child nodes having attributes. Further, in the node Family: Potter, there are a child node Name: James, a child node Name: Lily, and a child node Name: Harry. On the other hand, a child node Name: Sirius exists in the node Family: Black. Here, the node is designated by the notation of node attribute name: attribute value.

  FIG. 3 is an explanatory diagram of a data representation format describing tree structure data according to an embodiment of the present invention. In particular, FIG. 3A shows a data representation format with depth priority in the example of the tree structure data shown in FIG. 2, and FIG. 3B shows a data representation format with width priority.

Here, the depth priority method and the width priority method will be briefly described. For example, consider a case where the nodes of the tree structure data in FIG. 2 are searched in a depth-first order from the root node, and node identifiers are assigned to the nodes in the order found. At this time, if the node identifier given to each node is 0 as the node identifier of the root node,
Node Story: Node identifier of Harry Potter = 0
Node Family: Potter node identifier = 1
Node Name: James node identifier = 2
Node Name: Node identifier of Lily = 3
Node Name: Node identifier of Harry = 4
Node Family: Black node identifier = 5
Node Name: Sirius node identifier = 6
It becomes. On the other hand, when the node of the tree structure data in FIG.
Node Story: Node identifier of Harry Potter = 0
Node Family: Potter node identifier = 1
Node Name: Node identifier of James = 3
Node Name: Node identifier of Lily = 4
Node Name: Node identifier of Harry = 5
Node Family: Black node identifier = 2
Node Name: Sirius node identifier = 6
It becomes. That is, the depth-first search represents a node search that gives priority to child nodes over the same generation node, and the breadth-first search represents a node search that gives priority to nodes of the same generation over child nodes. The description method of such tree structure data is described in Patent Document 3.

  Here, the notation of the arrangement | sequence in this specification is demonstrated. In general, an array element A can be expressed as A [i], where i is a subscript. However, in the drawing, an array element A [i] is within a region surrounded by a solid line. The boundary between the element A [i] and the element A [i + 1] is indicated by a dotted line. The subscript i of element A [i] is shown on the left side of element A [i]. Further, the subscript i of the array is represented by an integer starting from 0.

  Referring back to FIGS. 3A and 3B, the tree structure data is represented by an array of records where one record corresponds to one node and each record is identified by a record sequence number representing the order of the records. ing. Since the node and the record have a one-to-one correspondence, the record sequence number matches the node identifier described above.

  The record includes a parent-child relationship field Topology that stores the record order number of the parent node of the node corresponding to the record, an attribute name field Title that specifies an attribute name that belongs to the node, and an attribute value that specifies an attribute value that belongs to the node Field Value. For example, the element of each field of record Record [i] with record sequence number = i is represented by Topology [i], Title [i], and Value [i].

In the example of FIG. 3A with depth priority, the element of each field of the record with the record sequence number = 0 is
Topology [0] =-1
Title [0] = Story
Value [0] = Harry Potter
It becomes. A record in which a value that does not exist as a record sequence number, for example, -1, is stored in the parent-child relationship field Topology indicates that this record corresponds to a node that does not have a parent node. Therefore, it can also be seen that the record with the record order number = 0 corresponds to the root node, the attribute name of the root node is Story, and the attribute value is Harry Potter.

Furthermore, in the example of FIG. 3A, the element of each field of the record of record sequence number = 3 is
Topology [3] = 1
Title [3] = Name
Value [3] = Lily
It is. Therefore, this record corresponds to the node whose record order number of the parent node is 1, and indicates that the node attribute name = Name and the node attribute value = Lily. The parent node of the node is a node corresponding to the record of record order number = 1, that is, a node having a record order number of the parent node = 0, a node attribute name = Family, and a node attribute value = Potter I know that there is.

On the other hand, also in the example of FIG. 3B by width priority, for example, the element of each field of the record of record sequence number = 6 is
Topology [6] = 2
Title [6] = Name
Value [6] = Sirius
It is. Therefore, this record corresponds to the node whose record order number of the parent node is 2, and indicates that the node attribute name = Name and the node attribute value = Sirius. The parent node of the node is a node corresponding to the record of record order number = 2, that is, a node having a record order number of the parent node = 0, a node attribute name = Family, and a node attribute value = Black. I know that there is.

  As described above, the data representation format for describing the tree structure data according to the embodiment of the present invention is integrated into one table, so that it is very easy to operate and flexible for adding a new tree or deleting a tree. Corresponding, the freedom of data editing is high.

  Here, the array of records describing the tree structure data shown in FIGS. 3A and 3B is stored in the same format on the storage device such as a memory, that is, as an array Topology, an array Title, and an array Value. There is no need, and any representation can be used as long as the array of records can be substantially represented. Data that can equivalently represent an array of records in this way is sometimes referred to as a “virtual” record array in this document.

  For example, a record belongs to a parent-child relationship field that stores the record order number of the parent node of the node corresponding to the record, an attribute name field that stores an attribute name number that specifies an attribute name that belongs to the node, and the node It can be defined by an attribute value field that stores an attribute value number that specifies an attribute value. Then, the parent node of the node is identified by the record sequence number stored in the parent-child relationship field included in the record corresponding to the node, and the attribute name belonging to the node is included in the record corresponding to the node Number and attribute name are stored in the attribute name array stored in the order of attribute name number, and the attribute value number and attribute value included in the record corresponding to the node are attribute value numbers belonging to the node. It can be configured to be specified by the attribute value array stored in order.

  This is based on the idea of expressing values such as attribute names and attribute values by a combination of a value list VL and a pointer array VNo to the value list. The combination of the value list VL and the pointer array to the value list is also called an “information block” and is a concept proposed in Patent Document 4.

  4A and 4B are explanatory diagrams of a data representation format of tree structure data constructed on a storage device by introducing the concept of this information block according to an embodiment of the present invention. The example in the figure follows the depth priority method. FIG. 4A is an explanatory diagram of a data expression format in which an attribute name Title is separated into an attribute name number array Title_VNo and an attribute name array Title_VL, and an attribute value Value is separated into an attribute value number array Value_VNo and an attribute value array Value_VL. 4B is an explanatory diagram of an information block type data representation format derived based on the representation format of FIG. 4A. For example, when the record order number i is specified, the value of the parent-child relationship field is specified by Topology [i], the attribute name is specified by Title_VL [Title_VNo [i]], and the attribute value is Value_VL [Value_VNo [i]. ] Will be understood.

[Data management mechanism based on information blocks]
A data management mechanism based on information blocks will be briefly described so that the data representation format of FIGS. 4A and 4B can be better understood.

  FIG. 5 is a diagram showing an example of tabular data for explaining a data management mechanism based on information blocks. The tabular data is stored in a memory (for example, RAM 14) as a data structure as shown in FIG. 6 in the computer by using the data management mechanism proposed in Patent Document 4 described above. This data structure has been proposed to realize retrieval, sorting, aggregation, etc. of large-scale tabular data using hardware resources of commercially available computers, for example, personal computers, in particular, processors and memories. It should be noted that the data structure of tabular data placed on the computer memory.

  Note that “information record number representing the position in which the record is accommodated in the original tabular data (ie, the original record position number)” and “information representing the record order (ie, record order number)” It should be clearly distinguished. Every record has a source record position number associated with it. This primitive record position number is virtual information used for specifying individual records including item values corresponding to data items. In general, in the tabular data, records are not always arranged in the order of the original record position numbers. For example, when the original tabular data is sorted in ascending order with respect to the item value of a certain item, the order of the tabular data record obtained is different from the order of the original tabular data record. However, the records in the original tabular data may be arranged in the order of the source record position numbers. In this case, the source record position number and the record sequence number are initially matched. Yes.

  As shown in FIG. 6, the order number (record order number) of each record of the tabular data and the original record position number are abbreviated as a record order designation array 601 (hereinafter, this array is abbreviated as “OrdSet”). .). The record order specification array 601 stores source record position numbers in the order of record order numbers. In the example of FIG. 6, the records are arranged in the order of the original record position numbers.

  Referring to FIG. 6, regarding gender, it can be seen that the original record position number corresponding to the record order number = 0 of the tabular data is “0” from the array OrdSet [0]. The actual gender value for the record whose source record position number is “0”, ie, “male” or “female” is a value list in which the actual values are sorted according to a predetermined order (eg, ascending or descending order). An item value number array 602 (hereinafter, an item value number array, that is, a pointer array) that is a pointer array to a certain item value array 603 (hereinafter, an item value array, that is, a value list is abbreviated as “VL”). Is abbreviated as “VNo.”). The pointer array 602 stores pointers that point to elements in the actual value list 603 according to the order of the source record position numbers stored in the array OrdSet 601. As a result, the item value of the gender corresponding to the record “0” of the tabular data is (1) the original record position number = 0 corresponding to the record sequence number = 0 is extracted from the array OrdSet 601 and (2) is stored in the value list. The element “1” corresponding to the original record position number = 0 is extracted from the pointer array 602, and (3) the element “female” indicated by the element “1” extracted from the pointer array 602 to the value list is extracted from the value list 603. Can be obtained by taking out "".

  The item values can be acquired in the same manner for other records and also for age and height.

  In this way, the tabular data is expressed by a combination of the value list VL and the pointer array VNo to the value list, and this combination is particularly referred to as an “information block”. In FIG. 6, information blocks relating to gender, age and height are shown as information blocks 608, 609 and 610, respectively.

  If a single computer has a single memory (physically multiple, but a single memory in the sense that it is located and accessed in a single address space) May store the ordered set array OrdSet, the value list VL constituting each information block, and the pointer array VNo in the memory. However, in various embodiments of the present invention, the manipulation of tabular data can be performed in parallel by a plurality of arithmetic units.

[Parts list (BOM) expansion]
Next, an embodiment of the present invention will be described with respect to parts table (BOM) expansion in a production management system. In the following description, it is assumed that the configuration of the car Car_A and the car Car_B (or the part diagram number corresponding to the configuration) is given in the form of a parts table. FIG. 7 is an explanatory diagram of an example of a structure-type parts table relating to the configuration of the vehicle. In the parts table shown in the figure, pairs of figure numbers (that is, parent figure numbers) of 10 sets of parent parts and figure numbers (that is, child figure numbers) of child parts are stored. The numbers from 0 to 9 at the left end represent the record numbers of the parts table. A pair of a parent figure number and a child figure number in the BOM, that is, a record is identified by this record number. For example, a pair of parent figure number = Car_A and child figure number = Body_1 is stored in the first row of the parts table (that is, the record with record number = 0). Further, the record of record number = 1 stores a pair of parent figure number = Car_A and child figure number = Engine_1. Further, since the record number = 4, the record number = 5, and the record number = 6 store the parent figure number = Body_1, it can be seen that the respective child figure numbers are Tire_1, Chassis_1, and Door_1. . In this manner, the parts table in FIG. 7 is also called a structure-type parts table because the hierarchical relationship of the parts is embedded.

  FIG. 8 is a diagram showing a hierarchical relationship of the vehicle configuration described in the parts table of FIG. One embodiment of the present invention provides a method for converting (expanding) the parts table (original data) shown in FIG. 7 into the tree structure data shown in FIG. This method is performed by the computer system 10 shown in FIG. 1 in one embodiment of the invention. That is, the processing steps described below are executed by the computer system 10, particularly the CPU 12 in the computer system 10. Further, data, tables, and arrays generated in the processing steps are each stored in a memory (for example, RAM 14). The converted tree structure data is described in the data representation format of the tree structure data described with reference to FIGS. 3A and 3B or FIGS. 4A and 4B.

Step 1: Designation of Data to be Expanded The parts table itself describes a parent-child relationship, but it is not always arranged in, for example, depth priority order or width priority order. Therefore, in order to convert the parts table into tree structure data, first, the data to be expanded (the root node of the tree structure data) is designated. The data to be expanded is stored in advance in the hard disk 18 and the input device 24 of the computer system 10 shown in FIG. 1, or supplied from the CD-ROM 19 via the CD-ROM driver 20, or the I / F 22 It is given in various forms such as being supplied from an external terminal via The CPU 12 of the computer system 10 designates data given in any form as data to be developed. In this example, consider the case where Car_A is converted into tree structure data.

Step 2: Creation of a table of data to be expanded Next, a table of data to be expanded is created as intermediate data of the first hierarchy. Specifically, a table including one record (record number = 0) in which item name = development command and item value = Car_A is created. In addition, since it is not necessary to assume that the record order is changed for the record created as the intermediate data, the record order number is sometimes referred to as a record number for simplicity. In addition, the item name and the item value may be collectively referred to as an item. At this time, the item is distinguished by the item name. Therefore, the notation of item = expansion command indicates an item of item name = expansion command.

Step 3: Create record number correspondence table (first time)
A parts table that is original data is prepared as intermediate data of the second hierarchy. The key item for sharing (ie, matching key) between the intermediate data of the first hierarchy (ie, the parent table) and the intermediate data of the second hierarchy (ie, the child table) Matching is executed, and a record number correspondence table is created between the two hierarchies. For example, if a certain record (for example, record a) in the intermediate data of the first hierarchy and a certain record (for example, record b) in the intermediate data of the second hierarchy have the same item value for the key item The combination of the record a in the intermediate data of the first hierarchy and the record b in the intermediate data of the second hierarchy is registered in the record number correspondence table. In this document, a record included in original data or intermediate data may be referred to as a “row” in order to distinguish it from a record in a virtual record array. Similarly, the record number may be referred to as a “line number”, and the record number correspondence table may be referred to as a “line number correspondence table”.

  An example of such matching can be realized by a join. For example, as described in Patent Document 5, an equivalent item (that is, a join key) is found between two tabular data described using an information block, and the equivalent is equivalent. This is a technique for comparing value lists included in an information block relating to an item, and sharing a value list referenced by both tabular data. A method of creating a record number correspondence table using a join will be described later.

In this example, the intermediate data item of the first hierarchy = development command and the intermediate data item of the second hierarchy = the parent figure number are selected as key items for sharing. An item value = Car_A is stored in the record of record number = 0 of the intermediate data in the first layer (hereinafter, for the sake of simplicity, the record of record number = N may be expressed as record N). On the other hand, it can be seen that the records in which the item value = Car_A is stored in the intermediate data item of the second hierarchy = the parent figure number are the record 0 and the record 1. Therefore, between the intermediate data of the first hierarchy and the intermediate data of the second hierarchy,
0 → 0, 1
The record number correspondence table is created.

Step 4: Create record number correspondence table (second time)
The record number correspondence table is continued until there is no record having the same item value for the key item for sharing. More specifically, it is checked whether or not there is further data having a parent-child relationship with respect to the record 0 and the record 1 of the intermediate data in the second hierarchy appearing in the record number correspondence table created in step 3. In this example, a parts table that is original data is further prepared as intermediate data in the third hierarchy. In the case of parts list expansion, original data is repeatedly used as intermediate data. This is because the structure type parts table has a hierarchical relationship embedded in one table. Between the intermediate data of the second hierarchy and the intermediate data of the third hierarchy, the intermediate data item of the second hierarchy = the child figure number and the intermediate data item of the third hierarchy = the parent figure number is a key for sharing Selected as an item.

The item = child figure number of record 0 of the intermediate data in the second hierarchy is item value = Body_1, and the item of record 1 = child figure number is item value = Engine_1. On the other hand, the records in which the item value = Body_1 is stored in the intermediate data of the third hierarchy, that is, the item of the parts table as the original data = the parent figure number are the record 4, the record 5, and the record 6. Also, there is no record in which item value = Engine_1 is stored in the intermediate data of the third hierarchy, that is, the item of the parts table as the original data = the parent figure number. Therefore, between the intermediate data of the second hierarchy and the intermediate data of the third hierarchy,
0 → 4, 5, 6
1 →
The record number correspondence table is created.

Step 5: Create record number correspondence table (third time)
Referring to the record number table created between the second hierarchy and the third hierarchy, the items belonging to the record 4, the record 5 and the record 6 of the intermediate data in the third hierarchy = the child figure number, and the fourth hierarchy A record number correspondence table is further created using the intermediate data, that is, the item of the parts table as the original data = the parent figure number as a key item. However, in this example, the item value of the record 4 of the intermediate data in the third layer = Tire_1, the item value of the record 5 = Chassis_1, and the item value of the record 6 = Door_1 are records of the intermediate data of the fourth layer. Item = not present in parent figure number. Therefore, it has been found that there is no need to create intermediate data of the fourth hierarchy and a record number correspondence table between the third hierarchy and the fourth hierarchy.

  FIG. 9 is a diagram showing the correspondence between the intermediate data created from the structure-type parts table and the records between the intermediate data by the processing from step 1 to step 5 described above. The arrows between the intermediate data Table_0 and the intermediate data Table_1 and the arrows between the intermediate data Table_1 and the intermediate data Table_2 are respectively a record number correspondence table between the first hierarchy and the second hierarchy, and This is equivalent to the record number correspondence table between the second layer and the third layer.

Step 6: Generation of tree structure data from record number correspondence table Next, tree structure data is generated from the acquired record number correspondence table. As described above, the record number correspondence table between Table_0 and Table_1 is
0 → 0, 1
The record number correspondence table between Table_1 and Table_2 is
0 → 4, 5, 6
1 →
It is. 10A and 10B show the generated tree structure data. FIG. 10A is an explanatory diagram of an example of tree structure data in a depth priority format generated from a structure type BOM, and FIG. 10B is an explanatory diagram of an example of tree structure data in a width priority format generated from the same structure type BOM. It is.

  The step of generating tree structure data from the record number correspondence table is either depth-first or width-priority, and the record number in the intermediate data on the parent side having a parent-child relationship from the record number correspondence table and the intermediate on the child side Step 6-1 for searching for a record number in the data and Step 6-2 for generating a record in the virtual record array of the tree structure data are included.

  In step 6-1, if depth-first search is executed, tree structure data in the depth-first format is generated, and if width-first search is executed, tree structure data in the width-first format is generated. Whether to select depth priority or width priority may be set in advance, may be specified every time by the user, or may be automatically selected according to the application.

For example, in this example, when a depth-first search is performed,
(1) Table_0 [0] → Table_1 [0]
(2) Table_1 [0] → Table_2 [4]
(3) Table_1 [0] → Table_2 [5]
(4) Table_1 [0] → Table_2 [6]
(5) Table_0 [0] → Table_1 [1]
Records with parent-child relationships are acquired in this order.

  Step 6-2 is executed each time one parent-child relationship is acquired in Step 6-1. For example, in step 6-1, when the parent-child relationship (1) is first acquired, a record sequence number 0 is assigned to a record to be newly created in the virtual record array, and the record sequence number 0 is set. The assigned record Record [0] corresponds to the record sequence number Topology [0] of the parent node of the node corresponding to this record, the item name Title [0] of the original data corresponding to this record, and this record The item value Value [0] of the original data to be stored is stored. In this example, Record [0] corresponds to the intermediate data Table_0 [0]. Since the node corresponding to this record has no parent node, Topology [0] = − 1. In addition, an item name = Table_0 [0] is stored in Title [0], and an item value = Car_A in Table_0 [0] is stored in Value [0]. Subsequently, a new record related to the child-side record of the parent-child relationship (1) is generated in the tree structure data. Therefore, the next record sequence number 1 is assigned to a record to be newly generated corresponding to the child record. Therefore, the newly generated record is Record [1]. Then, Topology [1] stores the record order number of the record corresponding to the parent node of the node corresponding to this record, that is, 0, and Title [1] contains the item name = child figure number of Table_1. Stored in Value [1], the item of Table_1 [0] = the item value accommodated in the child figure number = Body_1 is stored. If a new record is generated in step 6-2, the process returns to step 6-1 to search for the next parent-child relationship.

  In this example, next, the parent-child relationship (2) is found, the process proceeds again to step 6-2, and a new record is generated. In this step, since the record related to Table_1 [0] on the parent side has already been generated, the record Record [2] related to Table_2 [4] on the child side is generated in the same manner as Record [1]. Since the parent node of the node corresponding to the record 2 is the record 1, Topology [2] = 1. In addition, the item name of Table_2 = child figure number is stored in Title [2], and the item value = Tire_1 stored in Item_2 [4] item = child figure number is stored in Value [2]. The Thereafter, by repeatedly executing Step 6-1 and Step 6-2 in the depth priority method, an array of virtual records representing the tree structure data as shown in FIG. 10A is generated.

  In the case of the width priority method, the virtual record array representing the tree structure data as shown in FIG. 10B is obtained by repeatedly executing Step 6-1 and Step 6-2 as in the depth priority method. Generated.

Step 7: Separation of values As described with reference to FIGS. 4A and 4B, the item = Title and the item = Value in the tree structure data can be separated into an item value array and a pointer array to the item value array. it can. Therefore, in a preferred embodiment, the item = Title and the item = Value are converted into the information block type in order to improve the efficiency of search / aggregation / sorting based on the tree structure data. On the other hand, since item = Topology is described by an array of integers, there is no need to convert it to an information block type.

  11A and 11B are diagrams showing tree structure data generated by converting the tree structure data shown in FIGS. 10A and 10B into an information block type. 11A corresponds to the depth-priority tree structure data in FIG. 10A, and FIG. 11B corresponds to the width-priority tree structure data in FIG. 10B.

  As described above, according to an embodiment of the present invention, it is possible to generate integrated tree structure data from a structure-type parts table. Tree structure data can be generated in either depth-first or width-first format as required.

[Integration of tree structure data described in multiple tables]
In the description in Patent Document 1 or Patent Document 2, tree structure data is expressed by a chain or connection of a plurality of tables. Therefore, operations such as search, sort, and aggregation for tree structure data are not easy. Therefore, in one embodiment of the present invention, a method for converting tree structure data described in a plurality of tables into integrated tree structure data is provided.

  12A and 12B are explanatory diagrams of an example of tree structure data described in a plurality of tables. FIG. 12A illustrates a plurality of tables describing tree structure data, and FIG. 12B illustrates a plurality of tables. The hierarchical relationship of the tree structure data described by is shown.

  In FIG. 12A, the first table Table_0 has an item Story and an item DGrip. Here, the item Story is substantive information belonging to the data, and the item DGrip is information used to express the parent-child relationship between the elements of the table. The second table Table_1 has an item UGrip, an item Family, and an item DGrip. Here again, the item Family is substantive information, and the item UGrip and the item DGrip are information used to express a parent-child relationship. The third table Table_2 holds an item UGrip which is information for expressing a parent-child relationship and an item Name which is substantial information. The down grip represented as DGrip is a sequence number assigned in the order of appearance of data. The up grip indicated as UGrip is the value of the down grip assigned to the parent element. Therefore, generally, if the value of UGrip of a record i in a certain table is m and the value of DGrip of record j in the immediately preceding table is m, the parent element of record i in a certain table is Record j in the table. Each record corresponds to one node in the tree structure data, and an item name and an item value, which are substantive information of each record, represent an attribute name and an attribute value belonging to the node corresponding to the record. Yes. As described above, the tree structure data is described in a plurality of tables by combining the up grip and the down grip.

  Referring to FIG. 12B, the plurality of tables in FIG. 12A include a tree having Harry Potter as a root node, Mr. It can be seen that it represents tree structure data including two trees of which the Incredible is a root node. It is said that such a plurality of tables know in advance what data structure exists by scanning data or defining the data structure, creating a storage destination table accordingly, and storing the data Since it is constructed according to the procedure, it is unsuitable in terms of performance for an application such as an editor in which various data structures are generated at any time.

[Integrated tree structure data of depth-first method]
First, an embodiment of the present invention for converting tree structure data described in a plurality of tables, that is, original data into integrated tree structure data of a depth-first method will be described. The processing steps described below are executed by the computer system 10, particularly the CPU 12 in the computer system 10. Further, data, tables, and arrays generated in the processing steps are each stored in a memory (for example, RAM 14).

Step 1: Creation of Record Number Correspondence Table A record number correspondence table is created between the first layer table Table_0 and the second layer table Table_1. The record number correspondence table is created by joining the two tables Table_0 and Table_1 with the table DGrip and Table_1 items UGrip as key items. It should be noted that, according to one embodiment of the present invention, joins are used to create a record number correspondence table, so there is no need to generate a join table. Since the record 0 of Table_0 matches the key item value = 0 of the record 1 and the record 2 of Table_1, the record 1 of the table_1 and the key item value = 1 of the record 0 of Table_1 match.
0 → 1, 2
1 → 0
The record correspondence table is completed. Similarly, if a record number correspondence table is created between the table Table_1 of the second layer and the table Table_2 of the third layer,
0 → 4, 5, 6, 7
1 → 1, 2, 3
2 → 0
The record number correspondence table is obtained. 13A and 13B are explanatory diagrams of a record number correspondence table creation process according to an embodiment of the present invention. FIG. 13A shows a record number correspondence table between Table_0 and Table_1, and FIG. , A record number correspondence table between Table_1 and Table_2 is shown.

Step 2: Generation of tree structure data from record number correspondence table Next, tree structure data is generated from the acquired record number correspondence table. Specifically, the value of the Topology field, the value of the Title field, and the value of the Value field are stored in each record of the virtual record array.

Step 2-1: Generation of Record 0 Step 2-1: Initialization Array Topology, Array Title, Array Value, and stack array ParentNodeNo storing the record identification number of the parent node are secured in the memory, and the stack -1 is set to the top of the array, that is, ParentNodeNo [0]. Further, the value −1 stored in the stack array ParentNodeNo is copied to Topology [0]. 14A to 14C are explanatory diagrams of tree structure data generation processing based on the depth priority method according to an embodiment of the present invention, and FIG. 14A shows the processing of step 2-1-1.

Step 2-1-2: Value Storage FIG. 14B shows a process for generating record 0 corresponding to the root node (node 0). Since the current position in the record number correspondence table indicated by the upward arrow in the drawing is the record 0 of Table_0, the item name and item value of the record 0 of Table_0 are acquired, and Title [0] and Value [ 0] respectively.

Step 2-1-3: Move to Child Node FIG. 14C shows a move process to the child node. As shown in the figure, the current position is moved to the child node according to the record number correspondence table. At this time, the storage address (subscript) of the parent node, that is, the record sequence number = 0 is pushed to the stack array ParentNodeNo. In addition, since the pointers to the array Topology, array Title, and array Value indicated by the horizontal arrows in the same figure indicate the record positions where the values have been stored, the pointer is incremented (go forward one step). ).

Step 2-2: Generation of Record 1 FIGS. 15A to 15C show a process for generating record 1 corresponding to node 1. First, as shown in FIG. 15A, the value stored in the stack array ParentNodeNo is copied to the array Topology [1]. Next, as shown in FIG. 15B, since the current position in the record number correspondence table is the record 1 of Table_1, the item name and item value of the record 1 of Table_1 are acquired, and Title [1] And Value [1]. Finally, as shown in FIG. 15C, the current position is moved to the child node according to the record number correspondence table. At this time, the storage address (subscript) of the parent node, that is, the record sequence number = 1 is pushed to the stack array ParentNodeNo. In addition, since the pointers to the array Topology, array Title, and array Value indicated by the horizontal arrows in the same figure indicate the record positions where the values have been stored, the pointer is incremented (go forward one step). ).

Step 2-3: Generation of Record 2 FIGS. 16A to 16C show processing for generating record 2 corresponding to node 2. FIG. First, as shown in FIG. 16A, the value stored in the stack array ParentNodeNo is copied to the array Topology [2]. Next, as shown in FIG. 16B, since the current position in the record number correspondence table is the record 1 of Table_2, the item name and the item value of the record 1 of Table_2 are acquired, and Title [2] And Value [2]. Finally, as shown in FIG. 16C, it is checked whether there is a child node according to the record number correspondence table. If there is no child node, it is checked whether there is a younger brother node. In this example, since there is a younger brother node, the current position in the record number correspondence table is moved to the younger brother node. Since this is a depth-first method, the child node is examined in preference to the brother node. When the current position is moved to the younger brother node, the stack array ParentNodeNo is not operated. Further, since the pointers to the array Topology, array Title, and array Value indicated by the horizontal arrows in FIG. 16C point to the record positions where the values have been stored, the pointers are incremented (go forward one step). ).

Step 2-4: Generation of Record 3 As shown in FIGS. 17A-C, record 3 is generated in the same manner as in Step 2-3 shown in FIGS. 16A-C.

Step 2-5: Generation of Record 4 FIGS. 18A to 18C show processing for generating record 4 corresponding to node 4. First, as shown in FIG. 18A, the value stored in the stack array ParentNodeNo is copied to the array Topology [4]. Next, as shown in FIG. 18B, since the current position in the record number correspondence table is the record 3 of Table_2, the item name and the item value of the record 3 of Table_2 are acquired, and Title [4] And Value [4]. Finally, as shown in FIG. 18C, it is checked whether there is a child node according to the record number correspondence table. If there is no child node, it is checked whether there is a brother node. In this example, since there is no younger brother node, the current position in the record number correspondence table is moved (returned) to the parent node. When returning the current position to the parent node, the record sequence number stored from the stack array ParentNodeNo is popped. The parent node corresponds to the record 1 of Table_1. Next, it is checked whether there is a younger brother node in this parent node. In this example, since a younger brother node exists, the current position in the record number correspondence table is moved to the younger brother node of the record 1 of Table_1, that is, the record 2 of Table_1. Further, since the pointers to the array Topology, array Title, and array Value indicated by the horizontal arrows in FIG. 18C point to the record positions where the values have been stored, the pointers are incremented (go forward one step). ).

Step 2-6: Generation of Record 5 FIGS. 19A to 19C show processing for generating record 5 corresponding to node 5. First, as shown in FIG. 19A, the value stored in the stack array ParentNodeNo is copied to the array Topology [5]. Next, as shown in FIG. 19B, since the current position in the record number correspondence table is the record 2 of Table_1, the item name and the item value of the record 2 of Table_1 are acquired, and Title [5] And Value [5]. Finally, as shown in FIG. 19C, the current position is moved to the child node according to the record number correspondence table. At this time, the storage address (subscript) of the parent node, that is, the record sequence number = 5 is pushed to the stack array ParentNodeNo. In addition, since the pointers to the array Topology, array Title, and array Value indicated by the horizontal arrows in FIG. 19C point to the record positions where the values have been stored, the pointers are incremented (go forward one step). ).

Step 2-7: Generation of Record 6 FIGS. 20A to 20C show processing for generating record 6 corresponding to node 6. FIG. First, as shown in FIG. 20A, the value stored in the stack array ParentNodeNo is copied to the array Topology [6]. Next, as shown in FIG. 20B, since the current position in the record number correspondence table is the record 0 of Table_2, the item name and the item value of the record 0 of Table_2 are acquired, and Title [6] And Value [6], respectively. Finally, as shown in FIG. 20C, it is checked whether there is a child node according to the record number correspondence table. Since there is no child node, it is checked whether a brother node exists. In this example, since there is no younger brother node, the current position in the record number correspondence table is moved (returned) to the parent node. When returning the current position to the parent node, the record sequence number stored from the stack array ParentNodeNo is popped. The parent node corresponds to the record 2 of Table_1. Next, it is checked whether there is a younger brother node in this parent node. In this example, since there is no younger brother node, the current position in the record number correspondence table is moved to the parent node of the record 2 of Table_1, that is, the record 0 of Table_0. At this time, the record sequence number stored from the stack array ParentNodeNo is popped. In addition, since the pointers to the array Topology, array Title, and array Value indicated by the horizontal arrows in FIG. 20C point to the record positions where the values have been stored, the pointers are incremented (go forward one step). ).

  As a result of the above processing, the current position in the record number correspondence table has returned to the record 0 of Table_0, so that the integrated tree structure data of the depth priority method for the Harry Potter is completed.

  Mr. of the record 1 of the other Table_0. The integrated tree structure data of the depth-first method regarding Incredible is also generated by the same processing. The process of the record 1 of Table_0 may be sequentially executed by one processor after the process related to the record 0 of Table_0. For example, the process related to the record 0 of Table_0 using a plurality of processors, Processing regarding the record 1 of Table_0 may be executed in parallel.

Step 3: Generation of Tree Structure Data with Separated Value List The tree structure data generated in Step 2 can be converted into tree structure data with a separated value list. The tree structure data from which the value list is separated is equivalent to the information block type tree structure data. Thus, in one embodiment of the present invention, a method is provided for converting consolidated tree structure data into tree structure data with separated value lists. 21A to 21C are explanatory diagrams of tree structure data generated from the original data in FIG. 12A and from which the value list is separated. FIG. 21A shows the integrated tree structure data.

In this embodiment, values appearing in the array Title are separated into a value number and a unique and ascending (or descending) value list, and values appearing in the array Value are also unique and ascending (or descending) values. Separated into a list. For example, referring to the array Title, the values that appear in the array Title are:
Story
Name
Family
It is three. If you sort these three values alphabetically,
Family
Name
Story
It becomes in order. Therefore, a value number 0 is assigned to the value Family, a value number 1 is assigned to the value Name, a value number 2 is assigned to the value Story, and
VL [0] = Family
VL [1] = Name
VL [2] = Story
When the value list is prepared, the values are separated into a value number VNo and a value list VL. FIG. 21B shows tree structure data in which values are separated into value numbers and value lists in this way. FIG. 21C shows information block type tree structure data in which a set of a value number and a value list is separated with respect to an item Title and an item Value.

  When the value list is separated in this way, the array Title and the array Value become integer arrays, so that the computer can process them at high speed. In addition, the separation of the value list eliminates the holding of duplicate values, thereby reducing the data size. Furthermore, the separation of the value list eliminates the need to repeatedly check whether the search condition is satisfied for the same value at the time of search, thus facilitating the search. In addition, the separation of the value list facilitates tabulation because the list of dimension values can be used immediately at the time of tabulation. In addition, by separating the value list, counting can be used for sorting, so that sorting becomes easy.

[Generation of tree structure data using ordered set and value list]
In one embodiment of the present invention described above, the values in the tree structure data are separated into value numbers and value lists after the integrated tree structure data is created. In contrast, in another embodiment of the present invention, tree structure data described in a plurality of tables, that is, integrated tree structure data is generated after separating original data into an ordered set and an information block. A method is provided. The processing steps described below are also executed by the computer system 10, particularly the CPU 12 in the computer system 10. Further, data, tables, and arrays generated in the processing steps are each stored in a memory (for example, RAM 14).

Step 1: Conversion of Data Format First, the original data shown in FIG. 12A, that is, Table_0, Table_1, and Table_2 are converted into a data format composed of an ordered set array OrdSet and an information block. This data format is as described in [Data management mechanism based on information block]. FIG. 22 is an explanatory diagram of the conversion from the original data shown in FIG. 12A to the data format based on the information block.

Step 2: Common Value List for Item Value Next, common value lists for Item Story, Item Family, and Item Name are made common. Therefore, the value list of the item story and the value list of the item family are first made common, and then the value list made common first and the value list of the item name are made common. The sharing of the value list is a process necessary for creating the information block of the item value of the final information block type tree structure data. FIG. 23 is an explanatory diagram of a value list sharing process. When the value list of the item story and the value list of the item family are made common, elements from the respective value lists are stored in the common value list in alphabetical order without duplication. Then, the value number of the element of the value number array of each item is rewritten so as to specify the corresponding value in the common value list. If a value list of a plurality of items is shared, a plurality of items can be handled as one information block.

Step 3: Separation of Item Title Value Number and Value List Next, in order to describe the item Title of the tree structure data, the Title list is separated into a value number array VNo and a value list VL. FIG. 24 is an explanatory diagram of processing for separating a value array into a value number and a value list.

Step 4: Creation of record number correspondence table Next, a record number correspondence table is created between Table_0 and Table_1, and between Table_1 and Table_2. This process is the same as the process described with reference to FIG. This process is realized by using the join process described in Patent Document 5 as described above. FIGS. 25A and 25B are explanatory diagrams of processing for creating a record number correspondence table using a join according to an embodiment of the present invention. FIG. 25A shows join processing between Table_0 and Table_1, and FIG. 25B shows join processing between Table_1 and Table_2. 25A and 25B, the master side represents a table in which the order of the ordered set of the original table is stored. In this example, the upper layer table corresponds to the master side, and conversely, the slave side. Represents the table in which the order of the ordered set of the original table is sorted by the join key. In this example, the lower layer table corresponds to the slave side.

  With reference to FIG. 25B, a record number correspondence table creation process using join will be described in detail. When joining Table_1 and Table_2, the key items are DGrip of Table_1 on the master side and UGrip of Table_2 on the slave side. For example, when there are n elements having key item values that match the key item value of the record m in the master side table in the slave side data, the join table generated by the join includes the record m in the master side table. Appears repeatedly n times. In this example, there are four records, that is, a record 4, a record 5, a record 6, and a record 7, corresponding to the record 0 on the slave side corresponding to the record 0 on the table 1 on the master side. Similarly, the record 1 on the slave side corresponds to the record 1, the record 2 and the record 3 on the slave side, and the record 2 on the slave side corresponds to the record 2 on the master side. The master-side cumulative number array, the master-side ordered set array, the master-side join key array, the slave-side cumulative number array, and the slave-side ordered set array shown in FIG. The correspondence of the side record is described.

  The master side cumulative number array is an array obtained by accumulating the number of corresponding records on the slave side. From the master side cumulative number array [1] = 4, the master side ordered set array [0] = 0. It can be seen that the number of slave side records corresponding to the master side record 0 specified by is four. Similarly, from the master side cumulative number array [2] = 7, the number of slave side records corresponding to the master side record 1 specified by the master side ordered set array [1] = 1 is 7-4 = 3. I understand that. Furthermore, from the master side cumulative number array [3] = 8, the number of slave side records corresponding to the master side record 2 specified by the master side ordered set array [2] = 2 is 8-7 = 1. I understand. Therefore, it can be seen that the combination of the master side cumulative number array and the master side ordered set array expresses a virtual ordered set array as shown in FIG. 26A in a compact manner. In other words, the master side cumulative number array [i] represents the start position where the element specified by the corresponding master side ordered set array [i] appears in the virtual ordered set array.

  The slave side ordered set is sorted by the join key, in this example, the value of UGrip. As shown in FIG. 26B, the slave side cumulative number array [i] also indicates the start position at which the element corresponding to the shared join key VL [i] appears in the slave side ordered set array. Yes.

  As an example of a process for acquiring data as shown in FIG. 25B, the join process described in Patent Document 5 will be briefly described.

  First, an item (join key) to be shared is found among a plurality of tabular data. Next, in a plurality of tabular data, the value lists are compared to make both value lists equivalent. When the value lists are made equivalent, the pointer array is converted along with the addition of the item value to generate a new pointer array. Furthermore, a slave side existence number array that stores the existence number indicating the number of records related to the slave table format data corresponding to the item value is generated, and the item value is referred to by referring to the existence number in the slave side existence number array. A slave side cumulative number array storing the cumulative number of corresponding existence numbers is generated. On the other hand, the pointer value in the pointer array indicated by the record number on the master side is taken out, the element in the slave side existence number array corresponding to the item value indicated by the pointer value is specified, and the master side is associated with the record number on the master side. A record corresponding to the record number on the master side, stored in the record number indicating array indicating the number of records of the slave tabular data corresponding to each record of the tabular data, and referring to the number of records in the record number indicating array Generate a master-side cumulative number array that stores the cumulative number of numbers. Furthermore, with respect to the master side cumulative number array, a new record number for determining the total number of the total number of records and identifying a new record related to the combined tabular data that can accommodate the number of elements of the total number By comparing a new record number in the array and an element in the master side cumulative number array, a master side ordered set array that accommodates the record numbers in the master tabular data in consideration of duplication is obtained. Next, the element in the pointer array related to the slave table format data specified by the record number in the master table format data which is an element in the master side ordered set array is specified, and the element in the pointer array related to the slave table format data is Identify the element in the slave side cumulative number array to point to, temporarily hold this as the start address on the slave side, record number in the new record number array, and master cumulative number array specified by the record number A slave side ordered set array containing record numbers in the slave table format data considering duplication is obtained from the elements inside and the start address on the slave side.

Returning to FIG. 25B again, the processing for acquiring the corresponding slave side record from the master side record will be described. From the master side ordered set array [0] = 0 and the corresponding master side join key VNo “0” = 0, the record number of the slave side record corresponding to the master side record 0 is the slave in the slave side ordered set array. It can be seen that the elements from the side cumulative number array [0] = 0th to the slave side cumulative number array [0 + 1] = 4-1 = third, that is, record numbers = 4, 5, 6, and 7. As a result, 0 → 4, 5, 6, 7 in the first row of the record number correspondence table.
Can be obtained. Similarly, the slave side record corresponding to the master side record 1 is the slave side cumulative number array [1 + 1] = 7-1 = 6th from the slave side cumulative number array [1] = 4th in the slave side ordered set array. It can be seen that the above elements, that is, record numbers = 1, 2, and 3. As a result, 1 → 1, 2, 3 in the second row of the record number correspondence table
Can be obtained. Further, similarly, the slave side record corresponding to the master side record 2 is the slave side cumulative number array [2 + 1] = 8-1 from the slave side cumulative number array [2] = 7th in the slave side ordered set array. It can be seen that up to the seventh element, that is, record number = 0. As a result, 2 → 0 in the third row of the record number correspondence table
Can be obtained.

  The record number correspondence table between Table_0 and Table_1 can be obtained in the same manner using the join process.

Step 5: Generation of tree structure data When the record number correspondence table acquired in step 4 is generated, values are stored in order from the record 0 in the Topology array, Title_VNo array, and Value_VNo array of the tree structure data. , Tree structure data with separated values is generated. At this time, as shown in FIG. 23, a value number and a value list related to the item Value in which the item Story, the item Family and the item Name are made common, and a value number related to the item Title as shown in FIG. And a list of values is used.

Step 5-1: Generation of record 0 Step 5-1: Initialization Array Topology, Array Title, Array Value, and stack array ParentNodeNo storing the record identification number of the parent node are secured in the memory, and the stack -1 is set to the top of the array, that is, ParentNodeNo [0]. Further, the value −1 stored in the stack array ParentNodeNo is copied to Topology [0]. This process is similar to the process described with reference to FIG. 14A.

Step 5-1-2: Value Storage This process is similar to the record 0 generation process corresponding to the root node (node 0) described with reference to FIG. 14B. Since the current position in the record number correspondence table is the record 0 of Table_0, the value number = 2 of the item name “story” of the record 0 of Table_0 and the value number 4 of the item value are obtained, and Title [0] and Each stored in Value [0]. Thus, in this embodiment, the values stored in the array Title and the array Value are not the item name and the item value, but the item name value number and the item value value number.

Step 5-1-3: Move to Child Node This process is similar to the move process to the child node described with reference to FIG. 14C. The current position is moved to the child node according to the record number correspondence table. At this time, the storage address (subscript) of the parent node, that is, the record sequence number = 0 is pushed to the stack array ParentNodeNo. In addition, since the pointers to the array Topology, array Title, and array Value indicated by the horizontal arrows in the same figure indicate the record positions where the values have been stored, the pointer is incremented (go forward one step). ).

Step 5-2: Generation of Record 1 This process is similar to the process of generating record 1 corresponding to node 1 described with reference to FIGS. 15A-C. First, the value stored in the stack array ParentNodeNo is copied to the array Topology [1]. Next, since the current position in the record number correspondence table is the record 1 of Table_1, the item name Family value number = 0 and the item value Potter value number = 10 of the record_1 of Table_1 are acquired, and Title [ 1] and Value [1], respectively. Finally, the current position is moved to the child node according to the record number correspondence table. At this time, the storage address (subscript) of the parent node, that is, the record sequence number = 1 is pushed to the stack array ParentNodeNo. Further, since the pointers to the array Topology, array Title, and array Value indicated by the horizontal arrows in FIG. 15C indicate the record positions where the values have been stored, the pointers are incremented (go forward one step). ).

  Thereafter, by executing processing similar to the processing described with reference to FIGS. 16A to 16A to 20C, tree structure data in which the value list is separated is generated as shown in FIG. 21B. The The process of converting the tree structure data from which the value list is separated into the information block type tree structure data as shown in FIG. 21C is as described above.

  Finally, Mr. of record 1 of the other Table_0 is recorded. The tree structure data of the depth-first method related to Incredible is also generated by the same processing. The process of the record 1 of Table_0 may be sequentially executed by one processor after the process related to the record 0 of Table_0. For example, the process related to the record 0 of Table_0 using a plurality of processors, Processing regarding the record 1 of Table_0 may be executed in parallel.

  FIG. 27 shows the result of applying the tree structure data generation processing according to the embodiment of the present invention to both the record 0 and the record 1 of Table_0. In this example, the record 0 of Table_0 corresponds to one root node, and the record 1 of Table_1 corresponds to the other root node. On the other hand, it is also possible to generate tree structure data in which a node corresponding to the record 0 of Table_0 and a node corresponding to the record 1 of Table_1 are sibling nodes. FIG. 28 shows a result of applying the tree structure data generation processing according to another embodiment of the present invention in which the record 0 and the record 1 of Table_0 are handled as sibling nodes.

[Integrated tree structure data of breadth-first method]
Next, an embodiment of the present invention for converting tree structure data described in a plurality of tables, that is, original data into integrated tree structure data in a breadth-first manner will be described. Again, the original data is tree structure data described in a plurality of tables as shown in FIG. 12A. The processing steps described below are also executed by the computer system 10, particularly the CPU 12 in the computer system 10. Further, data, tables, and arrays generated in the processing steps are each stored in a memory (for example, RAM 14).

Step 1: Creation of Record Number Correspondence Table The record number correspondence table creation processing in the depth priority method described with reference to FIGS. 13A and 13B is also applied to the width priority method in exactly the same manner.

Step 2: Generation of tree structure data from record number correspondence table Next, tree structure data is generated from the acquired record number correspondence table. Specifically, because of the breadth-first method, the storage position in the virtual record array is determined in order from the highest layer, and the value of the Topology field, the value of the Title field, And the value of the Value field is stored.

Step 3: Generation of Record 0 The highest node is Record 0 of Table_0. Since the parent node does not exist in the highest node, −1 is stored in Topology [0] (Transfer 1). The item name and the item value of the record 0 of Table_0 are acquired and stored in Title [0] and Value [0], respectively (Transfer 2). The confirmed record sequence number (that is, the node number, 0 in this example) is added to the record number correspondence table (Transfer 3). Since there is no younger brother node in node 0, the next node is the first node existing in the next hierarchy (depth). FIG. 29 is an explanatory diagram of such a breadth-first tree structure data generation process according to an embodiment of the present invention.

Step 4: Generation of Record 1 Next, a generation process of the record 1 of the tree structure data will be described with reference to FIG. The current node is record 1 of Table_1. Since the record order number of the parent node is 0, 0 is stored in Topology [1] (Transfer 1). The item name and item value of the record 1 of Table_1 are acquired and stored in Title [1] and Value [1], respectively (Transfer 2). The confirmed node number (1 in this example) is added to the record number correspondence table (transfer 3). Since node 1 has a younger brother node, the next node is a younger brother node.

Step 5: Generation of Record 2 Next, the generation process of the record 2 of the tree structure data will be described with reference to FIG. The current node is the record 2 of Table_1. Since the record order number of the parent node is 0, 0 is stored in Topology [2] (Transfer 1). The item name and item value of the record 2 of Table_1 are acquired and stored in Title [2] and Value [2], respectively (Transfer 2). The confirmed node number (2 in this example) is added to the record number correspondence table (transfer 3). Since there is no younger brother node in node 2 and there is no undetermined node in the same generation, the next node is the first node existing in the next hierarchy (depth).

Step 6: Generation of Record 3 Next, the generation process of the record 3 of the tree structure data will be described with reference to FIG. The current node is record 1 of Table_2. Since the record order number of the parent node is 1, 1 is stored in Topology [3] (Transfer 1). The item name and item value of the record 1 of Table_2 are acquired and stored in Title [3] and Value [3], respectively (Transfer 2). The confirmed node number (3 in this example) is added to the record number correspondence table (transfer 3). Since the younger brother node exists in the node 3, the next node is the younger brother node.

Step 7: Generation of Record 4 Next, generation processing of the record 4 of the tree structure data will be described. The current node is record 2 of Table_2. Since the record order number of the parent node is 1, 1 is stored in Topology [4] (Transfer 1). The item name and item value of the record 2 of Table_2 are acquired and stored in Title [4] and Value [4], respectively (Transfer 2). The confirmed node number (4 in this example) is added to the record number correspondence table (transfer 3). Since node 4 has a brother node, the next node is a brother node.

Step 8: Generation of Record 5 Next, the generation process of the record 5 of the tree structure data will be described with reference to FIG. The current node is record 3 of Table_2. Since the record order number of the parent node is 1, 1 is stored in Topology [5] (Transfer 1). The item name and item value of the record 3 of Table_2 are acquired and stored in Title [5] and Value [5], respectively (Transfer 2). The confirmed node number (5 in this example) is added to the record number correspondence table (transfer 3). Although there is no younger brother node in node 5, there is an indeterminate node of the same generation, so the next node is the next data of the same generation.

Step 9: Generation of Record 6 Next, the generation process of the record 6 of the tree structure data will be described with reference to FIG. The current node is record 0 of Table_2. Since the record order number of the parent node is 2, 2 is stored in Topology [6] (Transfer 1). The item name and item value of record 0 of Table_2 are acquired and stored in Title [6] and Value [6], respectively (Transfer 2). The confirmed node number (6 in this example) is added to the record number correspondence table (transfer 3). Since the node 6 has neither a younger brother node nor a next generation node, the generation process of the tree structure data is completed.

  In the case of tree structure data generation processing using the breadth-first method, as well as the depth-first method, tree structure data generation processing with separated value lists and tree structure data generation processing using ordered sets and value lists are performed. It is possible to realize. FIG. 35 is an explanatory diagram of information block type tree structure data generated using the tree structure data generation process of the breadth-first method according to an embodiment of the present invention.

  Finally, Mr. of record 1 of the other Table_0 is recorded. The breadth-first tree structure data related to Incredibles is also generated by the same process. The process of the record 1 of Table_0 may be sequentially executed by one processor after the process related to the record 0 of Table_0. For example, the process related to the record 0 of Table_0 using a plurality of processors, Processing regarding the record 1 of Table_0 may be executed in parallel.

  FIG. 36 shows the result of applying the tree structure data generation processing according to the embodiment of the present invention to both the record 0 and the record 1 of Table_0. In this example, the record 0 of Table_0 corresponds to one root node, and the record 1 of Table_1 corresponds to the other root node. On the other hand, it is also possible to generate tree structure data in which a node corresponding to the record 0 of Table_0 and a node corresponding to the record 1 of Table_1 are sibling nodes. FIG. 37 shows a result of applying tree structure data generation processing according to another embodiment of the present invention in which the records 0 and 1 of Table_0 are handled as sibling nodes.

  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.

Claims (20)

A tree structure data composed of a plurality of nodes, each node being represented by an attribute name and attribute value, is constructed on the storage device as a virtual record array identified by a record sequence number in which each record represents the order of the records. A device,
Means for matching a plurality of tables having a hierarchical structure with a matching key for each hierarchy, and creating a row number correspondence table between row numbers having a parent-child relationship between the parent side table and the child side table;
Means for searching a row number in the parent table and a row number in the child table having a parent-child relationship from the row number correspondence table;
A record sequence number assigned to a row in the child table is determined in the order found by the searching means, and a parent-child relationship is determined at the position identified by the record sequence number in the virtual record array. Store the record order number of the parent node of the node corresponding to the row in the child table as a field value, store the item name belonging to the row in the child table as the attribute name field value of the node, Means for storing an item value belonging to a row in the child table as an attribute value field value of the node;
A device comprising:   An attribute name number array in which attribute name numbers that uniquely identify the attribute names are stored in the order of the record order numbers from an array in which the attribute name field values of the nodes are stored in the order of the record order numbers; An attribute name array storing the attribute name uniquely specified by the attribute name number in the order of the elements of the attribute name number array, and an attribute value number for uniquely specifying the attribute value in the order of the record sequence number An attribute value number array, and means for creating an attribute value array in which the attribute value uniquely specified by the attribute value number is stored in the order of the elements of the attribute value number array. Item 2. The apparatus according to Item 1. The plurality of tables is a structure-type parts table that represents a parent-child relationship of parts,
The means for creating the row number correspondence table selects a part corresponding to the root node of the tree structure data as a table of the highest hierarchy, and uses the same structure type parts table as data of other hierarchy,
The apparatus according to claim 1 or 2.   The means for creating the row number correspondence table is assigned to the parent side data corresponding to the sequence number assigned in the order of appearance of the data in the parent side table and the data in the child side table as the matching key. The apparatus according to claim 1 or 2, wherein a pair with a specific sequence number is used. A device comprising a memory for storing a plurality of tables having a hierarchical structure, wherein the plurality of tables are converted into tree structure data composed of a plurality of nodes each represented by an attribute name and attribute value, and stored in the memory. And
A matching unit for matching the plurality of tables with a matching key for each hierarchy;
A correspondence table creation unit that creates a row number correspondence table between row numbers having a parent-child relationship between a parent table and a child table matched for each of the plurality of table hierarchies;
A search unit for searching for a row number in the parent-side table having a parent-child relationship and a row number in the child-side table from the row-number correspondence table;
A record sequence number assigned to a row in the child table is determined in the order found by the search unit, and a parent-child relationship field is located at a position identified by the record sequence number in the virtual record array. Storing the record order number of the parent node of the node corresponding to the row in the child side table as a value, storing the item name belonging to the row in the child side table as the attribute name field value of the node, A record generation unit for storing an item value belonging to the original data belonging to a row in the child table as an attribute value field value of a node;
With
An apparatus in which the tree structure data is constructed in the memory as a virtual record array in which each record is identified by the record order number representing the order of records.   An attribute name number array in which attribute name numbers that uniquely identify the attribute names are stored in the order of the record order numbers from an array in which the attribute name field values of the nodes are stored in the order of the record order numbers; An attribute name array storing the attribute name uniquely specified by the attribute name number in the order of the elements of the attribute name number array, and an attribute value number for uniquely specifying the attribute value in the order of the record sequence number And a value separation unit for creating an attribute value array in which the attribute value uniquely specified by the attribute value number is stored in the order of the attribute value number array and the element of the attribute value number array. The apparatus according to claim 5. The plurality of tables is a structure-type parts table that represents a parent-child relationship of parts,
The correspondence table creation unit selects a part corresponding to the root node of the tree structure data as intermediate data of the table structure of the highest hierarchy, and uses the same structure type parts table as intermediate data of other table structures To
Apparatus according to claim 5 or 6.   The correspondence table creation unit, as the matching key, a sequence number assigned in the order of appearance of data in the parent table, a sequence number assigned to the parent data corresponding to the data in the child table, 7. An apparatus according to claim 5 or 6, wherein a pair of A tree structure data composed of a plurality of nodes, each node being represented by an attribute name and attribute value, is constructed on the storage device as a virtual record array identified by a record sequence number in which each record represents the order of the records. A method,
A step of matching a plurality of tables having a hierarchical structure with a matching key for each hierarchy, and creating a row number correspondence table between row numbers having a parent-child relationship between the parent side table and the child side table;
A row number in the parent table having a parent-child relationship and a row number in the child table are searched from the row number correspondence table, and assigned to the rows in the child table in the order found by the search. Record of the parent node of the node corresponding to the row in the child side table as a parent-child relationship field value at the position identified by the record sequence number in the virtual record array An order number is stored, an item name belonging to a row in the child side table is stored as an attribute name field value of the node, and an item value belonging to a row in the child side table is stored as an attribute value field value of the node A step of storing
A method comprising:   An attribute name number array in which attribute name numbers that uniquely identify the attribute names are stored in the order of the record order numbers from an array in which the attribute name field values of the nodes are stored in the order of the record order numbers; An attribute name array storing the attribute name uniquely specified by the attribute name number in the order of the elements of the attribute name number array, and an attribute value number for uniquely specifying the attribute value in the order of the record sequence number And further comprising the step of creating an attribute value array in which the attribute value number and the attribute value uniquely specified by the attribute value number are stored in the order of the elements of the attribute value number array. Item 10. The method according to Item 9. The plurality of tables is a structure-type parts table that represents a parent-child relationship of parts,
In the step of creating the row number correspondence table, the part corresponding to the root node of the tree structure data is selected as the highest hierarchy table, and the same structure type parts table is used as the other hierarchy table.
The method according to claim 9 or 10.   In the step of creating the row number correspondence table, the matching key is assigned to the order number assigned in the order of appearance of data in the parent side table and the parent side data corresponding to the data in the child side table. The method according to claim 9 or 10, wherein a pair with a specific sequence number is used. A computer comprising a memory for storing a plurality of tables having a hierarchical structure, wherein the plurality of tables are converted into tree structure data composed of a plurality of nodes each represented by an attribute name and an attribute value, and stored in the memory.
A function of matching the plurality of tables for each hierarchy by a matching key;
A function for creating a row number correspondence table between row numbers having a parent-child relationship between the matched parent-side table and child-side table for each of the plurality of table hierarchies;
A function of searching for a row number in the parent table and a row number in the child table having a parent-child relationship from the row number correspondence table;
A function for determining the record sequence numbers assigned to the rows in the child table in the order found in the search;
The tree structure data is constructed in the memory as an array of virtual records, wherein each record is identified by the record sequence number representing the order of the records. At the position identified by the record sequence number, the record sequence number of the parent node of the node corresponding to the row in the child side table is stored as the parent-child relationship field value, and the child side attribute value is stored as the attribute name field value of the node. A function for storing item names belonging to the rows in the table, and storing item values belonging to the rows in the child table as attribute value field values of the nodes;
A program to realize   An attribute name number array in which attribute name numbers that uniquely identify the attribute names are stored in the order of the record order numbers from an array in which the attribute name field values of the nodes are stored in the order of the record order numbers; An attribute name array storing the attribute name uniquely specified by the attribute name number in the order of the elements of the attribute name number array, and an attribute value number for uniquely specifying the attribute value in the order of the record sequence number The computer further realizes a function of creating an attribute value number array and an attribute value array storing the attribute value uniquely specified by the attribute value number in the order of the elements of the attribute value number array The program according to claim 13 for causing the program to occur. The plurality of tables is a structure-type parts table that represents a parent-child relationship of parts,
Claims for further realizing the function of selecting a part corresponding to a root node of the tree structure data as a top hierarchy table and using the same structure type BOM as a table of other hierarchy The program according to 13 or 14.   A function of using a pair of a sequence number assigned in the order of appearance of data in the parent table and a sequence number assigned to parent data corresponding to the data in the child table as the matching key. The program according to claim 13 or 14 for further realizing the computer.   The computer-readable recording medium which recorded the program of any one of Claim 13 thru | or 16. A computer comprising a memory for storing a plurality of tables having a hierarchical structure, wherein the plurality of tables are converted into tree structure data composed of a plurality of nodes each represented by an attribute name and an attribute value, and stored in the memory.
A function of matching the plurality of tables for each hierarchy by a matching key;
A function for creating a row number correspondence table between row numbers having a parent-child relationship between the matched parent-side table and child-side table for each of the plurality of table hierarchies;
A function of searching for a row number in the parent table and a row number in the child table having a parent-child relationship from the row number correspondence table;
A function for determining a record sequence number assigned to a row in the child table in the order found in the search;
The tree structure data is constructed in the memory as an array of virtual records, wherein each record is identified by the record sequence number representing the order of the records. At the position identified by the record sequence number, the record sequence number of the parent node of the node corresponding to the row in the child side table is stored as the parent-child relationship field value, and the child side attribute value is stored as the attribute name field value of the node. A function for storing item names belonging to the rows in the table, and storing item values belonging to the rows in the child table as attribute value field values of the nodes;
Program product to realize. A computer-readable recording medium that records tree structure data composed of a plurality of nodes each node is represented by an attribute name and an attribute value,
The tree structure data is represented by a virtual array of records, each record being identified by a record sequence number representing the order of the records,
The record includes a parent-child relationship field that stores a record sequence number of a parent node of a node corresponding to the record, an attribute name field that stores an attribute name number that specifies an attribute name that belongs to the node, and an attribute value that belongs to the node An attribute value field for storing an attribute value number for specifying
A parent node of the node is identified by the record sequence number stored in the parent-child relationship field included in the record corresponding to the node;
The attribute name belonging to the node is specified by the attribute name number included in the record corresponding to the node and the attribute name array in which the attribute name is stored in the order of the attribute name number,
An attribute value belonging to the node is specified by the attribute value number included in the record corresponding to the node and an attribute value array in which the attribute values are stored in the order of the attribute name numbers;
Computer-readable recording medium.   The computer-readable recording medium according to claim 19, wherein the record order number is assigned to the record corresponding to each node of the plurality of nodes in the order of depth-first search or width-first search.

Images