JPH06266603A - Object directing data base management system - Google Patents

Abstract

PURPOSE:To provide an object directing data base management system which can construct a flexible system adjusted to the scales of various applications. CONSTITUTION:The object directing data base management system 3 is provided with a core part 32 providing a basic function for storing/managing a permanent object, one or plural parts objects 33A and 33B providing extension functions for extending the basic function on storage/management and a control means 34 controlling the connection of the extension functions which the parts objects 33A and 33B have as against the basic function which the core part 32 has in accordance with the request of a user operating the permanent object. Thus, a storage management environment corresponding to the scale which the user(application) requests is provided.

Description

Detailed Description of the Invention

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to an object-oriented database system in which a persistent object having a complicated data structure that directly reflects the information structure of the real world is the object of operation. The present invention relates to an object-oriented database management system that executes storage management related to generation and deletion of objects.

[0002]

2. Description of the Related Art In recent years, in CAD (Computer Aided Design), CASE (Computer Aided Software Engineering), OA (Office Automation), Network Management, etc., an object having a complicated data structure is efficiently processed. It is well known that an object-oriented database system is attracting attention as a database system suitable for the.

The object-oriented database management system refers to such an object-oriented database system, and its data, that is, generation of an object,
This is a part that executes storage management related to deletion, etc. Normally, this object is used so that the application that uses this database system can use the object created on the main storage device even after the execution of the application is completed. It becomes persistent, that is, stored in a secondary storage device as a persistent object, and manages the load / store of the object between the main storage device and the secondary storage device. FIG. 12 shows the concept of an object storage management mechanism by such an object-oriented database management system.

That is, in FIG. 12, reference numeral 1 is a database constructed on a secondary storage device such as a magnetic disk device, and 2 is an application request for the database 1 (object storage management request for object creation / deletion). Is an object-oriented database management system configured on a main memory to manage the stored data and execute the required storage processing. The database management system 2 is further associated with an input system shown in FIG. The output management unit 21 and the object storage management unit 22 are included.

Here, the input / output management unit 21 decodes a user's processing request such as a request to generate an object Obj given via the application,
The contents are given to the object storage management unit 22, and the generation result of the specified object Obj by the object storage management unit 22 is a part which plays a role of an interface such as returning this to the application. Further, the object storage management unit 22 generates the corresponding object Obj in the main storage device by being given the contents of the processing request from the input / output management unit 21, and also generates the generated object Obj. This is a part that manages the storage mode of these objects by executing actual processing such as persisting as a persistent object PObj and storing this in the database 1 on the secondary storage device. By performing storage management of objects through the object-oriented database management system 2 as described above, the persistent objects on the database 1, that is, the secondary storage device, are operated from the application side in a manner of operating the objects normally. You will be able to operate.

Details of such an object-oriented database system or an object-oriented database management system are described in, for example, Japanese Patent Laid-Open No. 3-137.
No. 730 (the title of the invention "object-oriented computer system"), "Information Processing" May 1991 issue (May 15, 1991, published by The Information Processing Society of Japan).

[0007]

By the way, as an object-oriented database management system, in addition to the function of making an object generated on the main memory device persistent, there are also the following objects: Function to manage identifiers ・ Function to manage files on secondary storage device ・ Function to control parallel processing ・ Function to recover from failure if it occurs ・ Function to manage index ・ Query function ・ Clustering function ・ Security function Although many functions are required and are being embodied so that they can be used, for example, the above-mentioned JP-A-3-1377.
As disclosed in Japanese Patent No. 30 (the title of the invention, "Object-Oriented Computer System"), the conventional object-oriented database system is a software system integrated by itself, and stores the above-mentioned generation and deletion of objects. Even the part related to management is not configured so that the user can freely customize only that part. Incidentally, according to the document, the object manager shown in FIG. 5 manages the object table. This is because the application programmer adds or deletes a function according to the purpose. Not something you can do.

As described above, in the conventional object-oriented database or its management system, for example, various advanced functions for memory management are fixedly installed in advance in the system itself, and from among the installed functions,
Since the application (user) has adopted the form of selectively using only the function that it needs each time, it realizes the function that it does not use for the application (user) who does not need all of the built-in functions. The computer resources (for example, storage areas for various management tables on the main storage device, CPU capacity, etc.) required to do so are wasted, and conversely, if more advanced functions are required in the future. However, it was not possible to meet such demands because the built-in functions cannot be expanded.

The present invention has been made in view of such circumstances, and various applications (user's request)
The object of the present invention is to provide an object-oriented database management system which enables flexible system construction by selecting necessary and sufficient storage management functions according to the scale of the system.

[0010]

In order to achieve these objects, the present invention provides (a) a core part that provides a basic function for storing and managing a persistent object, and (b) the same basic function for the same storage management. One or more component objects that provide an extension function for extending, and (c) the combination of the extension functions of these component objects with the basic functions of the core according to the request of the user who operates the persistent object. An object-oriented database management system is configured with control means for controlling.

[0011]

The core part is a part that provides the minimum necessary functions such as the above-mentioned persistence, management of object identifiers, file management on the secondary storage device, concurrency control, failure recovery, etc. The part object is a part that provides a function that is not in the above core part such as index management, inquiry function, clustering, security, etc., that is, an extended function, respectively, and that the part object is controlled by the control means. Any one or a plurality of the extended functions possessed is combined with the above-mentioned basic function originally possessed by the core part or the combination thereof is released, thereby providing, for example, a high-level storage management function to the object-oriented database management system. For the requesting application (user),
It becomes possible to obtain a high-level storage management environment in which one or more of the required extended functions are combined with the basic functions of the core, and it is necessary for the object-oriented database management system. For applications (users) that require only a minimum scale of storage management function, the basic part of the core part responds to the request (that is, request that does not require any extended function in this case = normal data operation request). It becomes possible to obtain a compact storage management environment consisting only of functions. Incidentally, assuming the same computer resource, generally, the former high-level storage management environment is suitable for applications (users) who prioritize execution efficiency even if it is somewhat disadvantageous in terms of storage efficiency. It can be said that the storage management environment is suitable for applications (users) that prioritize storage efficiency. On the other hand, if the computer resources are different, it is also possible to set a storage management environment that is sufficient to match the individual computer resources.

In any case, according to the object-oriented database management system having the above configuration, it is possible to construct a flexible system that matches the scale of various applications (user requests).

As such an object-oriented database management system, (d) a component management table indicating through which of the component objects the persistent object stored in the secondary storage device is stored and managed is provided in the secondary storage device. By further providing a means for generating the same in the so-called server / client model, even when a plurality of clients in different storage management environments access the same database resource managed by the server. By allowing each client to access the required data while referencing such a component management table, incompatibilities due to different storage management functions of different component objects, data destruction and confusion caused by it It becomes possible to prevent such problems.

[0014]

1 shows an embodiment of an object-oriented database management system according to the present invention.

In the system of the embodiment shown in FIG. 1, 1 is a database constructed on a secondary storage device such as a magnetic disk device as in FIG. 12, and 3 is an application request (object) to the database 1. Object storage management request relating to the creation / deletion of objects), and an object-oriented database management system configured on the main memory to execute the required storage processing. Further, an input / output management unit 31, an object storage management unit core (hereinafter simply referred to as core) 32, and a part object 33 that are associated in the manner shown in FIG.
A, 33B, ..., And a combination control unit 34.

Here, the input / output management unit 31 decodes a user's processing request such as a request to generate an object Obj given via the application and gives the contents to the combination control unit 34, and also the combination control. Part 3
The result of the generation of the designated object Obj through 4 is a part that plays an interface role such as returning this to the application.

The core unit 32 is a unit configured to provide only the basic function of the storage management function as the object storage management unit. Incidentally, in this embodiment, for example, (a) object persistence (b) object identifier management (c) file management on the secondary storage device (d) concurrency control (e) failure in the core 32 For example, it is assumed that essential functions such as recovery from an object storage management unit are built in in advance, even though the object storage management unit has a minimum scale.

Further, the part objects 33A, 33
B, ... Are persistent objects realized by using the basic functions of the core part 32, and these are parts that provide functions for expanding the basic functions of the same memory management. By the way, in this embodiment,
For these part objects 33A, 33B, ...
For example, (f) index management (g) inquiry function (h) clustering (d) security, etc. are not essential, but it is desirable to have them as an object storage management unit, or to realize more advanced storage management. It is assumed that functions such as the above are convenient.

Then, the combination control unit 34 combines the extended functions of these component objects 33A, 33B, ... With the basic functions of the core unit 32 based on the contents of the application request given through the input / output management unit 31. Is a part mainly controlling the presence / absence of the object and the combination mode when there is a combination, and the request contents are given from the input / output management part 31 about the generation request of the object Obj, for example, the core part 32. Creates the corresponding object Obj on the main storage device based on the storage management function defined as the basic function in
Further, it is also a part for executing processing such as making the generated object Obj persistent as a persistent object PObj and storing it in the database 1 on the secondary storage device. Incidentally, in this embodiment, the core part 3 is
2 has the basic functions and part objects 33A, 33
It is assumed that the extended functions of B, ... Are provided in the form of a library for each corresponding function.

For convenience of explanation, a storage management object that realizes a clustering function (adds a function) will be taken up as an example of the above-mentioned component object. Then, it is assumed that an object that realizes this clustering function is registered in the object-oriented database management system 3 as the component object 33A.

Clustering is to arrange data having a semantically close relationship in physically close positions on the secondary storage device so that access processing to the data to be stored in the database 1 can be performed at high speed. Is. Here, the concept of segment is introduced as a logical unit for arranging data, that is, persistent objects. One segment represents variable-length data composed of a plurality of pages. A page is an object that represents fixed-length data on the secondary storage device, and this page is the unit of physical clustering here. In addition, segments are objects that control the creation and deletion of objects in their own segments, and if there is an object allocation request to these segments, the corresponding page is managed for each page. Function to allocate the object to be created. Therefore, although the segment itself is composed of a number of pages that are not necessarily continuous and manages them, the user sees the segments as if they were physically continuous areas. If the objects (data) that are semantically related to each other are requested to be allocated to the same segment, the probability that a plurality of objects will be allocated to the same page becomes high. For reference, the relationships among the segments, pages, and objects (persistent objects) on these secondary storage devices are shown in FIG.

That is, in FIG. 2, 1 is the above-mentioned database, and one of them has three segments of "segment 1", "segment 2", and "segment 3" as shown in FIG. Are configured. "Segment 1" is not necessarily physically continuous "Page 1", "Page 2", and "Page 3"
It is assumed that it is composed of three pages (physical pages) for managing the creation and deletion of objects on those pages, and that "segment 2" is not necessarily physically continuous "page 4" and "page 5". , Page 6 and page 7 (physical pages), and manages the creation and deletion of objects on those pages. Similarly, segment 3 also has page 8 And “page 9” are two pages (physical pages) and manage the generation and deletion of objects on these pages. In the figure, circles indicate "POb
Each j indicates an object (persistent object, that is, data) allocated to each corresponding page through the above "segment 1,""segment2," or "segment 3". The above-described relationship of the segment, page, and object on the secondary storage device is typically in such a mode. In addition,
Although illustration is omitted in FIG. 2, each segment holds a connection relation of pages to be managed and correspondence with each object as a table or a list therein.

Now, suppose that there is a request from the user for such a database 1 "allocation request by designating" segment 1 "of three related objects" as shown in the upper right part of FIG. By the page management function based on this "segment 1", all of these objects are empty areas of the page managed by the "segment 1", that is, "page 1" in this example, in the mode indicated by the arrow in FIG. Will be assigned to. In this case, all three related objects were accidentally allocated to the same page, but if the segment does not exist, those objects have empty spaces at that time, for example, “page 4”, “page 9”. , And "Page 6" are likely to be physically spaced and allocated, introducing this segment increases the probability that related objects will be allocated to the same page. It is also easy to understand.

In such a database system, since data (object) is usually transferred in page or segment units, if a plurality of related data can be allocated to the same page in this way, it is the minimum. Efficient data transfer can be realized with limited access.

In the system of this embodiment shown in FIG. 1, the part object 33A has storage management objects A1, A2, A representing each of these segments.
.., which is a component object that adds the above-mentioned clustering function to the basic function of the core part 32. Hereinafter, based on such a premise, its implementation mode and operation as the system of the embodiment Will be further described in detail.

In the object-oriented database management system, when an object is created in the system, the object-oriented language prepared by the system is used. Usually, in an object-oriented language, a function for creating an object is prepared as a function of a class. For example, in an object-oriented language called C ++ (C ++), a constructor that is an object generator is prepared for each class, and an object is allocated from a free memory by a new operator. As a method of generating an object as a persistent object, there are a method of changing a language specification to introduce a new syntax, a method of providing a generating function of a persistent object, and the like.

Here, as a method of generating a persistent object in a specific segment, a method of passing a segment as a parameter to a function for generating a persistent object prepared in the core 32 will be shown as an example. A segment constitutes a class hierarchy, and the top class has a default storage management behavior such as default page management, that is, page allocation from the end regardless of the segment. And An instance of a class that behaves with this default behavior is called a default segment here for convenience. This default segment is also the core 32
It is assumed that a default segment (correctly, a storage management object corresponding to the default segment) 32a is incorporated in advance.

A variable storage area 34a for storing the currently used segment as the current segment is provided in the coupling control section 34. The segment set as the current segment is a segment used when the segment is not passed as a parameter to the persistent object generation function or when the passed segment address is null (NULL). If this current segment is also null (NULL)
If it is, the default segment 32a is finally used.

FIG. 3 shows, as an operation example of the embodiment system, a procedure for generating (allocating) such an object by a persistent object generating function.

That is, assuming that the preprocessing required for object generation here, such as generation of a target database and generation of the segment for the database, has already been completed, the input / output management is performed. If an application program requesting generation of an object is input to the unit 31 and the decrypted content is given to the combination control unit 34, the combination control unit 3
This persistent object generation function in the core part 32 is called through 4 and the allocation of objects in the modes listed below is executed by the persistent object generation function.

(1) The persistent object creation function checks the address of the segment passed as a parameter (see FIG.
In step S31), if this address is not null (NULL), that is, if the application explicitly specifies which segment to use, generation of an object for the specified segment, Request allocation (step S3 in FIG. 3)
2). The segment requested for this processing is the storage management object A1 in the component object 33A,
Any one of A2, A3, ..., This request is passed to the storage management object corresponding to the designated segment through the coupling control unit 34. In the storage management object that has received the request, through the corresponding segment, the object is allocated to the page managed by itself in the database 1 through the corresponding segment, and the allocated object (persistent object ) Is returned to the persistent object generation function via the binding control unit 34. As a result, the persistent object generation function assigns the received address to the binding control unit 34 as if it had performed the above allocation.
And returns to the input / output management unit 31 (step S36 in FIG. 3).

(2) When the address of the segment passed as the above parameter is null (NULL), that is, when the segment is not designated (step S in FIG. 3).
31), the persistent object generation function is the binding control unit 34
Is checked to see if the current segment is set (step S33 in FIG. 3). As a result, if the current segment is set, that is, if the current segment is not null (NULL), the current segment is requested to generate and allocate the object (step S34 in FIG. 3). As described above, when the current segment is set, which of the above-mentioned segments is registered in the variable storage area 34a in the coupling control unit 34, and this request is , Is passed to the storage management object corresponding to the segment registered as the current segment among the storage management objects A1, A2, A3, ... In the component object 33A. The storage management object that has received the request, similarly to the above, executes the allocation of the object to the page managed by itself through the corresponding segment, and assigns the address of the allocated object (persistent object) to the binding control unit 34. To the persistent object creation function via. As a result, the persistent object generation function returns the received address to the input / output management unit 31 through the coupling control unit 34, as if the persistent object generation function itself performed the above-described allocation (step S in FIG. 3).
36).

(3) If the segment is not specified (step S31 in FIG. 3) and the current segment is not set (step S33 in FIG. 3), the persistent object generation function is the default segment provided in the core 32 in advance. 32a is requested to generate and allocate the object (step S35 in FIG. 3). As described above, the default segment 32a is a storage management object that executes basic storage management such as simply allocating pages from the end to the database 1, and after the allocation is executed, the allocation is performed. The address of the object (persistent object) will be returned to the persistent object creation function. As a result, the persistent object generation function returns the received address to the input / output management unit 31 through the binding control unit 34 as if it had executed the above allocation (step S36 in FIG. 3).

As described above, the component object 33A for managing the segment is provided, and the core segment 32 is provided with the default segment 32a, and the current segment can be set. ) For applications that explicitly specify a segment, it provides a powerful clustering function using the specified segment. (B) If the current segment is set without specifying the segment, that is, even if it is an existing application that does not use the segment, if the description to set the current segment is used, the current segment is used in the same manner. To provide a powerful clustering function. (C) Only the basic storage management function based on the default segment is provided for applications that do not specify these segments or set the current segment.
That is, clustering is not actively performed, but more storage area as computer resources is left for that amount. Even if one clustering function such as the above is adopted, extremely flexible and wide-ranging storage management can be realized. Figure 4
For reference, an actual example of each application program shown as (A), (B), and (C) is shown.

That is, FIG. 4A shows an example of an application in which the above segment (A) is explicitly designated, and each line has the following meanings.

First line: A database named "example" is generated. It is assumed that this application program interface (API) for using the system of this embodiment belongs to the core part 32.

Second line and third line: Segment s respectively
Generate eg1 and seg2. At this time, since these segments are persistent objects, the data of these segments are stored in the database 1 by the function of the core 32. Further, this API is assumed to belong to the part object 33A.

Lines 4 and 5: Segment s respectively
The objects Obj1 and Obj2 are assigned to the segments by explicitly specifying eg2. This API also belongs to the part object 33A. By the way, the image of this allocation is shown in FIG. In this case, as shown in FIG. 5, a powerful clustering function through the designated segment seg2 is provided. In FIG. 5, PObj1 and PObj2 are the objects Obj1 and Obj, respectively.
2 shows a persistent object in the database 1.

Line 6: the database "exampl"
Close e ". This API is in core 32.

Further, FIG. 4B shows an example of the application including the description for setting the current segment, although the segment is not explicitly specified in the above (B), and each line is as follows. Have meaning.

First line: A database named "example" is generated.

Second line and third line: Segment s respectively
Generate eg1 and seg2.

4th line: The current segment, that is, the current segment is set in the database "example". As a result, the address of the segment seg1 (positional information in the database 1) is stored in the database 1 as the current segment, and the segment seg is stored in the variable storage area 32a of the coupling controller 34.
1 is registered. FIG. 6 illustrates a storage image of this address.

Lines 5 and 6: Object Obj3
And Obj4 are generated. However, in this case, since the segment seg1 is set as the current segment, the objects Obj3 and Obj4 are allocated through this current segment seg1. An image of such allocation is shown in FIG. FIG. 7
In this case as well, a strong clustering function through the current segment seg1 is provided in this case as well. Note that in FIG. 7, PObj3 and Pbj3
Obj4 represents a persistent object in the database 1 of the objects Obj3 and Obj4.

Line 7: the database "exampl"
e "is closed.

FIG. 4C shows an example of the application in (C) where the segment is not specified and the current segment is not set, and each line has the following meanings.

First line: A database named "example" is generated.

Second and third lines: Object Obj5
And Obj6 are generated. In this case, only simple page allocation through the default segment 32a is performed.

Line 4: the database "exampl"
e "is closed.

The operation of the system of this embodiment when an object generation request is made has been described above. However, when a deletion request for those generated objects is input through an application, the operation of this embodiment is performed. The system further addresses this with the procedure shown in FIG. Incidentally, for this purpose, an object delete function which is prepared in advance in the core 32 is used, like the above-mentioned persistent object generating function.

That is, if an application program requesting deletion of an object is input to the input / output management unit 31 and the decrypted content is given to the combination control unit 34, the core unit is processed through the combination control unit 34. This object delete function in 32 is called, and the object delete function executes the object delete in the modes listed below.

(1) The object deletion function obtains the segment including the object designated for deletion (step S81 in FIG. 8). That is, specifically, the segment in which the object is included is specified based on the connection relation of the page held in each segment and the correspondence table with each object.

(2) As a result, if the corresponding segment exists, that is, if the segment is not null (step S82 in FIG. 8), the relevant segment is requested to delete the object (step S82). Figure 8
Step S83). The segment for which this processing is requested is any of the storage management objects A1, A2, A3, ... In the component object 33A, as in the case of the previous generation, and this request is sent via the combination control unit 34. It is passed to the storage management object corresponding to the specified segment. In the storage management object that received the request, through the corresponding segment, the database 1
Delete the object in the self-managed page in.

(3) As a result of specifying the above segment,
If there is no corresponding segment, that is, if the segment is null (FIG. 8, step S8).
2) Similarly, the default segment 32a prepared in the core 32 is requested to delete the object (step S84 in FIG. 8). As a result, the default segment 32a retrieves the object designated for deletion based on the standard storage management function, and deletes it.

As described above, the storage management object that realizes the clustering function is taken as an example of the part object, and the object that realizes this clustering function is installed as the part object 33A in the object-oriented database management system 3 has its configuration. , And the operation have been described in detail, but as described above, other desirable functions to be realized as this part object are, for example, an index management function, an inquiry function, or a security function. 33B, ..., Storage management objects related to these functions can also be appropriately installed in the object-oriented database management system 3. And according to the system of this embodiment,
Objects having these storage management functions are separated from the core part 32 as part objects, and only the functions required by the application each time are combined with the basic functions of the core part 32 through the combination controller 34. Therefore, the scale of the object-oriented database management system can be determined very flexibly according to the scale of those applications.

By the way, according to the system of the embodiment,
Although it is certainly possible to construct such a flexible system as an object-oriented database management system,
In particular, in a database system constructed as a server / client model, when a plurality of clients access the same database resource that is centrally managed by the server, a storage management mode is performed through different component objects for each client. There is a concern that various types of databases of different types will be generated, and as a result, the compatibility of the data will be lost.

Therefore, FIG. 9 shows another example of the object-oriented database management system according to the present invention, which is an example of a system which can satisfactorily solve such a compatibility problem. This figure 9
In FIG. 1, the same elements as those in FIG. 1 described above are denoted by the same reference numerals, and duplicate description of these elements will be omitted.

Now, in the system shown in FIG. 9,
In the newly provided part object management unit 35, the data (persistent object) generated in the database 1 of the secondary storage device is stored in the part objects 33A, 33B,
This is a part for generating the component management table 101 indicating which of the ... Is managed and stored in the secondary storage device, and managing the contents.

Here, the parts management table 101 is
For example, it is configured by an array as shown in FIG. 10, the index of each element is assigned to a specific component object, and an object (persistent object) is uniquely pointed in the database 1 as each element of the array. Possible identifier (object identifier: O
ID) and the like are stored. Although not shown in the figure for convenience in the parts management table 101, the identifier O
A core part 32 such as a so-called object table that represents the correspondence between the ID and the physical position information of the object on the secondary storage device (address or data size in the file on the secondary storage device that realizes the database 1). It also includes essential objects for However, the storage management objects required to realize these core parts 32 are commonly held by all database management systems (client systems), and regarding the data stored and managed by these storage management objects, Its compatibility is also kept good. That is, only the data stored and managed by the component objects 33A, 33B, ... Cause the compatibility problem. Incidentally, in the case of the example shown in FIG. 10, the component object 33A (which is assumed to be a component object for extending the clustering function to the basic function of the core part 32 as described above) is used for the database 1 The data of the part object A in the database 1 can be used from the client C1 accessing the part object 33B (this is, for example,
The data of the part object A in the database 1 is used from the client C2 accessing the same database 1 by using the basic object of the core part 32 as a part object for expanding the security function. It shows that you cannot do it.

Therefore, the component object management unit 35 is provided.
Is generated along with the generation of an object using the segments illustrated in FIGS. 3 and 5 to 7, for example.
A component management table 101 as illustrated in FIG. 10 is generated in the secondary storage device, and in order to avoid data destruction or the like due to the incompatibility in such a situation thereafter, for example, This is managed by the procedure shown in FIG.

That is, now, an application requesting access to the database 1 to the input / output management unit 31, for example, an application requesting generation of an object using the above-mentioned segment is input, and the decrypted contents are If it is given to the component object management unit 35 via the combination control unit 34, the component object management unit 35 handles the processing request in the modes listed below.

(1) First, it is checked whether the specified database 1 has been opened (step S11 in FIG. 11).
1) If it has not been opened yet, appropriate error processing is performed such as notifying the application to that effect through the input / output management unit 31 and ending the processing (step S112 in FIG. 11).

(2) If the database 1 is open, the parts management table 101 is read (see FIG. 11).
In step S113), it is checked whether or not the database is stored and managed by using the segment, that is, whether or not the database is stored and managed through the part object 33A (part object A) (step S114 in FIG. 11). In this example, since it is requested that the component management table 101 illustrated in FIG. 10 uses the segment, that is, the component object A, it is available data. However, when it is determined that access to the database using the component object 33B (component object B), which is a component to which a security function is added as described above, is requested. For example, an appropriate warning process such as returning a warning message to the application through the input / output management unit 31 and ending the process is executed (step S115 in FIG. 11). At least by this, the open database 1
It is possible to avoid a situation where the data in the inside is destroyed by an unauthorized access using a part object having a different storage management specification.

(3) If it is determined that the data is available, then it is checked whether or not a segment table exists as the data 101a (see FIG. 10) of the part object A (( FIG. 11 Step S
116), if it does not exist, the segment table is newly generated in the database (step S117 in FIG. 11). Here, the segment table is as follows. That is, when the database includes a segment, there is a high possibility that a plurality of the segment is included. In order for the database user to select a desired segment from multiple segments, all segments must be accessible. This includes identifiers OIDs of all segments
It is only necessary to realize a table including the above as an object and register the identifier OID of the table in the component management table 101. The segment table mentioned here is a table including the identifiers OIDs of all the segments realized as this object.

(4) In this way, the existence of the segment table is confirmed (step S116 in FIG. 11) or a segment table is newly generated (step S11 in FIG. 11).
7) Finally, the component object management unit 35 reads this segment table (step S118 in FIG. 11),
Based on the fact that the generation and allocation of the object in the mode as illustrated in the above-mentioned FIG. 3, FIG. 5 to FIG. 7 through the combination control unit 34 is completed, the generation and allocation result is reflected, Rebuild the segment table.

As described above, according to the system of the embodiment shown in FIG. 9, in the server / client model, a plurality of clients in the different storage management environments are uniformly managed by the server in the same database resource. Even when accessing the component object management unit 3
While referring to the parts management table 101 through 5,
Since the required data access or warning processing is performed, it is possible to prevent incompatibility of data based on different storage management functions of different component objects, data destruction, confusion, etc. It also becomes.

In the system of the embodiment, if it is determined as a result of referring to the component management table 101 that the data to be accessed cannot be used, warning processing is performed. The component management table 101 may be used in any manner. For example, a dynamic linking library (DLL) technique may be used, and a component object for using the data in the application based on the determination that the data cannot be used. May be dynamically linked.

[0068]

As described above, according to the present invention, the storage management function as an object-oriented database management system is appropriately distributed to some basic functions and some functions for extending the basic functions. Then, the functions are provided to the core part and one or a plurality of component objects respectively, and the application (user) requests whether or not the basic function of these core parts and the extended function of the component object are combined or not. Since the control is performed according to the requirements, it is possible to construct a very flexible system according to the scale required by those applications (users).

Further, according to the above configuration of the present invention, even in the case where a more advanced storage management function is desired in the future, it is possible to add a function required each time as the component object. Therefore, it becomes possible to easily deal with such a demand.

According to the present invention, in addition to the above configuration,
Since the component management table indicating which of the above-mentioned component objects the persistent object stored in the database is stored and managed is generated in the same database, access to the database while referring to the component management table By doing so, it is possible to prevent incompatibility based on different storage management functions of different component objects, data destruction, confusion, and the like due to the incompatibility. This is particularly effective in a database system constructed as a server-client model in which a plurality of clients access the same database resource that is centrally managed by the server.

[Brief description of drawings]

FIG. 1 is a block diagram showing a system configuration example of an object-oriented database management system according to an embodiment of the present invention.

FIG. 2 is a schematic diagram schematically showing the relationship of segments, pages, and objects on a secondary storage device as an explanation of clustering.

FIG. 3 is a flowchart showing an object generation procedure by the system of the embodiment shown in FIG.

FIG. 4 is a schematic diagram showing a description example of an application program requesting generation of an object to the system of the embodiment.

FIG. 5 is a block diagram schematically showing an object generation (allocation) mode by the system of the embodiment when an application requesting object generation by explicitly specifying a segment is input.

FIG. 6 is a block diagram schematically showing a storage mode of a current segment in a database when the current segment is set by an application.

FIG. 7 is a block diagram schematically showing an object generation (allocation) mode by the system of the embodiment when an application requesting object generation by setting the same current segment is input, although no segment is designated.

FIG. 8 is a flowchart showing the procedure of object deletion processing by the system of the embodiment.

FIG. 9 is a block diagram showing a system configuration example of another embodiment of the object-oriented database management system according to the present invention.

10 is a schematic diagram showing a specific example of the parts management table shown in FIG.

FIG. 11 is a flowchart mainly showing a processing procedure by the component object management unit as an operation example of the embodiment system shown in FIG. 9;

FIG. 12 is a block diagram showing a system configuration example of a conventional object-oriented database management system.

[Explanation of symbols]

1 ... Database, 3 ... Object-oriented database management system, 31 ... Input / output management section, 32 ... Core section, 3
3A, 33B, ... Component objects, 34 ... Combined control unit, 35 ... Component object management unit, 101 ... Component management table.

Claims (2)

[Claims] 1. An object-oriented database system in which a persistent object created in a secondary storage device is an operation target, and storage management for creation and deletion of the persistent object in the secondary storage device. In an object-oriented database management system for executing, a core part that provides a basic function for storing and managing the persistent object, and one or more component objects that provide an extension function for expanding the basic function for the same storage management And an object-oriented database management, which controls a combination of an extended function of these component objects with a basic function of the core part according to a request of a user who operates the persistent object. system. 2. An object-oriented database system in which a persistent object created in a secondary storage device is a target of operation, and storage management relating to creation and deletion of the persistent object in the secondary storage device. In an object-oriented database management system for executing, a core part that provides a basic function for storing and managing the persistent object, and one or more component objects that provide an extension function for expanding the basic function for the same storage management And a control means for controlling the combination of the extended functions of these component objects with the basic functions of the core part according to the request of the user who operates the persistent object, and the persistent object stored in the secondary storage device. Through which part object is stored and managed An object-oriented database management system comprising: means for generating the component management table shown in the secondary storage device.