JP2718427B2 - Data access method in large-scale knowledge base - Google Patents

Description

DETAILED DESCRIPTION OF THE INVENTION [Overview] Regarding an efficient data access method for a large-scale database in various object-oriented database systems, it is necessary to convert a program written by a user to a large-scale database into an efficient procedure. The purpose is to analyze the procedural statements in the user program by analyzing the procedural statements in the user program, and generating the function definition for the elements of the set and the function definition for the entire set as separate functions based on the function definition of the user program. A procedure analysis unit that separates and extracts a statement object, a procedure attribute name, and a parameter; a procedure generation unit that generates a conversion program from the user program using information obtained by the procedure analysis unit; Compiler for translating into modules Means, and a linker means for combining the generated object module and the execution library to generate a load module.

[Industrial applications]

The present invention relates to an efficient data access method for a large-scale database in various object-oriented database systems.

[Conventional technology]

In a conventional object-oriented system, when processing is performed on an entire set, a program describing processing on a set element is applied to each element of the set. Also, the processing program for the entire set needs to be created again as a program different from the program for the elements.

[Problems to be solved by the invention]

However, such a conventional method is extremely inefficient due to the overhead of calling a function for each element when processing a set. Furthermore, it is necessary to prepare a program for collection and a program for elements separately, and there is a problem that productivity of software is deteriorated.

Such a problem is that processing for a set and a processing program for each element are not unified, and in processing for a set, an element program is repeatedly called.

An object of the present invention is to convert a program described by a user in a large-scale database into an efficient procedure.

[Means for solving the problem]

 FIG. 1 shows a functional block diagram of the present invention.

The conversion means 2 comprises a program generation means, a procedure analysis means, and a procedure generation means.
Generate

The compiler 4 translates the generated conversion program 3 and generates an object module 5.

The linker 7 searches the execution library 6 for a runtime routine that is externally referenced in the object module 5, and combines them to generate a load module 8, which is an executable program.

[Action]

In FIG. 1, a conversion means 2 reads a user program 1 and automatically generates a conversion program 3. that time,
In the program described by the user, the description of the process for accessing the database is unified for the elements and the entire set.

The conversion means 2 defines another function in the most efficient form for each of the element and the entire set from the unified description sentence.

Of the program statements of the user program 1, statements referring to the function defined in this way are converted as the above-described different functions depending on whether the processing target at the time of the reference is a set, and the efficiency is improved. Good conversion program 3
Is generated.

As described above, since the user does not need to be aware of the difference between the element use and the set use during programming, the effort required for creating, operating, and maintaining the program is reduced.
The generated conversion program can execute processing for the entire set at high speed.

〔Example〕

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

FIG. 2 is a configuration diagram of one embodiment of the conversion unit 2 of FIG. It is possible to automatically generate a function for efficiently accessing the large-scale knowledge database for each of the elements and the sets from the user's program of the present embodiment, and thereby reduce the burden when the user performs programming. Show what you can do.

First, the program generation unit 1 (10) and the program generation unit 2 (11) determine the elements of the set from the definition of the procedure that processes both the elements of the set and the entire set described in the user program 1. A set function 12 and a set function 13 for the entire set are generated. The procedure in the user program 1 is a description that does not distinguish between accessing each element and accessing the entire set. The programmer needs to be aware of the difference in processing depending on the attribute to be accessed. Absent.

Next, with respect to a part of the user program 1 that refers to such a procedure, the procedure analyzing unit 14 and the procedure generating unit
By means of 15, conversion into an executable statement translatable by the compiler is performed, and a conversion program 3 is obtained.

FIG. 3 shows a specific example in which a function is automatically generated from a program 1 defined by a user in the user-defined language Jasmine / C language. In this embodiment, a procedure (void type function) name () for displaying the name of an individual indicated by a character type pointer variable * name and the age indicated by a short type integer variable age is defined in the user program 1. ing. This procedural function has a description format that has no arguments, the processing target is both the elements of the set and the entire set, and the programmer does not need to be aware of the description of the function due to the difference between the target objects. From the user's function definition, the element function msinglel () 12 and the set function
msetl () 13 is generated. Each procedural function is generated for the target object so as to have the most efficient processing form. In the embodiment of FIG. 3, optimization is performed based on whether or not a loop is included in the function. I'm trying. As a result, the user can perform programming without being conscious of the difference between the processing for each of the element and the set, thereby improving the productivity of the software and achieving high-speed processing due to the high efficiency of the generated function.

FIG. 4 shows a procedure for generating the set function msetl () 13. First, the type definition of the function is generated in S1, and then the function name is generated in S2. Function names begin with the string "mset", which represents the operation on the set, followed immediately by a unique number concatenated to each function. The first parameter of the function is a variable "selv" that points to the database file.
es ". If the remaining parameters are specified by the user, they are added in S3. In this embodiment, the function name () of the user program 1 is used.
Since there are no other arguments from the definition of, the processing moves to the generation of the next parameter definition (argument declaration) of S4, and the variable "selve
"s" is declared by the variable type "IDS", where the IDS type is a user-defined type used to indicate a database file. If there are other function parameters, as in S3, the parameter In S6, the definitions of “self” and “scan” are created among the local variables used in this function. The user-defined type ID identifies the individual contained in the database file. SCAN is a pointer type to the current list. The definition of the remaining local variables is created in S7. This function mset for the entire set uses open / close processing and ,
Include a loop inside the function to process the entire set,
Then, an open statement and a loop statement in the database file are generated, and a close statement is generated in S10. In S9 sandwiched between the two, the execution statement that is the body of the function is converted. Third
In the example of the figure, the name of the individual and the age are printedf
The printf statement to be output as a statement and the assignment statement of personal information for that name = self.name age = self.age correspond to the body of this function.

Since the set function generated according to the procedure of FIG. 4 described above includes a loop for processing the entire set inside, there is no overhead due to repeatedly calling the element function, so that high-speed processing can be realized. Further, this example is an embodiment of a process for accessing the entire set,
It can be easily applied to other sets.

FIG. 5 is a processing procedure of the procedure analysis unit 14 and the procedure generation unit 15, and is a procedure for converting the user program 1 referring to the function definition generated by the program generation unit 1 and the program generation unit 2 described above. It is shown. Among the program statements described in the user program 1, a procedural statement (for example, $ people.nameage ()) that calls the procedural function in FIG. 3 is converted into a translatable form. User program 1 in S11
Is read in S12, the object (＄ people), the procedure attribute name (nameag
e ()) and parameters (none). Next, in S13, the program management table is searched together with the class information and the procedure attribute obtained in S12. In S14, it is determined whether or not the above-mentioned element function definition 12 or set function definition 13 is referred to, and if so, it is further determined whether or not it is for a set (S15). Converted to the format (S16 and S17). Finally,
In S18, a translatable executable statement is generated by the compiler.

FIG. 6 shows an example of a reference example of the element and set functions generated in the user program 1, and an example of the conversion result. Of the executable statements of the user program 1, two statements, ＄ people.nameage (); and ＄ person.nameage () ;, are respectively the generated procedural function msinglel (person) for the element and the procedural function for the set. msetl (peo
ple).

The conversion program statement shown in this embodiment is an example for explaining the processing procedure, and the main body of the processing of the called function is simple. However, according to the present invention, it is possible to automatically generate a program for an element and a set and generate a call format without depending on the processing body of a function, and its application range is large-scale database Over.

〔The invention's effect〕

According to the present invention, a user can describe a program for accessing a database without being aware of the distinction between elements and sets. As a result, the time and cost required for creating, maintaining, and operating a user program can be drastically reduced, and the productivity of software can be improved. Further, the automatically generated conversion program automatically generates an efficient format for each processing object by distinguishing between the element and the set. Therefore, it is possible to construct a flexible system peculiar to an object-oriented system without causing a problem of a processing speed reduction due to a dynamic link when accessing a large amount of data, which is a problem in the conventional object-oriented system. .

[Brief description of the drawings]

FIG. 1 is a functional block diagram of the present invention, FIG. 2 is a configuration diagram of a conversion unit in one embodiment of the present invention, FIG. 3 is an embodiment diagram of program generation, and FIG. FIG. 5 is a flowchart showing a procedure of a procedure analysis unit and a procedure generation unit, and FIG. 6 is a diagram showing an example of program use and conversion. 1 ... User program, 2 ... Converter, 3 ... Converter, 4 ... Compiler, 5 ... Object module, 6 ... Execution library, 7 ... Linker, 8 ... Load module.

Claims (3)

(57) [Claims] Claims: 1. Based on a function definition of a user program,
A program generation means for generating the function definition for the elements of the set and the function definition of the entire set as separate functions, and analyzing the procedural statements in the user program to separate and extract the procedural statement object, procedure attribute names, and parameters Procedural analysis means for performing, a procedure generating means for generating a conversion program from the user program using information obtained by the procedural analysis means, and a compiler means for translating the conversion program into an object module. And a linker for combining the object module and the execution library to generate a load module. 2. The program generating means comprises a first program generating unit and a second program generating unit for automatically generating a function definition from the user program, wherein the first program generating unit is configured to generate a function definition from the user program. An element function definition for processing an element of a set is automatically generated, and the second program generation unit automatically generates a function definition for a processing for processing the entire set from the user program. Item 10. The database access method according to Item 1. 3. The procedure analysis means separates and extracts an object, a procedure attribute name and a parameter from a program sentence of the user program, and the procedure generation means also extracts a procedure attribute name extracted by the procedure analysis means. Detecting a program statement referring to the function definition generated by the program generation unit, further determining whether the program is for a set, and generating an execution statement of the conversion program based on the result. Item 10. The database access method according to Item 1.