JP2009223644A - Mapping unit, mapping method and program - Google Patents

Abstract

<P>PROBLEM TO BE SOLVED: To provide a mapping unit which is available even when an RDB structure has a fixed restriction, and takes advantage of an object model, and to provide a mapping method and a program. <P>SOLUTION: The mapping unit includes an element storage 1, an RDB storage 2, and a mapping section 34. The element storage 1 stores a plurality of first elements of the object model. The RDB storage 2 stores a plurality of second elements of the relational database. When the relational database structure has a fixed restriction, the mapping section 34 identifies a condition when the corresponding relationship holds between a fourth element among the plurality of second elements to a third element selected from among the plurality of first elements, and generates mapping including the conditional correspondence relationship. <P>COPYRIGHT: (C)2010,JPO&INPIT

Description

  The present invention relates to a mapping device, a mapping method, and a program, and more particularly to a mapping device, a mapping method, and a program between an object model and a relational database.

  Even when application software is developed using object-oriented technology, RDBMS (relational database management system) is often used instead of ODBMS (object database management system) for the data layer of an object-oriented database. In this case, in order to store the object model in the relational database (RDB), mapping (hereinafter referred to as “OR mapping”) between each element of the object model and each element of the RDB is necessary. However, each element of the object model is exemplified by class (including attributes), association (association between classes), and generalization (relationship between a class and a class of its upper concept). Each element of RDB is exemplified by an item (attribute) in each table.

  There are two methods for mapping between the object model and the RDB. The first mapping method is a method in which an object model is mainly used and an RDB is determined from the object model. The second mapping method is a method in which RDB is mainly used and an object model is determined in accordance with the table structure of RDB.

  As a first mapping method, for example, Japanese Patent Laid-Open No. 2000-148555 discloses a mapping method between an object model and a relational model. In this mapping method, one class of the object model is mapped to one table of RDB. One association of the object model is mapped to one table in the RDB or embedded in a table corresponding to the class. Further, the class of the object model and the related instance are mapped to the record of the RDB table. In this mapping method, one class is mapped to a plurality of tables.

  Japanese Unexamined Patent Application Publication No. 2007-249345 discloses a mapping device, a mapping method, and a program. This mapping method corresponds to one or more object model elements (classes (including attributes), associations, generalizations, instances, links, etc.) depending on the required processing time and how the objects are used. Create one batch (RDB wrapper) that is encapsulated. The RDB wrapper is associated with any number of RDB elements (tables, columns, rows, etc.) that can hold the data of the element of the object model.

  Japanese Patent Laid-Open No. 2000-155706 discloses a mapping method and apparatus for object-oriented and relational databases, and a recording medium therefor. In this mapping method, in relational database access method in which registration, reference, update and deletion of data are performed according to a known procedure, it is included in the relational database regarding the table to be accessed registered in the relational database. The management information is read out, and the correspondence between the access table and the class mapped to the access table is grasped based on the management information.

  Moreover, as a mapping method corresponding to both the first and second methods, JP-A-2001-518670 discloses an objective model mapping and runtime engine for using a relational database having object-oriented software. This is a way to interface object oriented software applications with relational databases. Selecting an object model; generating a map of at least some relationships between the schema in the database and the selected object model; and at least one corresponding to an object associated with the object-oriented software application. Using a map to generate one interface object, and using the at least one interface object with an object-oriented application to access data from a relational database.

JP 2000-148555 A JP 2007-249345 A JP 2000-155706 A JP-T-2001-518670

  The first mapping method has a problem that it cannot be used when the structure of the RDB is a determined constraint. When the RDB structure is determined, if the RDB structure of the existing system cannot be changed due to addition or modification to the existing system, the existing system itself is discarded, but the RDB structure is used continuously for operational reasons. In such a case, there may be a case where the RDB structure required by the external system must be observed for cooperation with the external system. These situations frequently occur in the field of system development that is far from textbooks. Inability to deal with these cases means that the use opportunities of the object model are practically limited, or the creation of the object model is merely a cost increase. Therefore, a mapping method that can be used even when the structure of the RDB is a determined constraint is required.

  The second mapping method is synonymous with reverse determination of the object model from the RDB, and there is a problem that the advantages such as the ease of change, the ease of understanding, and the reduction in scale, which the object model has as advantages, cannot be enjoyed at all. . Such mapping may be used when the existing RDB structure cannot be changed but object-oriented development is a contract condition, or only developers who do not have object-oriented development technology can be assigned. Conceivable. However, in current system development, there is a demand for a system that is easy to change, easy to understand, and small in scale, taking advantage of object-oriented development. Therefore, a mapping method that can take advantage of the object model even when the structure of the RDB is a determined constraint is desired.

  An object of the present invention is to provide a mapping apparatus, a mapping method, and a program that can be used even when the structure of the RDB is a determined constraint and can take advantage of the object model.

  The mapping apparatus of the present invention includes an element storage unit, an RDB storage unit, and a mapping unit. The element storage unit stores a plurality of first elements of the object model. The RDB storage unit stores a plurality of second elements of the relational database. When the relational database structure is a determined constraint, the mapping unit has a correspondence relationship with the fourth element of the plurality of second elements for the third element selected from the plurality of first elements. Is identified, and a mapping including a conditional correspondence is generated.

  The mapping method of the present invention includes steps (1) to (3). (1) The step is a step of referring to a plurality of first elements of the object model and a plurality of second elements of the relational database. (2) In the step, when the structure of the relational database is a determined constraint, the third element selected from the plurality of first elements is between the fourth element of the plurality of second elements. This is a step of identifying conditions when a correspondence relationship is established. (3) The step is a step of generating a mapping including a conditional correspondence.

  The program of the present invention causes a computer to execute a mapping method comprising steps (1) to (3). In step (1), the mapping unit refers to an element storage unit that stores a plurality of first elements of an object model and an RDB storage unit that stores a plurality of second elements of a relational database. (2) In the step, when the mapping unit is a constraint whose structure of the relational database has been determined, the fourth element of the plurality of second elements is selected with respect to the third element selected from the plurality of first elements. Is a step of identifying a condition when a correspondence relationship is established between (3) In the step, the mapping unit generates a mapping including a conditional correspondence.

  According to the present invention, it is possible to provide a mapping device, a mapping method, and a program that can be used even when the structure of the RDB is a determined constraint and can take advantage of the object model.

  Hereinafter, embodiments of a mapping device, a mapping method, and a program according to the present invention will be described with reference to the accompanying drawings.

First, a mapping device according to an embodiment of the present invention will be described.
FIG. 1 is a block diagram showing the configuration of the mapping apparatus according to the present embodiment. FIG. 1 shows a case where the mapping devices 100-1, 100-2,... Are connected to each other via a network capable of bidirectional communication. In the following description, when mapping devices are not distinguished, they are referred to as mapping devices 100. The mapping apparatus 100 includes an element storage unit 1, a relational database (RDB) storage unit 2, and a processing unit 3. The mapping device 100 is exemplified by an information processing device such as a computer, the processing unit 3 is exemplified by the computer main body, and the element storage unit 1 and the RDB storage unit 2 are exemplified by the storage device. The mapping apparatus 100 according to the present embodiment has the following configuration (and operation) including the configuration (and operation) of the mapping apparatus disclosed in Japanese Patent Application Laid-Open No. 2007-249345.

  The element storage unit 1 stores the elements of the object model (hereinafter also referred to as “elements”). In the example of FIG. 1, the element storage unit 1 stores the elements 10 a to 10 c of the object model. However, an element is exemplified by a class (including attributes), a qualifier, a relationship between classes (hereinafter referred to as “relation”), or generalization (a relationship between a class and a class of its higher concept). If association and generalization are also a kind of class, an element is a class. The object model also includes an instance of each element.

  The RDB storage unit 2 stores the RDB. The RDB includes elements of the RDB such as a table including an item and a record corresponding to the item, a row (value) of the table, and a column (value) of the table. In the example of FIG. 1, the RDB storage unit 2 stores RDB elements 20a to 20c. The item can store elements (of the object model). The record corresponding to the item can store the data (instance) of the element stored in the item.

  The processing unit 3 maps each element stored in the element storage unit 1 to an item in a table stored in the RDB storage unit 2. The processing unit 3 includes a memory 31, a reception unit 32, a selection unit 33, a mapping unit 34, and a row addition / deletion processing unit 35. For example, when the processing unit 3 is a computer main body having a memory, a CPU, and an input / output unit, the processing unit 3 executes software (programs), thereby causing a memory 31, a reception unit 32, a selection unit 33, a mapping unit, and the like. The unit 34 and the line addition / deletion processing unit 35 are realized.

  The memory 31 is used as a working memory of the processing unit 3 and is exemplified by a RAM (Random Access Memory).

  The receiving unit 32 receives elements of a given object model. Elements of a given object model are stored in the element storage unit 1. The receiving unit 32 receives a given RDB element. A given RDB element is stored in the RDB storage unit 2.

  The mapping unit 34 performs mapping between the object model and the existing RDB structure when the RDB structure is a determined constraint (example: RDB table is given in advance and cannot be changed). At that time, when the structure of the RDB is a determined constraint, a problem (described later) occurring in mapping is solved by a solving means (described later).

  In other words, the mapping unit 34 sets each of the object model elements whose correspondences are stored in the memory 31 (instead of generating RDB elements) of the solving means 1 to 13, the solving means 15, and the solving means 16. As described above, association with a given RDB element is performed, and the correspondence relationship is stored in the memory 31. Further, the mapping unit 34 creates an RDB element corresponding to the class identifier as in the solving means 14 for each element of the object model whose correspondence is stored in the memory 31 (instead of generating an RDB element). The created RDB element is stored in the RDB storage unit 2, and the correspondence relationship related to the generalization of the class is stored in the memory 31.

  Here, the problem of mapping between an object model and an existing RDB structure when the RDB structure is a determined constraint will be described. For mapping between the object model and the existing RDB structure when the structure of the RDB is a determined constraint, the elements of the object model (example: class (including attributes)) listed below (A) to (D) , Relationship, generalization, instance, link) and existing RDB elements (example: table, row, column, relation) are not 1: 1.

(A) A plurality of RDB elements correspond to one object model element.
1. One class corresponds to a plurality of tables.
2. One attribute corresponds to multiple columns of table (s).
3. One association corresponds to multiple tables or multiple columns of table (s).
4. One qualifier corresponds to multiple columns of the table (s).
5. One instance or link corresponds to multiple rows.

(A) Elements of a plurality of object models correspond to one RDB element.
1. Multiple classes correspond to one table.
2. A plurality of classes having a generalization relationship correspond to one table.
3. A plurality of attributes correspond to one table column.
4). A plurality of associations correspond to one table or one table column.
5. A plurality of qualifiers correspond to one table column.
6). Multiple instances or links correspond to one row.

(C) Elements of a plurality of object models correspond to elements of a plurality of RDBs.
1. Multiple classes correspond to multiple tables.
2. Multiple attributes correspond to multiple columns of the table (s).
3. Multiple associations correspond to multiple tables or multiple columns of (multiple) tables.
4). Multiple qualifiers correspond to multiple columns of the table (s).
5. Multiple instances or links correspond to multiple rows.

(D) There is no RDB element corresponding to the object model element.
1. There is no RDB element corresponding to the class.
2. There is no RDB element corresponding to generalization (identification information of a class to which an instance for handling generalization belongs).
3. There is no RDB element corresponding to the attribute.
4). There is no RDB element corresponding to the association.
5. There is no RDB element corresponding to the qualifier.
6). There is no RDB element corresponding to the instance or link (the same case as the above (D) -1 and (D) -4).

In the present invention, in order to satisfy both changeability and execution performance at the same time, one or more object model elements (example: class (including attributes)), relationship, general purpose, and the like described in JP-A-2007-249345 are disclosed. , Instance, link) (1a, 1b, 1c...) Is based on a configuration for creating one unit (processing unit 3) in which encapsulation is performed. In order to solve the above mapping problem, the function of the processing unit 3 is expanded so that the processing unit 3 can execute the following solving means 1 to 16. Thereby, even when the structure of the RDB is a determined constraint (example: when the RDB table is given in advance and cannot be changed), the mapping between the object model and the existing RDB structure is realized.
(1) Solution 1: Solution to problem (a) -1 (during mapping)
The mapping unit 34 identifies the condition corresponding to the class and the table, and creates a conditional correspondence (example: the corresponding table differs depending on the value of the class attribute).
(runtime)
The mapping unit 34 performs RDB CRUD (Create Read Update Delete) processing according to the conditions prepared at the time of mapping.
(2) Solution 2: Solution for problem (A) -2 and problem (A) -4 (during mapping)
The mapping unit 34 identifies the conditions corresponding to the attributes or qualifiers and the columns of each table, and creates a conditional correspondence (example: the column of the table corresponding to each class type to which the instance belongs). .
When there is a correspondence relationship established by calculation between one attribute or qualifier (value) and a plurality of table columns (value), they are associated with each other and from the attribute or qualifier (value) A calculation formula for obtaining a table column (value) and a calculation formula for obtaining an attribute or qualifier (value) from the table column (value) are prepared.
(runtime)
The mapping unit 34 performs RDB CRUD processing according to the conditions and calculation formulas prepared at the time of mapping.
(3) Solution 3: Solution for Problem (A) -3 (at mapping)
The mapping unit 34 identifies the relation and the condition corresponding to each table or table column, and creates a conditional correspondence (example: the column of the table corresponding to each type of relation to which the link belongs).
If there is a correspondence established by calculation between one association (link) and multiple table columns (values), they are matched and the table columns (values) are converted from the association (link). A calculation formula to be obtained and a calculation formula to obtain a relationship (link) from the column (value) of the table are prepared.
(runtime)
The mapping unit 34 performs RDB CRUD processing according to the conditions and calculation formulas prepared at the time of mapping.
(4) Solution 4: Solution of Problem (A) -5 The mapping unit 34 solves the problem (A) -1, problem (A) -3, or a problem of a denormalized table structure.
(5) Solution 5: Solution for Problem (A) -1 and Problem (A) -2 (at mapping)
The mapping unit 34 identifies the condition corresponding to each class and the table, and creates a conditional correspondence (example: the corresponding class differs depending on the value of the table column). Thereby, a plurality of classes are associated with one table.
(runtime)
The mapping unit 34 performs RDB CRUD processing according to the conditions prepared at the time of mapping.
When a plurality of instances correspond to one row, it is solved by means for solving the problem (A) -6.
(6) Solution 6: Solution to Problem (A) -3 and Problem (A) -5 (at mapping)
The mapping unit 34 identifies the condition corresponding to each attribute or qualifier and the table column, and creates a conditional correspondence (example: the corresponding attribute varies depending on the value of the table column).
When there is a correspondence relationship established by calculation between a plurality of attributes or qualifiers (values) and one table column (values), they are associated with each other, and from the attributes or qualifiers (values) A calculation formula for obtaining a table column (value) and a calculation formula for obtaining an attribute or qualifier (value) from the table column (value) are prepared.
(runtime)
The mapping unit 34 performs RDB CRUD processing according to the conditions and calculation formulas prepared at the time of mapping.
(7) Solution 7: Solution to Problem (A) -4 (at mapping)
The mapping unit 34 identifies a condition corresponding to each relation and a table or a table column, and creates a conditional correspondence (example: the corresponding relation varies depending on the value of the table column).
When there is a correspondence relationship established by calculation between multiple associations (links) and table columns (values), a calculation that associates them and obtains the table columns (values) from the associations (links) Prepare a formula to calculate the relationship (link) from the formula and the table column (value).
(runtime)
The mapping unit 34 performs RDB CRUD processing according to the conditions and calculation formulas prepared at the time of mapping.
When a plurality of links correspond to one line, it is solved by means for solving the problem (A) -6.
(8) Solution 8: Solution to problem (b) -6 (during mapping)
The mapping unit 34 solves the problem (A) -1, the problem (A) -2, and the problem (A) -4.
(runtime)
The mapping unit 34 uses the row addition / deletion processing unit 35 to generate an instance by one of the following methods.
<Method 1>
Delay the execution timing of adding a row until all instances corresponding to the row are generated.
<Method 2>
・ Dummy data indicating that there is no instance is placed in the ungenerated instance part, and a row is temporarily added.
Each time an instance is created, the dummy data part is updated with the attribute value of the instance (if the primary key value is changed, the row is deleted and added).
The mapping unit 34 uses the row addition / deletion processing unit 35 to delete an instance by one of the following methods.
<Method 3>
Delay the execution timing of row deletion until all instances corresponding to the row are deleted.
<Method 4>
-Insert dummy data indicating that there is no instance in the instance part to be deleted.
• When all instances have been deleted, delete the line.
(9) Solution 9: Solution to problem (c) -1 (during mapping)
The mapping unit 34 identifies a condition corresponding to each class and each table, and creates a conditional correspondence (example: the correspondence differs depending on the value of the class attribute and the value of the table column).
Note that if non-key columns are duplicated in multiple tables, this is a problem of denormalized table structure (solved by a solution to the problem of denormalized table structure).
(runtime)
The mapping unit 34 performs RDB CRUD processing according to the conditions prepared at the time of mapping.
When a plurality of instances correspond to one row, it is solved by means for solving the problem (A) -6.
(10) Solution 10: Solution for problem (c) -2 and problem (c) -4 (during mapping)
The mapping unit 34 identifies the condition corresponding to the attribute or qualifier and the table column, and creates a conditional correspondence (example: for each class type to which the instance belongs and for each value in the table column. Different).
If there is a corresponding relationship established by calculation between multiple attributes or qualifiers (values) and multiple table columns (values), make them correspond and use the attributes or qualifiers (values) A calculation formula for obtaining a table column (value) and a calculation formula for obtaining an attribute or qualifier (value) from the table column (value) are prepared.
(runtime)
The mapping unit 34 performs RDB CRUD processing according to the conditions and calculation formulas prepared at the time of mapping.
(11) Solution 11: Solution for problem (c) -3 (during mapping)
The mapping unit 34 identifies a condition corresponding to each relation and each table or table column, and creates a conditional correspondence (example: corresponding to each kind of relation to which the link belongs and each column value of the table) The relationship is different).
If there is a corresponding relationship established by calculation between each relationship (link) and a plurality of table columns (values), they are matched and the table column (value) is converted from the relationship (link). A calculation formula to be obtained and a calculation formula to obtain a relationship (link) from the column (value) of the table are prepared.
(runtime)
The mapping unit 34 performs RDB CRUD processing according to the conditions and calculation formulas prepared at the time of mapping.
When a plurality of links correspond to one line, it is solved by means for solving the problem (A) -6.
(12) Solution 12: Solution for problem (c) -5 (during mapping)
The mapping unit 34 solves the problem (C) -1 and the problem (A) -3 with a solution.
(runtime)
The mapping unit 34 solves with the solving means for the solving means 8.
(13) Solution 13: Solution to Problem (D) -1, Solution to Problem (D) -6 (Solution 16 may be used)
(When mapping)
The mapping unit 34 creates (adds) a table corresponding to the class, similarly to the conventional OR mapping.
(runtime)
The mapping unit 34 handles the same as in the conventional OR mapping.
(14) Solution 14: Solution for problem (d) -2 (during mapping)
When the column is allowed to be added to a given table, the mapping unit 34 adds a class identifier column to the table corresponding to the class. If the primary key for identifying an object differs depending on the class, an object identifier column is also added.
If the addition of a column to a given table is not permitted, a table having a primary key of the table corresponding to the class as a foreign key and a column of a class identifier is added. If the primary key for identifying an object differs depending on the class, an object identifier column is also provided.
(runtime)
The mapping unit 34 adds / deletes a line including a class identifier when an instance is generated / deleted.
(15) Solution 15: Solution for Problem (D) -3 and Problem (D) -5 (at the time of mapping)
When the addition of a column to a given table is permitted, the mapping unit 34 adds a column corresponding to the attribute or qualifier to the table corresponding to the class.
If adding a column to a given table is not allowed, add a table with a primary key corresponding to the class as a foreign key and a column corresponding to an attribute or qualifier.
(runtime)
The mapping unit 34 adds / deletes a line including an attribute or a qualifier when an instance is generated / deleted.
(16) Solution 16: Solution for Problem (D) -4, Solution for Problem (D) -6 (Solution 13 is also acceptable)
(When mapping)
The mapping unit 34 creates (adds) a table corresponding to the association as in the conventional OR mapping. However, the column for identifying the object uses the primary key of the table corresponding to the class, except when the identifier of the object is added by the solving means 14.
(runtime)
The mapping unit 34 handles the same as in the conventional OR mapping.

Based on the instruction from the mapping unit 34, the row addition / deletion processing unit 35 performs processing by one of the following methods when an instance is generated when a plurality of instances are associated with one record.
<Method 1>
-Delay the execution timing of record addition until all instances are generated.
<Method 2>
・ Dummy data indicating that there is no instance is inserted in the ungenerated instance part, and a record is temporarily added.
-Each time an instance is generated, the dummy data part is updated with the attribute value of the instance (if the primary key value is changed, the record is deleted and added).

In addition, the row addition / deletion processing unit 35 performs processing by one of the following methods when deleting an instance when a plurality of instances are associated with one record based on an instruction from the mapping unit 34.
<Method 3>
・ Delay the execution timing of record deletion until all instances are deleted.
<Method 4>
-Insert dummy data indicating that there is no instance in the instance part to be deleted.
-When all instances have been deleted, delete the record.

  Further, the reception unit 32, the selection unit 33, and the mapping unit 34 can further perform operations described in Japanese Patent Application Laid-Open No. 2007-249345. That is, as shown below.

  The receiving unit 32 receives a selection condition (example: specific element name selected by the user) for selecting a plurality of elements to be encapsulated. A group of elements selected under this selection condition (hereinafter referred to as “RDB wrapper”) is an object of encapsulation, and is associated with an RDB table that can hold data (instances) of those elements. Furthermore, the reception unit 32 receives a specific condition (example: processing speed required for element processing) for specifying how to group a plurality of elements selected according to the selection condition.

  For example, if there is a part in the object model that requires high-speed processing and may be low in flexibility, the user may have a plurality of elements corresponding to the part (for example, a plurality of classes and associations and generalizations). A selection condition representing the name of the categorization) is input to the reception unit 32. On the other hand, when there is a part in the object model where high-speed processing is not required, the user selects a selection condition that represents the names of a plurality of elements (example: one class and some relations) corresponding to the part. Input to the reception unit 32. At this time, the selection conditions are set in consideration of how each class is used and the degree of aggregation of the elements of the object model. The selection condition is not limited to the name of the element and can be changed as appropriate.

  The selection unit 33 selects a plurality of elements that meet the selection condition received by the reception unit 32 from the plurality of elements stored in the element storage unit 1. The selection unit 33 collects the plurality of elements as an RDB wrapper, and stores the RDB wrapper in the memory 31. For this reason, the RDB wrapper corresponds to a plurality of elements in the element storage unit 1 selected based on the selection condition.

  The mapping unit 34 associates a plurality of elements stored in the memory 31 with the items in the RDB table stored in the RDB storage unit 2 and maps them as one group. For example, the mapping unit 34 maps a plurality of elements stored in the memory 31 to items in one table of the RDB stored in the RDB storage unit 2.

  Specifically, the mapping unit 34 creates, for each RDB wrapper element stored in the memory 31, a plurality of RDB tables having the elements as table items in the RDB storage unit 2. Thereafter, the mapping unit 34 denormalizes the plurality of tables based on the specific condition received by the receiving unit 32 and combines them into one table. For example, when the specific condition represents a request for processing time for a specific part of the application software corresponding to the element of the RDB wrapper stored in the memory 31, the mapping unit 34 sets the request so as to satisfy the request. Denormalize multiple tables to make final table. By mapping by the mapping unit 34, the RDB wrapper corresponds to an RDB table in which elements corresponding to the RDB wrapper are mapped to items.

  The mapping unit 34 maps a plurality of elements of the RDB wrapper stored in the memory 31 to items of different RDB tables, and associates these tables as one group (a group corresponding to the RDB wrapper). Also good. In this case, each RDB table associated as one group corresponds to the RDB wrapper stored in the memory 31.

  A plurality of elements in the element storage unit 1 selected based on the selection condition by the operations of the selection unit 33, the mapping unit 34, and the row addition / deletion processing unit 35 of the mapping apparatus 100 are stored in the RDB via the RDB wrapper. It is associated (mapped) with a plurality of RDB elements (example: table) in the section 2.

Next, a mapping method (operation of the mapping apparatus) according to the embodiment of the present invention will be described.
FIG. 2 is a schematic diagram showing an example of (an element of) an object model according to the embodiment of the present invention. The given object model includes, as elements, a “Party” class (“Party” class 41), a “field” class (“field” class 42), an “organization” class (“organization” class 43), “Person” class (“Person” class 44), “Activity” class (“Activity” class 45), “Position” class (“Position” class 46), and the relationship between “Party” and “Group” (generic ), The relationship between “Party” and “person” (generalization), the relationship between “field” and “organization”, the relationship between “organization” and “person”, the related class of “activity”, and the “activity” It has a “title” relationship.

  Here, it is assumed that the object model of FIG. 2 has the following characteristics. “Field” is used as the field of “organization”. The “field” is always used only for the operation required for the message to the “group”. High-speed processing is required for group searches using “field name” as a search condition. “Position” is always used only for the action required in the message for “activity”. A search for “person” using “organization name” and “title” as search conditions requires high-speed processing. “People” is generally widely used (other than those who work in “groups”).

  FIG. 3 is a schematic diagram showing an example of an RDB table according to the embodiment of the present invention. This given RDB table contains the following data: FIG. 3A shows an “organization master” 51, which includes “organization name” that is a primary key and field names as items. FIG. 3B shows a “group activity table” 52, which includes, as items, a name that is a primary key and a foreign key, a group name that is a primary key and a foreign key, an activity period, and a title. It is out. FIG. 3C shows a “person master” 53, which includes, as items, a name that is a primary key and a date of birth.

  FIG. 4 is a schematic diagram illustrating an example of mapping of an object model element, an RDB wrapper, and an RDB element by the RDB wrapper according to the embodiment of the present invention.

  Correspondence between the elements of the object model 11 (same as in FIG. 2) and the RDB wrapper 12 in the mapping method according to the embodiment of the present invention is performed as follows. Here, as an example, the “Party” class 41 will be described.

  The object model 11 is received in advance by the receiving unit 32 from the user or another device and stored in the element storage unit 1. The RDB table 13 is received in advance by the receiving unit 32 from a user or another device and stored in the RDB storage unit 2.

  In order to create an RDB wrapper with reference to the object model 11, the mapping unit 34 first selects one class (element) and reads an element related to the class (element).

  For example, the mapping unit 34 refers to the object model 11 to create a “Party wrapper” 61 that is an RDB wrapper of the “Party” class 41, a “Party” class (element), and “Party” The relationship (generalization) between “organizations” and the relationship (generalization) between “Party” and “people” are read out.

  Next, the mapping unit 34 refers to the RDB table 13 based on the read data, and identifies the RDB table corresponding to the RDB wrapper. Then, using the solving means 1 to 16, an RDB wrapper indicating the relationship between the object model and the RDB table is generated.

  For example, the mapping unit 34 refers to the RDB table 13 based on the read data, and sets the “organization master” 51 and the table corresponding to the class (“Party” class 41) corresponding to the “Party wrapper” 61. Two tables of “human master” 53 are specified. The mapping unit 34 stores two tables, “organization master” 51 and “person master” 53, corresponding to the “Party” class 41, and stores conditional correspondence in the memory 31. The conditional correspondence is “organization master” 51 when the condition: class = “organization”, and “person master” 53 when the condition: class = “person”. Such processing by the mapping unit 34 corresponds to the solving means 1.

  However, since the mapping unit 34 has two columns “organization master.organization name” and “person master.name” corresponding to the attribute of “name” of the “Party” class 41, there is a conditional correspondence relationship. Is stored in the memory 31. The conditional correspondence relationship is stored in the memory 31 in the condition: “group master.organization name” when the class = “organization” and “person master.name” when the condition: class = “person”. Such processing by the mapping unit 34 corresponds to the solving means 2.

  Here, since there is no RDB element corresponding to the generalization of the “Party” class 41 (identification information of the class to which the instance for handling the generalization belongs), the mapping unit 34 uses the primary key of the table corresponding to the class. A table held as a foreign key and having a class identifier column is added to the RDB table 13. The tables to be added are a “PartyID (group) table” 55 and a “PartyID (people) table” 56. In the “PartyID (group) table” 55, the “group name” that is the primary key of the “group master” 51 is an external key. In the “PartyID (person) table” 56, the “name” that is the primary key of the “person master” 53 is an external key. Such processing by the mapping unit 34 corresponds to the solving means 14.

  In this way, the “Party” wrapper 61 is associated with the “organization master” 51, the “person master” 53, the “PartyID (group) table” 55, and the “PartyID (person) table” 56. Accordingly, the “Party” class 41 via the “Party” wrapper 61 in FIG. 4, the “organization master” 51, the “person master” 53, the “PartyID (organization) table” 55, and the “PartyID (person) table” 56 Are stored in the memory 31.

  Similarly, the mapping unit 34 associates the “person” wrapper 64 with the “person master” 53, and the correspondence between the “person” class 44 and the “person master” 53 via the “person” wrapper 64 is stored in the memory. 31. Further, the “activity” wrapper 65 and the “group activity table” 52 are associated with each other by the mapping unit 34, and the “activity” class 45, the “position” class 46 and the “group activity table” 52 via the “activity” wrapper 65 are associated. Is stored in the memory 31. Further, the “group” wrapper 62 and the “group master” 51 are associated with each other by the mapping unit 34, and the “group” class 43 and the “field” class 42 and the “group master” 51 passed through the “group” wrapper 62. The correspondence relationship is stored in the memory 31.

  Thus, the mapping unit 34 associates the RDB wrapper 12 with the RDB table 13, and the correspondence between the elements of the object model 11 via the RDB wrapper 12 in FIG. 4 and the RDB table 13 is stored in the memory 31. Stored.

  The operations of the RDB wrapper 12 generated as described above (example: “Party” wrapper 61, “person” wrapper 64, “activity” wrapper 65, and “organization” wrapper 62) are performed as follows.

FIG. 5 is a flowchart showing the operation of the RDB wrapper according to the present embodiment. Here, as an example, the “Party” wrapper 61 will be described. The mapping unit 34 has a search program for the Party search method.
This program (SQL statement)
“SELECT {Primary key of the table of Party instances}
FROM {table name corresponding to class to which Party instance belongs}
WHERE {primary key of table of Party instance}
IN (SELECT {foreign key of the table of class identifiers of Party instances}
FROM {Table of class identifier of Party instance}
WHERE class identifier = “Party type”) AND
{The column corresponding to the attribute of “name”} = “name” ”.
The mapping unit 34 fills the curly braces “{}” in the SQL statement at the time of execution, and the party wrapper 61 of the RDB wrapper 12 executes the party search process.

  The above operation can be executed in the same manner even when the “unpurpose group” class 48 that inherits the “Party” class 41 is added. FIG. 6 is a schematic diagram illustrating another example of mapping of an object model element, an RDB wrapper, and an RDB element by the RDB wrapper according to the embodiment of the present invention. In this figure, an “unintended group” class 48 that inherits the “Party” class 41 is added to the object model 11 with respect to FIG.

  When the “unintended group” class 48 is added to the object model 11, the “unintended group” wrapper 68 and the “unintended group table” 58 are generated by the operation described in Japanese Patent Application Laid-Open No. 2007-249345. May be. Alternatively, when the “unintended group” class 48 is added to the object model 11 and the “unintended group table 58” is added to the table 13 of the RDB, the mapping unit 34 performs the same operation as described above. , A “unintended population” wrapper 68 can be generated.

  Regarding the “Party” wrapper 61, the mapping unit 34 further stores a “unpurpose group table” 58 in the memory 31 when the condition: class = “unpurpose group”, as a conditional correspondence. Such processing by the mapping unit 34 corresponds to the solving means 1. Accordingly, the mapping unit 34 further associates the “Party” wrapper 61 and the “unintended group table 58”, and the “unintended group” class 48 and the “unintended group table” 58 via the “Party” wrapper 61. Is further stored in the memory 31.

  As a result, by performing the mapping shown in FIG. 6 by the mapping unit 34, the party search of the “unintended population” class 48 can be executed without changing the search program for the party search method. As described above, the object model has the advantage of easy change and the advantage of scale reduction.

  On the other hand, let us consider a mapping (example: JP-T-2001-518670) that mainly uses RDB and determines an object model in accordance with the table structure of RDB. FIG. 7 is a conceptual diagram showing the relationship between the link and the RDB table when the “unintended group” class is added to the object model. FIG. 8 is a sequence diagram showing the operation of the RDB wrapper in the case of FIG. 8A shows a “person” search, FIG. 8B shows a “group” search, and FIG. 8C shows a “unintended group” search. When the “unintended group” class is added to the object model as shown in FIG. 7, the “unintended group” table is added to the RDB table, and the sequence diagram as shown in FIG. It is necessary to add a program, and the benefits of ease of change and scale reduction cannot be enjoyed.

  FIG. 9 is a sequence diagram illustrating an example of a sequence process. For the processing of the sequence as shown in FIG. 9, when encapsulation is performed that completely matches the object model, a plurality of SQL statements are required according to the message on the sequence diagram, and the required high-speed processing Unable to achieve performance. However, in the present invention, since it can be executed with a single SQL statement “SELECT organization name FROM organization master WHERE field name =“ field name ””, the required performance can be realized.

  In the present invention, even when the structure of the RDB used for persisting an instance of a given object model is a determined constraint, the object model operates with acceptable performance while maintaining the changeability of the object model. I can do it. The reason is that there is a configuration for associating each element of a given object model with each element of a given RDB, and a configuration necessary for operating the system according to the corresponding relationship including the record addition / deletion processing unit 35. Because.

  According to the present invention, it is possible to provide a mapping apparatus, a mapping method, and a program that can be used even when the structure of the RDB is a determined constraint and can take advantage of the object model.

FIG. 1 is a block diagram showing the configuration of the mapping apparatus according to the present embodiment. FIG. 2 is a schematic diagram showing an example of an object model according to the embodiment of the present invention. FIG. 3 is a schematic diagram showing an example of an RDB table according to the embodiment of the present invention. FIG. 4 is a schematic diagram showing an example of mapping of an object model element, an RDB wrapper, and an RDB element by the RDB wrapper according to the embodiment of the present invention. FIG. 5 is a sequence diagram showing the operation of the RDB wrapper according to the present embodiment. FIG. 6 is a schematic diagram showing another example of mapping of an object model element, an RDB wrapper, and an RDB element by the RDB wrapper according to the embodiment of the present invention. FIG. 7 is a conceptual diagram showing the relationship between the link and the RDB table when the “unintended group” class is added to the object model. FIG. 8 is a sequence diagram showing the operation of the RDB wrapper in the case of FIG. FIG. 9 is a sequence diagram illustrating an example of sequence processing.

Explanation of symbols

DESCRIPTION OF SYMBOLS 1 Element storage part 2 Relational database (RDB) storage part 3 Processing part 10, 10a-10c Object model element 11 Object model 12 Processing part (RDB wrapper)
13 RDB table 20, 20a to 20c RDB element 31 Memory 32 Reception unit 33 Selection unit 34 Mapping unit 35 Row addition / deletion processing unit 41 Party class 42 Field class 43 Group class 44 Person class 45 Activity class 46 Job class 48 None Target Group 51 Group Master 52 Group Activity Table 53 Person Master 55 PartyID (Group) Table 56 PartyID (Person) Table 58 Unpurposed Group Table 61 Party Wrapper 62 Person Wrapper 64 Group Wrapper 65 Activity Wrapper 68 Unpurposed Group Wrapper 100, 100- 1, 100-2 mapping device

Claims (10)

An element storage for storing a plurality of first elements of the object model;
An RDB storage for storing a plurality of second elements of a relational database;
In the case where the structure of the relational database is a determined constraint, there is a correspondence relationship between the third element selected from the plurality of first elements and the fourth element of the plurality of second elements. A mapping unit that identifies a condition in a case where the condition is satisfied and generates a mapping including the correspondence with the condition. The mapping device according to claim 1,
When the structure of the relational database is a determined constraint, the mapping unit corresponds to the third element when none of the plurality of second elements has a corresponding relationship with the third element. A mapping device for adding the added new element to the plurality of second elements. An element storage for storing a plurality of first elements of the object model;
An RDB storage for storing a plurality of second elements of a relational database;
When the relational database structure is a determined constraint, when there is no correspondence among the plurality of second elements with respect to the third element selected from the plurality of first elements, A mapping device comprising: a mapping unit that generates a mapping by adding a new element associated with a third element to the plurality of second elements. The mapping device according to any one of claims 1 to 3,
Each of the plurality of first elements includes any one or any one instance of a class, a qualifier, an association, and a generalization,
Each of the plurality of second elements includes any one or any one value of a table, a row of the table, and a column of the table. Referencing a plurality of first elements of an object model and a plurality of second elements of a relational database;
In the case where the structure of the relational database is a determined constraint, there is a correspondence relationship between the third element selected from the plurality of first elements and the fourth element of the plurality of second elements. Identifying a condition if satisfied;
Generating a mapping including the correspondence with the condition. The mapping method according to claim 5,
If the relational database structure is a determined constraint, a new element associated with the third element when there is no corresponding relationship with the third element among the plurality of second elements A mapping method further comprising: adding to the plurality of second elements. Referencing a plurality of first elements of an object model and a plurality of second elements of a relational database;
When the relational database structure is a determined constraint, when there is no correspondence among the plurality of second elements with respect to the third element selected from the plurality of first elements, Adding a new element associated with a third element to the plurality of second elements to generate a mapping. A step of referring to an element storage unit that stores a plurality of first elements of an object model and an RDB storage unit that stores a plurality of second elements of a relational database;
When the mapping unit is a constraint whose structure of the relational database has been determined, a third element selected from the plurality of first elements is compared with a fourth element of the plurality of second elements. Identifying a condition when a correspondence relationship is established between,
A program for causing a computer to execute a mapping method, wherein the mapping unit includes a step of generating a mapping including the conditional correspondence. The program according to claim 8, wherein
When the mapping unit is a constraint whose structure of the relational database has been determined, and when there is no correspondence relationship with the third element among the plurality of second elements, it corresponds to the third element A program for causing a computer to execute a mapping method further comprising the step of adding a new element added to the plurality of second elements. A step of referring to an element storage unit that stores a plurality of first elements of an object model and an RDB storage unit that stores a plurality of second elements of a relational database;
When the mapping unit is a constraint whose structure of the relational database has been determined, a correspondence relationship is established in the plurality of second elements with respect to the third element selected from the plurality of first elements. A program for causing a computer to execute a mapping method, comprising: adding a new element associated with the third element to the plurality of second elements when there is no mapping, and generating a mapping.

Images