JPH11120067A - Data base processing method for managing partial information of data precedently - Google Patents

Abstract

PROBLEM TO BE SOLVED: To reduce the load of data transfer and to suppress the consumption of memory resources by caching data transfer control information in a proxy instance and then transferring a maximum instance without expanding it on a memory. SOLUTION: An instance is a composite instance consisting of three instances 120, 130, and 140. For example, the instance 120 consists of instance management information 190 and a main body 121 representing the data of the instance. Of the information that the instance has, the proxy instance 110 consisting of partial information needed for a user and a data base process or control information for controlling this information, information for managing the partial information or control information, and information needed to acquire the instance is indicated from a handle 180 instead of the actual instance and then part of instance operation using the handle 180 is processed by the proxy instance 110 to suppress the transfer of the whole actual instance and its expansion on the memory.

Description

DETAILED DESCRIPTION OF THE INVENTION

[0001]

[0001] The present invention relates to a database processing apparatus. In particular, the present invention relates to a method for managing data having a complicated structure, variable-length data, or long data when an object-oriented extension of a relational database management system is performed.

[0002]

2. Description of the Related Art Data abstraction is a central idea of object-oriented programming. Data abstraction hides the physical structure of the data from the user of the data, and expresses the data model by the "behavior" of the object, which is a logical interface specification. One of the implementation techniques of this data abstraction is a "handle". A handle is a pointer to a fixed-length object. By using the handle, the user does not need to be aware of the size or physical structure of the object indicated by the handle. For example, when implementing a model in which "object A includes object B", object A can be constructed by having a handle pointing to object B without knowing the physical structure of object B.

[0003] Handles also reduce unnecessary copying. In an object assignment operation, instead of copying an object, a handle pointing to the object is copied, and the object is shared by a plurality of handles. Copy an object for the first time when updating the object via a handle (copy-on-write). By using the handle in this manner, it is possible to reduce the load associated with copying and save memory resources. If the object is large or variable length with respect to the handle,
This effect appears remarkably.

The object-oriented programming language C +
An example of a handle with + is by RBMurray (translated by Iwatani), "Realistic C ++ Programming" (Softbank 1994)
It is described in.

Regarding a handle to a persistent object in an object-oriented database, an object database standard: ODMG-93 (RGGCattel, et al. “T
HE OBJECT DATABASE STANDARD: ODMG-93 Release 1.1 ”,
Morgan Kaufmann Publishers, Inc., 1994).

In the field of relational databases,
There is a move to introduce object-oriented thinking. SQL3 (Database Language SQ) being considered as the standard
L, ISO Working Draft, July 1996) supports abstract data types and long object types, and introduces the concept of a locator, which is a handle for the user to manipulate objects of each type. However, this locator is different from a handle such as Ref of an object-oriented database, and is a handle indicating a “value (instance)” having no object identification.

In such a background, a method has been devised in which access information to a database server that manages instances is added to a handle that points to an instance of an abstract data type or a long object type, so that these instances can be fetched with delay. (Japanese Patent Application 9-54)
155). The exchange of instances between servers is handled by handles, and the transfer of real instances between servers is delayed until the instances are actually needed. Since the transfer of an instance of an abstract data type or a long object type is much higher than the transfer of a handle, the speed of database processing can be increased.

[0008]

When an object-oriented concept is introduced in a database management system, a user is provided with a consistent interface that does not depend on the physical structure of data to be operated or the life (temporary / permanent) of data. Desirable. For this implementation, it is useful to use a handle that can hide the physical structure of the data. However, in the above-described implementation using a handle, when an operation is performed on an instance indicated by the handle, it is necessary to expand the entire instance on a memory in order to guarantee the operation. For this reason, the following two problems occur when a long or complicated data type such as an abstract data type or a long object type is supported using a handle.

(1) In spite of the fact that the data necessary for the user or internal processing is a part of the instance, the entire instance is taken out, so that extra communication and unnecessary memory resource consumption occur, and the processing becomes slow. In some cases, processing becomes impossible due to lack of resources.

[0010] For example, dynamic type checking requires type information in an instance. Just to get this type information, retrieval of the whole instance occurs.

Also, consider an application that searches for a document that satisfies certain conditions, lists the titles and authors of the document, and displays the contents of the document selected from the list. All you need to list is the subject and the author. For documents that are not selected, document contents, which are long data, are not required. Nevertheless, all listed document instances are expanded in memory. Of course, by managing the title / author and the handle to the document instance on the application side, consumption of memory resources and communication cost can be suppressed. However, it is natural that the title and author are attributes of the document. Despite the fact that documents can be stored in a database as an abstract data type all at once, retrieving and re-managing each attribute separately on the application side is a defect in the interface specification between the database and the application.

(2) In the case of a long instance, there is a case where it is not practical to develop the entire instance in a memory. Further, since the physical structure is concealed by the handle, there is no means for selecting a process in consideration of the physical characteristic of being long. Therefore, when processing an instance having a size that is not practical to be developed in a memory, an enormous communication load and consumption of memory resources occur, and in many cases, the processing becomes impossible.

In order to solve these two problems, the present invention provides a method for operating and querying data having a complicated structure stored in a database or long data which is not practical to be developed on a memory. It is an object of the present invention to provide means for increasing the speed while maintaining a consistent interface that does not depend on the structure of.

[0014]

Means for Solving the Problems In order to solve the above-mentioned problems, of the information of the instance, partial information necessary for user or database processing or control information for controlling the above-mentioned information, and partial information or A part of the instance operation using the handle is processed by the proxy instance by pointing the proxy instance consisting of the information for managing the control information and the information necessary for acquiring the above-mentioned instance from the handle instead of the real instance. In addition, the transfer of the entire actual instance and the expansion to the memory are suppressed.

[0015]

Embodiments of the present invention will be described below in detail with reference to the drawings.

As a first embodiment, a method for performing database processing on an instance of an abstract data type using a proxy instance will be described.

First, the configuration of hardware for implementing the present invention will be described.

FIG. 2 shows a hardware configuration according to an embodiment of the present invention. One or more nodes, which are units of a processing device, are connected by a network (200) such as a LAN. The configuration of one node may take any form as long as it is a computer system that independently functions as a database system. For example, the node 201 includes a data processing device (211) including a central processing unit and a main storage device, and a data storage device (210) such as a hard disk. The node 202 has a configuration in which a data input / output device such as a keyboard and a display is added to the configuration of the node 201. Each node independently functions as a database system and can exchange data through a network. This configuration is a system in which a plurality of database systems are mutually connected via a network to perform data processing in parallel.

Next, an outline of a database system in which each node of the above hardware configuration functions will be described with reference to FIG.

The database system includes a plurality of application programs 303 and 304 created by the user.
And a database management system (3) that manages the entire database system such as processing of data operations and inquiries from application programs and resource management.
00) and a database (103) in which data is stored
And a dictionary (302) for storing database definition information.

The database management system (300)
It can be divided into a logical processing unit (310), a physical processing unit (320), and a system control unit. Logical processing unit (31
0) analyzes and executes inquiries from the application program. The query passed from the application program is described in a database query language such as SQL. Inquiry analysis unit (311)
Performs syntactic and semantic analysis on the query sentence.
The analysis result selects the optimal processing procedure for the inquiry by the static optimization processing (312). Code generation (313)
Generates an executable intermediate code according to the selected processing procedure. The dynamic optimization process (314) selects an optimal process according to the state at the time of execution from the process candidates selected by the static optimization process. Execute code analysis (31
5) executes the generated intermediate code according to the selection of the dynamic optimization processing.

The physical processing unit (320) includes an exclusive control (321) for performing exclusive control of resources shared by the system;
It comprises a data access process (322) for editing data and determining conditions, and a database buffer control (323) for reading and writing data.

The system control unit (330) performs input / output management and the like.

Hereinafter, a database processing method using a proxy instance in the database management system will be described.

FIG. 1 is a schematic diagram of database processing using a proxy instance.

In this embodiment, the database processing will be described as processing in two nodes for ease of explanation. In practice, there can be multiple nodes. These processes can be considered as a combination of processes in two nodes. In addition, the query execution node (10
1) and the database access node (102) are units of logical processing, and can correspond to the physical node having the hardware configuration shown in FIG. 2, or can be implemented by software within one physical node. Can be assigned a node (eg, a process). In the former case,
100 is equivalent to the 200 network of FIG.
In the latter case, 100 indicates inter-process communication or the like.

The query execution node (101) according to the intermediate code generated from the result of analyzing the query,
This is the node that performs the operation of the instance. The query execution node (101) has an instance management (10
5) exists, and provides for securing / releasing an area for expanding an instance and basic operations (generation, destruction, reference, update, and substitution) for the instance. The basic operation for the proxy instance is also performed by this instance management (105).

Database access node (102)
Is a node that manages instances stored in the database, and includes a storage instance operation (104) that provides basic operations (insert, update, search, retrieval, and deletion) on the storage instance, and a database that stores the instance.

Next, the structure of the instance will be outlined.

An instance is composed of a physical expression (instance entity) for managing the value of the instance and a handle (180) indicating the physical expression of the instance. The physical representation of the instance includes instance management information (19
0) and a body representing the value of the instance. Instance operations are performed via handles.

In FIG. 1, the instances stored in the database are composite instances composed of three instances 120, 130 and 140. Attention is paid to the instance 120. The instance includes instance management information (190) and a main body (121) representing data of the instance. The body 12 of the instance 120
1 stores a value for each attribute a1, a2, a3.

The value of the attribute a1 is a handle (180) to the instance 130.

The value of the attribute a2 is va2.

The value of the attribute a3 is a handle (180) to the instance 140.

In the body 131 of the instance 130, a value that is not attribute-managed (for example, a body of a character string type instance or a long object type instance), vb1
Is stored.

The body 141 of the instance 140 has attributes
It consists of c1 and c2, and the values vc1 and vc2 are stored respectively.

The proxy instance is one of the instances, and its basic structure is made up of instance management information (190) and a main body, similar to a general instance entity. Therefore, all basic operations on general instances can be performed. However, the handle indicating the proxy instance does not use the proxy instance as an entity, but uses the physical representation of the instance indicated by the proxy instance as an entity.

The proxy instance 110 shown in FIG. 1 includes instance management information (190) and a main body, like the instances 120, 130, and 140. The main body is composed of a handle (180) to the instance entity 120, partial data management information (111), and a data cache area (112). In this embodiment, in the data cache area, the value va2 of the attribute a2 of the instance 120 and the attribute of the instance 140 which is the value of the attribute a3 of the instance 120 are stored.
The value vc2 of c2 is cached.

The proxy instance 110 has a handle 1
Although referenced directly from (180) and handle 2 (180), handle 1 and handle 2 are handles that logically point to instance 120. Therefore, an instance operation via the handle 1 or the handle 2 is an operation on the instance entity 120.

Each structure of the proxy instance will be described in more detail.

Instance management information: Same as a general instance. It manages the reference counter, instance length, body data type (identifies abstract data type, long object type, character string type, etc.), etc.

However, in order to introduce a proxy instance, an identification flag indicating that it is a proxy instance is required separately from the data type of the main body.

The data type of the main body is the data type of the instance entity. That is, it is possible to determine from which instance entity the proxy instance is based on the instance management information. For example, it is possible to determine that the instance is a proxy instance of the instance of the abstract data type.

A handle to an instance entity: a handle pointing to an instance entity acting as a proxy.

The handle pointing to the proxy instance is a handle for operating the instance entity pointed to by this handle of the proxy instance.

Data cache management information: Information for managing partial information or control information of an instance entity to be cached in the data cache area. Type of information to be cached.

Information to be cached.

The cache state of the information to be cached.

And the like are managed.

Data cache area: An area for storing partial information or control information of an instance entity.

When the contents to be cached are determined at the time of compiling, the area length is calculated.

Next, a method for designating partial information or control information of the instance entity managed by the proxy instance will be described. The partial information of an instance entity is an abstract data type attribute, part of a value such as a long object type or character string type partial data (specified by an offset from the beginning and a length to be extracted), or a type identifier of an abstract data type And information for managing values such as the instance length of a large object type or a character string type. The control information of the instance entity is information for controlling the split transfer of the instance of the long object type.

The method of designating that such information is managed by the proxy instance can be roughly divided into two methods.

One is an explicit designation by the user. The specification method is as follows: ・ Extend the definition statement and provide a mark in the type definition or table generation to indicate that the proxy instance is to be cached in the attribute. Call the constructor of the proxy instance, and issue instructions to split and transfer long objects.

The other is a method of determining contents to be cached by the database system. These are: Default. In particular, when there is no user specification, caching such as a type identifier is performed as a default specification.

The attribute to be cached in the static optimization process (312) shown in FIG. For example, Select Document, Document >> Subject, Document >> Author From Document Table wher
If the query is e ..., the subject and author are cached in the proxy instance of the document instance.

Obtain statistical information, analyze frequently accessed attributes, and cache the attributes.

Analyzing the state of the instance at the time of execution,
Decide what to cache. For example, an instance of a long object type larger than a certain value caches control information for divided transfer.

And the like.

Next, as shown in FIG. 1, a database processing method of referring to attributes using a proxy instance that caches some attributes of the abstract data type as partial information will be described with reference to FIGS. 4 and 5. This will be described with reference to FIG.

Reference of an attribute using a proxy instance can be roughly divided into two processes. The first process of attribute reference is to execute a search, obtain a handle of an abstract data type of the search result, and generate a proxy instance. The second process of attribute reference refers to the attribute via the handle pointing to the generated proxy instance.

FIG. 4 is a flowchart of the first process of attribute reference.

In the query execution node shown in FIG. 1, a search is executed and a proxy instance is generated (400).
First, in order to obtain an instance of a target abstract data type, the database access node is requested to execute a query statement, that is, to execute a search (401). At this time, the search result specifies not only the instance (handle of) the target abstract data type but also the attribute value to be cached in the proxy instance. If you cache a2 and c2 as in Figure 1, one example of a query statement is
Select C1, C1 >> a2, C1 >> a3 >> c2 from ..... assuming that C1 is a column that stores the instance of the target abstract data type.

Upon receiving this request, the database access node executes a search (450, 451, 452). The query execution node obtains, as a search result, the handle to the instance of the specified abstract data type and the attribute value of the attribute to be cached in the proxy instance (4).
02). Generate a proxy instance in consideration of the size of the data to be cached, and set the contents of the obtained handle as a handle to the instance entity of the proxy instance. Further, the acquired attribute value is set in the data cache area of the proxy instance, and the content of the cache management information is updated (403). Further, a handle pointing to the instance of the abstract data type acquired as a search result is updated to point to the proxy instance that has generated (404).
FIG. 1 shows the state of each node at the time when the first processing is completed.

FIG. 5 is a flowchart of the second process of attribute reference. In the query execution node, the designated attribute value is obtained via the handle (500). First, it checks whether the instance pointed to by the handle is a proxy instance. This can be checked from the instance management information (190) of the instance. If it is not a proxy instance, an instance of an abstract data type has already been expanded on the memory, so that an attribute value is obtained from the instance entity (514). If it is a proxy instance, it is checked whether the next specified attribute is an attribute to be cached (502), and further, whether or not the attribute is cached (50).
3) Yes. If the attribute specified from the cache management information is to be cached and the attribute value is cached, the attribute value is obtained from the data cache area of the proxy instance (504). If either check condition is not satisfied, a request to transfer the instance entity is made using the handle to the instance entity of the proxy instance (510). In response to this request, the database access node performs an instance transfer process (550). First, an instance of an abstract data type that forms a composite instance with a handle is packed in one continuous area so as to be transferable (551). At this time, the contents of the handle are changed to indicate the relative position. Then, the packed instance is transferred (552). The query execution node receives the transferred instance and replaces it with the proxy instance (512). The proxy instance is deleted (513). FIG. 6 shows the state of the query execution node at the time when this step 513 is completed. In FIG. 1, the handle 1 and the handle 2 which pointed to the proxy instance are pointing to the instance entity in FIG. The attribute value is obtained from the expanded instance entity (514).

As described above, the access to the data cached in the proxy instance is very fast because neither new memory nor data transfer occurs. Further, even when access to uncached data occurs, the proxy instance has a handle to the instance entity, and therefore can access the data of the instance entity. However, instance transfer and memory reservation occur.

As a second embodiment, a description will be given of a method for performing database processing using a proxy instance for a large instance such as a character string type or a large object type instance which is not realistic to be developed in memory.

The hardware configuration and the configuration of the basic database system are the same as in the first embodiment.

FIG. 7 is a diagram for explaining the outline of taking out a long instance using a proxy instance.

The database access node (102) and the query execution node (101) are connected by 100 networks or inter-process communication. An application program (70
0) is connected.

The database access node has an instance management (105). This is similar to the instance management of the query execution node in FIG.

In the database, a long instance (7
20) is stored, the application program obtains a handle (180) pointing to the instance (pointing to the proxy instance), and using this handle, the long instance work area (7) of the application program
01), the body part (721) of the long instance is to be extracted. The long-sized instance work area is an area on a memory or an area of another storage device. Since the long instance is large, it is not realistic to develop it on the memory of the query execution node or the database access node. So, you can access the data using the handle without expanding it on the memory.
Introduce a proxy instance (710). This proxy instance stores, in the data cache area (112), the data length (711) of the long instance, which is partial information of the long instance, and control information (11) that can acquire data without expanding the long instance on a memory. 71
2) is cached. The control information 712 is, specifically, information for controlling divided transfer, and holds information on buffer management for divided transfer and state management.

As in the first embodiment, retrieval of a long instance using a proxy instance also includes a first process of searching and generating a proxy instance and a second process of dividing and transferring a long instance. .

FIG. 8 is a flowchart of the first process of extracting a long instance. The application program requests the database access node to execute a query statement (801) in order to obtain the long instance stored in the database (800). In response,
The database access node executes a search and generates a proxy instance (850). First, a search is executed according to the query (851). Next, a proxy instance is generated and initialized. The contents of the handle to the long instance of the search result are set as the handle to the instance entity of the proxy instance (852). The handle pointing to the generated proxy instance is returned as a search result (853). The application program receives a handle indicating the proxy instance generated in the instance management of the database access node as a search result (802).

FIG. 9 is a flowchart of a second process for extracting a long instance.

In the application program, a long instance acquisition process is started (900). In order to secure a long instance work area, a request to acquire the data length of the long instance is issued to the database access node using the handle (901). In response, the database access node obtains the data length of the long instance (920). First, it is checked whether or not the data length in the data cache area of the proxy instance indicated by the handle is cached (921). If cached, the cached value is returned (922, 923). If not cached, the data length of the long instance is obtained from the database using the handle to the instance instance of the proxy instance (930). The acquired value is set in the data cache area of the proxy instance (931) and returned (923).

The application program uses the acquired data length (902) to secure a long instance work area (903). By specifying this area and using the handle, a request is made to retrieve a long instance (904, 910). The database access node starts the transfer process of the instance (930), and uses the handle to the instance entity of the proxy instance,
While maintaining the transfer control information, the long instance of the database is divided and transferred (931, 932, 9
33, 934).

The inquiry execution node executes processing for receiving the divided transfer (911, 912, 913). If all of them can be received, the long instance has been extracted to the long instance work area (905).

FIG. 10 shows an outline of insertion of a long instance into a database using a proxy instance. The format of the proxy instance is the same as that of FIG. 7, except that the proxy instance exists on the instance management of the query execution node side, and the handle to the instance instance of the proxy instance is a long instance work area in which the long instance is stored. The difference is that the handle pointing to the proxy instance is held by the storage instance operation of the database access node.

A method of inserting a long instance using a proxy instance will be described with reference to the flowchart of FIG.

In the application program, the process of inserting the long instance stored in the long instance work area into the database is started (1100).
A proxy instance is generated, and a pointer to a long-sized instance work area is set in a handle pointing to the instance entity of the proxy instance (1101). Using the generated handle to the proxy instance, a request is made to insert the long instance into the database. In response to this, the database access node starts insertion processing of the long instance (1110). First, a handle to the proxy instance specified at the time of the insertion request is obtained (1111). Via this handle, a long instance split transfer request is issued to the proxy instance (1112). Although the direction of the split transfer is reversed from the query execution node to the database access node, the method is the same as in FIG. The database access node sequentially stores the data to be divided and transferred in the database (1113). When the transfer is completed, an end notification is sent to the application program (1103).

As described above, by caching the data transfer control information in the proxy instance, the long instance can be transferred from the database to the user area or from the user area to the database without expanding the long instance on the memory. Moreover, the interface using the handle remains as it is.

[0083]

As described above, when a part of an instance that is frequently accessed is acquired at the same time as the handle of the instance is acquired, the acquired part is cached in a proxy instance.
By suppressing the process of transferring the entity of the instance and expanding it in the memory, the data transfer load can be reduced and the consumption of memory resources can be suppressed. Further, by caching information for controlling data transfer between the database and the user in the proxy instance, the consumption of memory resources can be suppressed, and the data transfer can be optimized. Therefore,
The overall processing efficiency is increased, and the speed of database processing is increased.

This effect is remarkable in a parallel database system having a large number of nodes where data transfer frequently occurs.

[Brief description of the drawings]

FIG. 1 is a schematic diagram of database processing using a proxy instance

FIG. 2 is a hardware configuration diagram.

FIG. 3 is a configuration diagram of a database system.

FIG. 4 is a flowchart of attribute reference of an instance using a proxy instance-1.

FIG. 5 is a flowchart of attribute reference of an instance using a proxy instance-2.

FIG. 6 shows a state after a proxy instance is replaced with a real instance.

FIG. 7 is a schematic diagram of taking out a long instance using a proxy instance.

FIG. 8 is a flowchart of taking out a long-sized instance using a proxy instance-1.

FIG. 9 is a flowchart of taking out a long instance using a proxy instance;

FIG. 10 is a schematic diagram of insertion of a long instance using a proxy instance.

FIG. 11 is a flowchart of inserting a long instance using a proxy instance.

[Explanation of symbols]

100 ... network or inter-process communication, 101 ...
Inquiry execution node, 102: database access node, 103: database, 104: operation of stored instance, 105: instance management, 111: cache management information of proxy instance,
112: Data cache area of proxy instance, 1
80 handle, 190 instance management information, 31
1: Inquiry analysis unit, 312: Static optimization processing, 3
13: code generation, 314: dynamic optimization processing, 31
5: execution of code analysis, 700: application program, 701: long instance work area.

 ──────────────────────────────────────────────────続 き Continuing on the front page (72) Inventor Yoshito Kamejo 5030 Totsukacho, Totsuka-ku, Yokohama-shi, Kanagawa Prefecture Software Development Division, Hitachi, Ltd.

Claims (8)

[Claims] 1. A database processing method in a parallel database system comprising a plurality of nodes for performing database processing, each node being connected to another node via a network, wherein information on a part of an instance stored in a database is provided. And the information that can access the instance stored in the aforementioned database is stored in the proxy instance which is an instance of a smaller area than the instance stored in the aforementioned database, and is stored in the aforementioned database. A database processing method, wherein database processing is performed using information on a part of the instance stored in the database, stored in the proxy instance, instead of the instance being performed. 2. The method according to claim 1, wherein the database processing according to claim 1 is stored in a proxy instance according to claim 1.
2. If the information cannot be obtained by only information on a part of the instance stored in the database, the instance stored in the database described in claim 1 can be accessed. A database processing method characterized by performing the above-mentioned database processing by accessing an instance stored in the above-mentioned database from basic information. 3. The instance stored in the database of claim 1 and its proxy instance each have instance management information of the same structure, and can be accessed by handles of the same structure, respectively. A database processing method characterized in that an instance stored in the database and its proxy instance are distinguished only by a flag for identifying the instance. 4. The proxy instance according to claim 1, wherein said information has already been set with respect to information of a part of the instance stored in said database stored in said proxy instance. Stores the configuration status information that manages the status of the proxy instance in the proxy instance described above, checks the configuration status when accessing the proxy instance, and stores it in the database if the information to be configured is not set A database processing method characterized in that when accessing a set instance or when acquiring the information to be set, the information is set. 5. The type definition of the proxy instance of claim 1, which part of the information of a part of the instance stored in the database of claim 1 stored in the proxy instance is stored. And means that can be specified at the time of table generation, register the specified contents in the dictionary, and when acquiring the handle to the instance stored in the above database, according to the above registered contents, A database processing method characterized by issuing a query for obtaining information of a part of a stored instance together, and generating a proxy instance using a result of the query. 6. The database system determines which part of the instance stored in the database according to claim 5 is to be stored in the proxy instance from the analysis result of the inquiry, the statistical information, and the state of the instance. When obtaining the handle to the stored instance, issue a query that also obtains information on a part of the instance stored in the database according to the above-described determined contents, and returns the result of the query. And generating a proxy instance by using the database processing method. 7. In the database processing of fetching an instance, if the instance stored in the database is long, instead of returning the handle to the long instance, a proxy instance is generated and the proxy is generated. A database processing method characterized by storing control information capable of dividing and transferring the above-mentioned long instance into an instance, thereby preventing the long instance from being expanded on a memory. 8. When inserting a long instance into a database, instead of generating a long instance, a proxy instance storing control information capable of dividing and transferring the long instance is generated. A database processing method for preventing a long instance from being expanded on a memory.